bluecellulab 2.2.2__tar.gz → 2.2.4__tar.gz

{bluecellulab-2.2.2 → bluecellulab-2.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bluecellulab
-Version: 2.2.2
+Version: 2.2.4
 Summary: The Pythonic Blue Brain simulator access
 Home-page: https://github.com/BlueBrain/BlueCelluLab
 Author: Blue Brain Project, EPFL

{bluecellulab-2.2.2 → bluecellulab-2.2.4}/bluecellulab/cell/core.py

@@ -101,9 +101,6 @@ class Cell(InjectableMixin, PlottableMixin):
 
         self.cellname = neuron.h.secname(sec=self.soma).split(".")[0]
 
-        # Set the gid of the cell
-        self.cell.getCell().gid = self.cell_id.id
-
         if rng_settings is None:
             self.rng_settings = RNGSettings("Random123")  # SONATA value
         else:
@@ -121,11 +118,11 @@ class Cell(InjectableMixin, PlottableMixin):
         # time recording needs this push
         self.soma.push()
         self.hocname = neuron.h.secname(sec=self.soma).split(".")[0]
-        self.somatic = [x for x in public_hoc_cell(self.cell).somatic]
-        self.basal = [x for x in public_hoc_cell(self.cell).basal]  # dend is same as basal
-        self.apical = [x for x in public_hoc_cell(self.cell).apical]
-        self.axonal = [x for x in public_hoc_cell(self.cell).axonal]
-        self.all = [x for x in public_hoc_cell(self.cell).all]
+        self.somatic = list(public_hoc_cell(self.cell).somatic)
+        self.basal = list(public_hoc_cell(self.cell).basal)  # dend is same as basal
+        self.apical = list(public_hoc_cell(self.cell).apical)
+        self.axonal = list(public_hoc_cell(self.cell).axonal)
+        self.all = list(public_hoc_cell(self.cell).all)
         self.record_dt = record_dt
         self.add_recordings(['self.soma(0.5)._ref_v', 'neuron.h._ref_t'],
                             dt=self.record_dt)
@@ -560,11 +557,7 @@ class Cell(InjectableMixin, PlottableMixin):
             syn_description, self
         )
 
-        if 'Weight' in connection_modifiers:
-            weight_scalar = connection_modifiers['Weight']
-        else:
-            weight_scalar = 1.0
-
+        weight_scalar = connection_modifiers.get('Weight', 1.0)
         exc_mini_frequency, inh_mini_frequency = mini_frequencies \
             if mini_frequencies is not None else (None, None)
 
@@ -573,11 +566,10 @@ class Cell(InjectableMixin, PlottableMixin):
         # SpontMinis in sim config takes precedence of values in nodes file
         if 'SpontMinis' in connection_modifiers:
             spont_minis_rate = connection_modifiers['SpontMinis']
+        elif synapse.mech_name in ["GluSynapse", "ProbAMPANMDA_EMS"]:
+            spont_minis_rate = exc_mini_frequency
         else:
-            if synapse.mech_name in ["GluSynapse", "ProbAMPANMDA_EMS"]:
-                spont_minis_rate = exc_mini_frequency
-            else:
-                spont_minis_rate = inh_mini_frequency
+            spont_minis_rate = inh_mini_frequency
 
         if spont_minis_rate is not None and spont_minis_rate > 0:
             sec = self.get_hsection(post_sec_id)
@@ -590,8 +582,7 @@ class Cell(InjectableMixin, PlottableMixin):
             self.syn_mini_netcons[synapse_id].delay = 0.1
             self.syn_mini_netcons[synapse_id].weight[0] = weight * weight_scalar
             # set netcon type
-            nc_param_name = 'nc_type_param_{}'.format(
-                synapse.hsynapse).split('[')[0]
+            nc_param_name = f'nc_type_param_{synapse.hsynapse}'.split('[')[0]
             if hasattr(neuron.h, nc_param_name):
                 nc_type_param = int(getattr(neuron.h, nc_param_name))
                 # NC_SPONTMINI
@@ -655,7 +646,7 @@ class Cell(InjectableMixin, PlottableMixin):
         """Get the children section of a neuron section."""
         number_children = neuron.h.SectionRef(sec=parentsection).nchild()
         children = []
-        for index in range(0, int(number_children)):
+        for index in range(int(number_children)):
             children.append(neuron.h.SectionRef(sec=self.soma).child[index])
         return children
 
@@ -679,10 +670,10 @@ class Cell(InjectableMixin, PlottableMixin):
             self.get_recording(secname)
             self.get_recording(child)
 
-    def somatic_branches(self):
+    def somatic_branches(self) -> None:
         """Show the index numbers."""
         nchild = neuron.h.SectionRef(sec=self.soma).nchild()
-        for index in range(0, int(nchild)):
+        for index in range(int(nchild)):
             secname = neuron.h.secname(sec=neuron.h.SectionRef(
                 sec=self.soma).child[index])
             if "axon" not in secname:
@@ -699,9 +690,9 @@ class Cell(InjectableMixin, PlottableMixin):
                                     public_hoc_cell(self.cell).nSecBasal + apicnumber)
                     logger.info((apicnumber, secnumber))
                 else:
-                    raise Exception(
-                        "somaticbranches: No apic or \
-                                dend found in section %s" % secname)
+                    raise BluecellulabError(
+                        f"somaticbranches: No apic or dend found in section {secname}"
+                    )
 
     @staticmethod
     @deprecated("Use bluecellulab.cell.section_distance.EuclideanSectionDistance instead.")
@@ -743,7 +734,7 @@ class Cell(InjectableMixin, PlottableMixin):
 
                 children = [
                     neuron.h.SectionRef(sec=max_diam_section).child[index]
-                    for index in range(0, int(neuron.h.SectionRef(
+                    for index in range(int(neuron.h.SectionRef(
                         sec=max_diam_section).nchild()))]
                 if len(children) == 0:
                     break
@@ -808,18 +799,14 @@ class Cell(InjectableMixin, PlottableMixin):
     @property
     def info_dict(self):
         """Return a dictionary with all the information of this cell."""
-
-        cell_info = {}
-
-        cell_info['synapses'] = {}
-        for sid, synapse in self.synapses.items():
-            cell_info['synapses'][sid] = synapse.info_dict
-
-        cell_info['connections'] = {}
-        for sid, connection in self.connections.items():
-            cell_info['connections'][sid] = connection.info_dict
-
-        return cell_info
+        return {
+            'synapses': {
+                sid: synapse.info_dict for sid, synapse in self.synapses.items()
+            },
+            'connections': {
+                sid: connection.info_dict for sid, connection in self.connections.items()
+            }
+        }
 
     def delete(self):
         """Delete the cell."""

{bluecellulab-2.2.2 → bluecellulab-2.2.4}/bluecellulab/circuit/circuit_access.py

@@ -557,7 +557,7 @@ class SonataCircuitAccess:
         edges = self._circuit.edges
         # select edges that are in the projections, if there are projections
         if projections is None or len(projections) == 0:
-            edge_population_names = [x for x in edges]
+            edge_population_names = list(edges)
         elif isinstance(projections, str):
             edge_population_names = [x for x in edges if edges[x].source.name == projections]
         else:

{bluecellulab-2.2.2 → bluecellulab-2.2.4}/bluecellulab/plotwindow.py

@@ -52,7 +52,7 @@ class PlotWindow:
             # Sorry, don't see a way but disable this warning to access this
             colors = pylab.rcParams['axes.prop_cycle'].by_key()['color']
 
-            linecolors = [x for x in itertools.islice(itertools.cycle(colors), 0, 50)]
+            linecolors = list(itertools.islice(itertools.cycle(colors), 0, 50))
 
             self.line[var_name] = pylab.Line2D(
                 time, recording, label=var_name,

{bluecellulab-2.2.2 → bluecellulab-2.2.4}/bluecellulab/psection.py

@@ -124,7 +124,7 @@ class PSection:
 
     def getAllPDescendants(self):
         """Return all the psection that are descendants of this psection."""
-        pdescendants = [x for x in self.pchildren]
+        pdescendants = list(self.pchildren)
         for child in self.pchildren:
             pdescendants += child.getAllPDescendants()
         return pdescendants
@@ -158,10 +158,7 @@ class PSection:
         if self.isLeaf:
             treeWidth = self.maxsegdiam + self.xSpacing
         else:
-            treeWidth = 0
-            for child in self.pchildren:
-                treeWidth += child.treeWidth()
-
+            treeWidth = sum(child.treeWidth() for child in self.pchildren)
         return max(self.diam + self.xSpacing, treeWidth)
 
     def treeHeight(self):

{bluecellulab-2.2.2 → bluecellulab-2.2.4}/bluecellulab.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bluecellulab
-Version: 2.2.2
+Version: 2.2.4
 Summary: The Pythonic Blue Brain simulator access
 Home-page: https://github.com/BlueBrain/BlueCelluLab
 Author: Blue Brain Project, EPFL

{bluecellulab-2.2.2 → bluecellulab-2.2.4}/bluecellulab.egg-info/SOURCES.txt

@@ -199,6 +199,8 @@ tests/examples/ballstick_cell/analytic_expsyn.txt
 tests/examples/ballstick_cell/ballstick.asc
 tests/examples/ballstick_cell/ballstick.hoc
 tests/examples/ballstick_cell/bs.cfg
+tests/examples/bpo_cell/0_cADpyr_L5TPC_a6e707a_1_sNone.hoc
+tests/examples/bpo_cell/C060114A5.asc
 tests/examples/cell_example1/test_cell.asc
 tests/examples/cell_example1/test_cell.hoc
 tests/examples/cell_example1/test_cell_longname1.hoc

bluecellulab-2.2.4/tests/examples/bpo_cell/0_cADpyr_L5TPC_a6e707a_1_sNone.hoc

@@ -0,0 +1,399 @@
+/*
+Created by BluePyOpt(1.6.4) at 2017-11-20 08:35:16.366371
+*/
+{load_file("stdrun.hoc")}
+{load_file("import3d.hoc")}
+/*
+ * Check that global parameters are the same as with the optimization
+ */
+proc check_parameter(/* name, expected_value, value */){
+  strdef error
+  if($2 != $3){
+    sprint(error, "Parameter %s has different value %f != %f", $s1, $2, $3)
+    execerror(error)
+  }
+}
+proc check_simulator() {
+  check_parameter("celsius", 34, celsius)
+  check_parameter("v_init", -80, v_init)
+}
+
+begintemplate cADpyr_L5TPC
+  public init, morphology, geom_nseg_fixed, geom_nsec
+  public soma, dend, apic, axon, myelin
+  create soma[1], dend[1], apic[1], axon[1], myelin[1]
+
+  objref this, CellRef, segCounts
+
+  public all, somatic, apical, axonal, basal, myelinated, APC
+  objref all, somatic, apical, axonal, basal, myelinated, APC
+
+proc init(/* args: morphology_dir, morphology_name */) {
+  all = new SectionList()
+  apical = new SectionList()
+  axonal = new SectionList()
+  basal = new SectionList()
+  somatic = new SectionList()
+  myelinated = new SectionList()
+
+  //For compatibility with BBP CCells
+  CellRef = this
+
+  forall delete_section()
+
+  if(numarg() >= 2) {
+    load_morphology($s1, $s2)
+  } else {
+    load_morphology($s1, "C060114A5.asc")
+  }
+
+  geom_nseg()
+    replace_axon()
+  insertChannel()
+  biophys()
+  re_init_rng()
+}
+
+proc load_morphology(/* morphology_dir, morphology_name */) {localobj morph, import, sf, extension
+  strdef morph_path
+  sprint(morph_path, "%s/%s", $s1, $s2)
+
+  sf = new StringFunctions()
+  extension = new String()
+
+  sscanf(morph_path, "%s", extension.s)
+  sf.right(extension.s, sf.len(extension.s)-4)
+
+  if( strcmp(extension.s, ".asc") == 0 ) {
+    morph = new Import3d_Neurolucida3()
+  } else if( strcmp(extension.s, ".swc" ) == 0) {
+    morph = new Import3d_SWC_read()
+  } else {
+    printf("Unsupported file format: Morphology file has to end with .asc or .swc" )
+    quit()
+  }
+
+  morph.quiet = 1
+  morph.input(morph_path)
+
+  import = new Import3d_GUI(morph, 0)
+  import.instantiate(this)
+}
+
+/*
+ * Assignment of mechanism values based on distance from the soma
+ * Matches the BluePyOpt method
+ */
+proc distribute_distance(){local x localobj sl
+  strdef stmp, distfunc, mech
+
+  sl = $o1
+  mech = $s2
+  distfunc = $s3
+  this.soma[0] distance(0, 0.5)
+  sprint(distfunc, "%%s %s(%%f) = %s", mech, distfunc)
+  forsec sl for(x, 0) {
+    sprint(stmp, distfunc, secname(), x, distance(x))
+    execute(stmp)
+  }
+}
+
+proc geom_nseg() {
+  this.geom_nsec() //To count all sections
+  //TODO: geom_nseg_fixed depends on segCounts which is calculated by
+  //  geom_nsec.  Can this be collapsed?
+  this.geom_nseg_fixed(40)
+  this.geom_nsec() //To count all sections
+}
+
+proc insertChannel() {
+  forsec this.all {
+    insert pas
+  }
+  forsec this.apical {
+    insert CaDynamics_DC0
+    insert Ca_HVA2
+    insert Ca_LVAst
+    insert NaTg
+    insert SKv3_1
+    insert Ih
+  }
+  forsec this.axonal {
+    insert CaDynamics_DC0
+    insert Ca_HVA2
+    insert Ca_LVAst
+    insert SKv3_1
+    insert SK_E2
+    insert K_Pst
+    insert K_Tst
+    insert NaTg
+    insert Nap_Et2
+  }
+  forsec this.basal {
+    insert CaDynamics_DC0
+    insert Ca_HVA2
+    insert Ca_LVAst
+    insert Ih
+  }
+  forsec this.somatic {
+    insert CaDynamics_DC0
+    insert Ca_HVA2
+    insert Ca_LVAst
+    insert SKv3_1
+    insert SK_E2
+    insert K_Pst
+    insert K_Tst
+    insert NaTg
+    insert Ih
+  }
+  forsec this.myelinated {
+  }
+}
+
+proc biophys() {
+  
+  forsec CellRef.all {
+    Ra = 100
+    g_pas = 4.7051946481499811e-05
+    e_pas = -79.603749561469684
+  }
+  
+  forsec CellRef.apical {
+    cm = 2
+    ena = 50
+    ek = -90
+    gamma_CaDynamics_DC0 = 0.04517010601950254
+    vshiftm_NaTg = 6
+    vshifth_NaTg = 6
+    gSKv3_1bar_SKv3_1 = 0.0018178286052065377
+    gCa_HVAbar_Ca_HVA2 = 3.4636229677800608e-06
+    gCa_LVAstbar_Ca_LVAst = 0.00098549473641638421
+  }
+  
+  forsec CellRef.axonal {
+    cm = 1
+    ena = 50
+    ek = -90
+    vshifth_NaTg = 10
+    slopem_NaTg = 9
+    gNaTgbar_NaTg = 0.33556102181366648
+    gNap_Et2bar_Nap_Et2 = 0.0050542837974557036
+    gK_Pstbar_K_Pst = 0.99801140749927841
+    gK_Tstbar_K_Tst = 0.064027490811985444
+    gSKv3_1bar_SKv3_1 = 0.21965904565617991
+    gCa_HVAbar_Ca_HVA2 = 0.00050971480143243212
+    gCa_LVAstbar_Ca_LVAst = 0.0009394854482623271
+    gSK_E2bar_SK_E2 = 0.096808660670667457
+    decay_CaDynamics_DC0 = 285.46128321068517
+    gamma_CaDynamics_DC0 = 0.012752321129750291
+  }
+  
+  forsec CellRef.basal {
+    cm = 2
+    gamma_CaDynamics_DC0 = 0.048834292167029961
+    gCa_HVAbar_Ca_HVA2 = 7.4498164370347347e-05
+    gCa_LVAstbar_Ca_LVAst = 0.00074352999455036864
+  }
+  
+  forsec CellRef.somatic {
+    cm = 1
+    ena = 50
+    ek = -90
+    vshiftm_NaTg = 13
+    vshifth_NaTg = 15
+    slopem_NaTg = 7
+    gNaTgbar_NaTg = 0.28992456437225478
+    gK_Pstbar_K_Pst = 0.10031922891367806
+    gK_Tstbar_K_Tst = 0.013153142654420691
+    gSKv3_1bar_SKv3_1 = 0.38829177538605941
+    gCa_HVAbar_Ca_HVA2 = 0.00083534595739915185
+    gCa_LVAstbar_Ca_LVAst = 0.00021537640631977598
+    gSK_E2bar_SK_E2 = 0.020239349931865241
+    decay_CaDynamics_DC0 = 282.09663415587323
+    gamma_CaDynamics_DC0 = 0.022091065777470664
+  }
+  
+  forsec CellRef.myelinated {
+    cm = 0.02
+  }
+  
+  distribute_distance(CellRef.apical, "gIhbar_Ih", "(-0.8696 + 2.087*exp((%.17g)*0.0031))*2.6113487420290699e-05")
+  distribute_distance(CellRef.apical, "gNaTgbar_NaTg", "exp(%.17g*-0.00453252486077)*0.081013620392016858")
+  distribute_distance(CellRef.basal, "gIhbar_Ih", "(-0.8696 + 2.087*exp((%.17g)*0.0031))*2.6113487420290699e-05")
+  distribute_distance(CellRef.somatic, "gIhbar_Ih", "(-0.8696 + 2.087*exp((%.17g)*0.0031))*2.6113487420290699e-05")
+}
+
+func sec_count(/* SectionList */) { local nSec
+  nSec = 0
+  forsec $o1 {
+      nSec += 1
+  }
+  return nSec
+}
+
+/*
+ * Iterate over the section and compute how many segments should be allocate to
+ * each.
+ */
+proc geom_nseg_fixed(/* chunkSize */) { local secIndex, chunkSize
+  chunkSize = $1
+  soma area(.5) // make sure diam reflects 3d points
+  secIndex = 0
+  forsec all {
+    nseg = 1 + 2*int(L/chunkSize)
+    segCounts.x[secIndex] = nseg
+    secIndex += 1
+  }
+}
+
+/*
+ * Count up the number of sections
+ */
+proc geom_nsec() { local nSec
+  nSecAll = sec_count(all)
+  nSecSoma = sec_count(somatic)
+  nSecApical = sec_count(apical)
+  nSecBasal = sec_count(basal)
+  nSecMyelinated = sec_count(myelinated)
+  nSecAxonalOrig = nSecAxonal = sec_count(axonal)
+
+  segCounts = new Vector()
+  segCounts.resize(nSecAll)
+  nSec = 0
+  forsec all {
+    segCounts.x[nSec] = nseg
+    nSec += 1
+  }
+}
+
+/*
+ * Replace the axon built from the original morphology file with a stub axon
+ */
+    
+    proc replace_axon(){ local nSec, L_chunk, dist, i1, i2, count, L_target, chunkSize, L_real localobj diams, lens
+
+        L_target = 60  // length of stub axon
+        nseg0 = 5  // number of segments for each of the two axon sections
+
+        nseg_total = nseg0 * 2
+        chunkSize = L_target/nseg_total
+
+        nSec = 0
+        forsec axonal{nSec = nSec + 1}
+
+        // Try to grab info from original axon
+        if(nSec < 3){ //At least two axon sections have to be present!
+
+            execerror("Less than three axon sections are present! This emodel can't be run with such a morphology!")
+
+        } else {
+
+            diams = new Vector()
+            lens = new Vector()
+
+            access axon[0]
+            axon[0] i1 = v(0.0001) // used when serializing sections prior to sim start
+            axon[1] i2 = v(0.0001) // used when serializing sections prior to sim start
+            axon[2] i3 = v(0.0001) // used when serializing sections prior to sim start
+
+            count = 0
+            forsec axonal{ // loop through all axon sections
+
+                nseg = 1 + int(L/chunkSize/2.)*2  //nseg to get diameter
+
+                for (x) {
+                    if (x > 0 && x < 1) {
+                        count = count + 1
+                        diams.resize(count)
+                        diams.x[count-1] = diam(x)
+                        lens.resize(count)
+                        lens.x[count-1] = L/nseg
+                        if( count == nseg_total ){
+                            break
+                        }
+                    }
+                }
+                if( count == nseg_total ){
+                    break
+                }
+            }
+
+            // get rid of the old axon
+            forsec axonal{delete_section()}
+            execute1("create axon[2]", CellRef)
+
+            L_real = 0
+            count = 0
+
+            // new axon dependant on old diameters
+            for i=0,1{
+                access axon[i]
+                L =  L_target/2
+                nseg = nseg_total/2
+
+                for (x) {
+                    if (x > 0 && x < 1) {
+                        diam(x) = diams.x[count]
+                        L_real = L_real+lens.x[count]
+                        count = count + 1
+                    }
+                }
+
+                all.append()
+                axonal.append()
+
+                if (i == 0) {
+                    v(0.0001) = i1
+                } else {
+                    v(0.0001) = i2
+                }
+            }
+
+            nSecAxonal = 2
+            soma[0] connect axon[0](0), 1
+            axon[0] connect axon[1](0), 1
+
+            create myelin[1]
+            access myelin{
+                    L = 1000
+                    diam = diams.x[count-1]
+                    nseg = 5
+                    v(0.0001) = i3
+                    all.append()
+                    myelinated.append()
+            }
+            connect myelin(0), axon[1](1)
+        }
+    }
+
+
+
+
+func hash_str() {localobj sf strdef right
+  sf = new StringFunctions()
+
+  right = $s1
+
+  n_of_c = sf.len(right)
+
+  hash = 0
+  char_int = 0
+  for i = 0, n_of_c - 1 {
+     sscanf(right, "%c", & char_int)
+     hash = (hash * 31 + char_int) % (2 ^ 31 - 1)
+     sf.right(right, 1)
+  }
+
+  return hash
+}
+
+proc re_init_rng() {localobj sf
+  strdef full_str, name
+
+  sf = new StringFunctions()
+
+  
+}
+
+
+endtemplate cADpyr_L5TPC