cm_tree.h

Go to the documentation of this file.

/*
 *  cm_tree.h
 *
 *  This file is part of NEST.
 *
 *  Copyright (C) 2004 The NEST Initiative
 *
 *  NEST is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  NEST is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with NEST.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef CM_TREE_H
#define CM_TREE_H
 
#include <stdlib.h>
 
#include "nest_time.h"
#include "ring_buffer.h"
 
// compartmental model
#include "cm_compartmentcurrents.h"
 
// Includes from libnestutil:
#include "dict_util.h"
#include "numerics.h"
 
// Includes from nestkernel:
#include "exceptions.h"
#include "kernel_manager.h"
#include "universal_data_logger_impl.h"
 
 
namespace nest
{
 
class Compartment
{
private:
  double xx_;
  double yy_;
 
public:
  long comp_index;
  long p_index;
  Compartment* parent;
  std::vector< Compartment > children;
 
  RingBuffer currents;
  double ca;  // compartment capacitance [uF]
  double gc;  // coupling conductance with parent (meaningless if root) [uS]
  double gl;  // leak conductance of compartment [uS]
  double el;  // leak current reversal potential [mV]
 
  double v_comp;
 
  double gg0;
  double ca__div__dt;
  double gl__div__2;
  double gc__div__2;
  double gl__times__el;
  double ff;
  double gg;
  double hh;
  int n_passed;
 
  CompartmentCurrents compartment_currents;
 
  Compartment( const long compartment_index, const long parent_index );
  Compartment( const long compartment_index, const long parent_index, const Dictionary& compartment_params );
  ~Compartment() {};
 
  // initialization
  void pre_run_hook();
  std::map< std::string, double* > get_recordables();
 
  void construct_matrix_element( const long lag );
 
  inline void gather_input( const std::pair< double, double >& in );
  inline std::pair< double, double > io();
  inline double calc_v( const double v_in );
};  // Compartment
 
 
/*
Short helper functions for solving the matrix equation. Can hopefully be inlined
*/
inline void
Compartment::gather_input( const std::pair< double, double >& in )
{
  xx_ += in.first;
  yy_ += in.second;
}
 
inline std::pair< double, double >
Compartment::io()
{
  // include inputs from child compartments
  gg -= xx_;
  ff -= yy_;
 
  // output values
  double g_val( hh * hh / gg );
  double f_val( ff * hh / gg );
 
  return std::make_pair( g_val, f_val );
}
 
inline double
Compartment::calc_v( const double v_in )
{
  // reset recursion variables
  xx_ = 0.0;
  yy_ = 0.0;
 
  // compute voltage
  v_comp = ( ff - v_in * hh ) / gg;
 
  return v_comp;
}
 
 
class CompTree
{
private:
  mutable Compartment root_;
  std::vector< long > compartment_indices_;
  std::vector< Compartment* > compartments_;
  std::vector< Compartment* > leafs_;
 
  long size_ = 0;
 
  void solve_matrix_downsweep( Compartment* compartment_ptr, std::vector< Compartment* >::iterator leaf_it );
  void solve_matrix_upsweep( Compartment* compartment, double vv );
 
  void set_parents();
  void set_compartments();
  void set_leafs();
 
public:
  CompTree();
  ~CompTree() {};
 
  void add_compartment( const long parent_index );
  void add_compartment( const long parent_index, const Dictionary& compartment_params );
  void add_compartment( Compartment* compartment, const long parent_index );
 
  void pre_run_hook();
 
  void init_pointers();
 
  void set_syn_buffers( std::vector< RingBuffer >& syn_buffers );
 
  std::map< std::string, double* > get_recordables();
 
  Compartment* get_compartment( const long compartment_index ) const;
  Compartment* get_compartment( const long compartment_index, Compartment* compartment, const long raise_flag ) const;
  Compartment* get_compartment_opt( const long compartment_indx ) const;
  Compartment*
  get_root() const
  {
    return &root_;
  };
 
  long
  get_size() const
  {
    return size_;
  };
 
  std::vector< double > get_voltage() const;
  double get_compartment_voltage( const long compartment_index );
 
  void construct_matrix( const long lag );
  void solve_matrix();
 
  void print_tree() const;
};  // CompTree
 
}  // namespace
 
#endif /* #ifndef CM_TREE_H */