Add connection mask for maximal distnance for 2d positions

Author: FinnBurkhardt

nestkernel/nestmodule.cpp

@@ -1320,14 +1320,15 @@ NestModule::SetMaxBufferedFunction::execute( SLIInterpreter* i ) const
 void
 NestModule::EnableStructuralPlasticity_Function::execute( SLIInterpreter* i ) const
 {
-  i->assert_stack_load( 3 );
-  const bool cache_prob = getValue< bool >( i->OStack.pick( 0 ) );
-  const double sigma = getValue< double >( i->OStack.pick( 1 ) );
-  const bool use_kernel = getValue< bool >( i->OStack.pick( 2 ) );
+  i->assert_stack_load( 4 );
+  const double max_distance = getValue< double >( i->OStack.pick( 0 ) );
+  const bool cache_prob = getValue< bool >( i->OStack.pick( 1 ) );
+  const double sigma = getValue< double >( i->OStack.pick( 2 ) );
+  const bool use_kernel = getValue< bool >( i->OStack.pick( 3 ) );
 
-  kernel().sp_manager.enable_structural_plasticity( use_kernel, sigma, cache_prob );
+  kernel().sp_manager.enable_structural_plasticity( use_kernel, sigma, cache_prob, max_distance );
 
-  i->OStack.pop( 3 );
+  i->OStack.pop( 4 );
   i->EStack.pop();
 }
 void
@@ -2012,8 +2013,8 @@ NestModule::SelectNodesByMask_g_a_MFunction::execute( SLIInterpreter* i ) const
     MaskedLayer< 2 > ml = MaskedLayer< 2 >( *layer, mask, false, layer_nc );
 
     for ( Ntree< 2, size_t >::masked_iterator it = ml.begin( Position< 2 >( anchor[ 0 ], anchor[ 1 ] ) );
-      it != ml.end();
-      ++it )
+          it != ml.end();
+          ++it )
     {
       mask_node_ids.push_back( it->second );
     }
@@ -2029,8 +2030,8 @@ NestModule::SelectNodesByMask_g_a_MFunction::execute( SLIInterpreter* i ) const
     MaskedLayer< 3 > ml = MaskedLayer< 3 >( *layer, mask, false, layer_nc );
 
     for ( Ntree< 3, size_t >::masked_iterator it = ml.begin( Position< 3 >( anchor[ 0 ], anchor[ 1 ], anchor[ 2 ] ) );
-      it != ml.end();
-      ++it )
+          it != ml.end();
+          ++it )
     {
       mask_node_ids.push_back( it->second );
     }

nestkernel/sp_manager.cpp

@@ -32,6 +32,7 @@
 #include "connector_base.h"
 #include "connector_model.h"
 #include "kernel_manager.h"
+#include "mask.h"
 #include "nest_names.h"
 #include "sp_manager_impl.h"
 #include "spatial.h"
@@ -49,6 +50,8 @@ SPManager::SPManager()
   , sp_conn_builders_()
   , growthcurve_factories_()
   , growthcurvedict_( new Dictionary() )
+  , structural_plasticity_max_distance_( std::numeric_limits< double >::infinity() )
+  , distance_mask_template_( nullptr )
 {
 }
 
@@ -274,7 +277,7 @@ SPManager::get_neuron_pair_index( int id1, int id2 )
 {
   int max_id = std::max( id1, id2 );
   int min_id = std::min( id1, id2 );
-  int index = ( ( max_id ) * ( max_id - 1 ) ) / 2 + ( min_id - 1 );
+  int index = ( ( max_id ) *        ( max_id - 1 ) ) / 2 + ( min_id - 1 );
   return index;
 }
 
@@ -304,7 +307,7 @@ SPManager::roulette_wheel_selection( const std::vector< double >& probabilities,
 
   // Perform binary search to find the selected index
   auto it = std::lower_bound( cumulative.begin(), cumulative.end(), randomValue );
-  return static_cast< int >( std::distance( cumulative.begin(), it ) );
+  return static_cast< int >( std::distance(        cumulative.begin(), it ) );
 }
 
 
@@ -365,13 +368,12 @@ SPManager::build_probability_list()
         continue;
       }
 
-      
+
       std::vector< double > pos_j(
         global_positions.begin() + pos_dim * ( id_j - 1 ), global_positions.begin() + pos_dim * id_j );
 
       double prob = gaussian_kernel( pos_i, pos_j, structural_plasticity_gaussian_kernel_sigma_ );
       probability_list[ index ] = prob;
-    
     }
   }
 }
@@ -905,6 +907,16 @@ SPManager::global_shuffle_spatial( std::vector< size_t >& pre_ids,
     size_t pre_id = pre_ids.back();
     pre_ids.pop_back();
 
+
+    // build an AnchoredMask about this pre‐neuron’s position
+    std::vector< double > pre_pos(
+      global_positions.begin() + ( pre_id - 1 ) * pos_dim, global_positions.begin() + pre_id * pos_dim );
+
+    AnchoredMask< 2 > distance_mask( *distance_mask_template_, // the BallMask centered at 0
+      pre_pos                                                  // now anchored at pre_pos
+    );
+
+
     std::vector< double > probabilities;
     std::vector< size_t > valid_post_ids;
     double rnd;
@@ -915,6 +927,16 @@ SPManager::global_shuffle_spatial( std::vector< size_t >& pre_ids,
         continue; // Skip self-connections
       }
 
+      // fetch post position
+      std::vector< double > post_pos(
+        global_positions.begin() + ( post_id - 1 ) * pos_dim, global_positions.begin() + post_id * pos_dim );
+
+      // HARD cutoff via the Mask:
+      if ( !distance_mask.inside( post_pos ) )
+      {
+        continue; // distance > max_distance -> masked out entirely
+      }
+
       double prob;
       if ( structural_plasticity_cache_probabilities_ )
       {
@@ -929,13 +951,14 @@ SPManager::global_shuffle_spatial( std::vector< size_t >& pre_ids,
       }
       else
       {
+        /**
         size_t pre_index = pre_id - 1;
         std::vector< double > pre_pos(
           global_positions.begin() + pre_index * pos_dim, global_positions.begin() + ( pre_index + 1 ) * pos_dim );
 
         size_t post_index = post_id - 1;
         std::vector< double > post_pos(
-          global_positions.begin() + post_index * pos_dim, global_positions.begin() + ( post_index + 1 ) * pos_dim );
+          global_positions.begin() + post_index * pos_dim, global_positions.begin() + ( post_index + 1 ) * pos_dim );**/
 
         prob = gaussian_kernel( pre_pos, post_pos, structural_plasticity_gaussian_kernel_sigma_ );
       }
@@ -973,7 +996,8 @@ SPManager::global_shuffle_spatial( std::vector< size_t >& pre_ids,
 void
 nest::SPManager::enable_structural_plasticity( bool use_gaussian_kernel,
   double gaussian_kernel_sigma,
-  bool cache_probabilities )
+  bool cache_probabilities,
+  double max_distance )
 {
   if ( kernel().vp_manager.get_num_threads() > 1 )
   {
@@ -996,6 +1020,7 @@ nest::SPManager::enable_structural_plasticity( bool use_gaussian_kernel,
   structural_plasticity_cache_probabilities_ = cache_probabilities;
   structural_plasticity_enabled_ = true;
 
+  distance_mask_template_ = std::make_unique< BallMask< 2 > >( Position< 2 > { 0, 0 }, max_distance );
   if ( use_gaussian_kernel )
   {
     gather_global_positions_and_ids();

nestkernel/sp_manager.h

@@ -32,6 +32,7 @@
 
 // Includes from nestkernel:
 #include "growth_curve_factory.h"
+#include "mask.h"
 #include "nest_time.h"
 #include "nest_types.h"
 #include "node_collection.h"
@@ -127,7 +128,10 @@ class SPManager : public ManagerInterface
   /**
    * Enable structural plasticity
    */
-  void enable_structural_plasticity( bool use_gaussian_kernel, double gaussian_kernel_sigma, bool cache_probabilities );
+  void enable_structural_plasticity( bool use_gaussian_kernel,
+    double gaussian_kernel_sigma,
+    bool cache_probabilities,
+    double max_distance = 10000000 );
 
   /**
    * Disable structural plasticity
@@ -284,6 +288,10 @@ class SPManager : public ManagerInterface
    */
   int pos_dim;
 
+
+  double structural_plasticity_max_distance_;
+  std::unique_ptr< Mask< 2 > > distance_mask_template_;
+
   /**
    * List of precomputed probabilities for neuron connections, indexed
    * by neuron pair indices for efficient lookup.

pynest/nest/lib/hl_api_simulation.py

@@ -333,7 +333,7 @@ def Install(module_name):
 
 @check_stack
 def EnableStructuralPlasticity(
-    use_gaussian_kernel=False, gaussian_kernel_sigma=0.0, cache_probabilites=False
+    use_gaussian_kernel=False, gaussian_kernel_sigma=0.0, cache_probabilites=False,  max_distance=float('inf'),
 ):
     """Enable structural plasticity for the network simulation
 
@@ -346,6 +346,7 @@ def EnableStructuralPlasticity(
     sps(bool(use_gaussian_kernel))
     sps(float(gaussian_kernel_sigma))
     sps(bool(cache_probabilites))
+    sps(float(max_distance))
 
     sr("EnableStructuralPlasticity")