rm workflow

Author: alejoe91

.coveragerc

@@ -1,2 +1,4 @@
 [run]
-omit = */tests/*
+omit = */tests/*,bluepyopt/_version.py
+[report]
+omit=bluepyopt/_version.py

.github/workflows/build.yml

@@ -0,0 +1,37 @@
+name: Build
+
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - '[0-9]+.[0-9]+.[0-9]+'
+
+jobs:
+  call-test-workflow:
+    uses: BlueBrain/BluePyOpt/.github/workflows/test.yml@master
+  
+  build-n-publish:
+    name: Build and publish on PyPI
+    runs-on: ubuntu-latest
+    needs: call-test-workflow
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python 3.6
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.6
+
+      - name: Build a source tarball and wheel
+        run: |
+            pip install wheel
+            python setup.py sdist bdist_wheel
+
+      - name: Publish package to PyPI
+        uses: pypa/gh-action-pypi-publish@master
+        with:
+          user: __token__
+          password: ${{ secrets.PYPI_PASSWORD }}

.github/workflows/keep-alive.yml

@@ -0,0 +1,36 @@
+name: Keep-alive
+
+on:
+  schedule:
+    # Runs every sunday at 3 a.m.
+    - cron: '0 3 * * SUN'
+
+jobs:
+  call-test-workflow:
+    uses: BlueBrain/BluePyOpt/.github/workflows/test.yml@master
+  
+  keep-workflow-alive:
+    name: Keep workflow alive
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          ref: master
+
+      - name: Get date from 50 days ago
+        run: |
+          datethen=`date -d "-50 days" --utc +%FT%TZ`
+          echo "datelimit=$datethen" >> $GITHUB_ENV
+
+      - name: setup git config
+        if: github.event.base.repo.updated_at <= env.datelimit
+        run: |
+          # setup the username and email.
+          git config user.name "Github Actions Keepalive Bot"
+          git config user.email "<>"
+
+      - name: commit IF last commit is older than 50 days
+        if: github.event.base.repo.updated_at <= env.datelimit
+        run: |
+          git commit -m "Empty commit to keep the gihub workflows alive" --allow-empty
+          git push origin master

.github/workflows/main.yml

@@ -0,0 +1,35 @@
+name: Test
+
+on:
+  pull_request:
+  # allows this workflow to be reusable (e.g. by the build workflow)
+  workflow_call:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.6", "3.7", "3.8", "3.9", "3.10"]
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v2
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip setuptools
+        pip install tox tox-gh-actions
+
+    - name: Run tox
+      run: tox
+
+    - name: "Upload coverage to Codecov"
+      uses: codecov/codecov-action@v2
+      with:
+        token: ${{ secrets.CODECOV_TOKEN }}
+        fail_ci_if_error: false

.github/workflows/test.yml

@@ -97,6 +97,10 @@ When you use the BluePyOpt software or method for your research, we ask you to c
 	}
 
 
+Publications that use or mention BluePyOpt
+==========================================
+The list of publications that use or mention BluePyOpt can be found on `the github wiki page <https://github.com/BlueBrain/BluePyOpt/wiki/Publications-that-use-or-mention-BluePyOpt>`_.
+
 Support
 =======
 We are providing support using a chat channel on `Gitter <https://gitter.im/BlueBrain/BluePyOpt>`_, or the `Github discussion page <https://github.com/BlueBrain/BluePyOpt/discussions>`_.

README.rst

@@ -71,7 +71,7 @@ def get_hyped(pop, ubound_score=250., threshold_improvement=240.):
     ubounds = numpy.max(points, axis=0) + 2.0
 
     hv = hype.hypeIndicatorSampled(
-        points=points, bounds=ubounds, k=5, nrOfSamples=200000
+        points=points, bounds=ubounds, k=5, nrOfSamples=1000000
     )
     return hv
 

bluepyopt/deapext/CMA_MO.py

@@ -25,6 +25,7 @@
 
 from bluepyopt.ephys.base import BaseEPhys
 from bluepyopt.ephys.serializer import DictMixin
+import numpy as np
 
 
 class Location(BaseEPhys):
@@ -354,7 +355,7 @@ def __init__(
             name,
             soma_distance=soma_distance,
             seclist_name=sec_name,
-            comment=''
+            comment=comment,
         )
         self.sec_index = sec_index
 
@@ -392,6 +393,74 @@ def instantiate(self, sim=None, icell=None):
         return self.find_icomp(sim, branches)
 
 
+class NrnTrunkSomaDistanceCompLocation(NrnSecSomaDistanceCompLocation):
+    """Location at a distance from soma along a main direction.
+
+    We search for the section that is the furthest away from some along
+    a direction, and pick a location at a given distance from soma along
+    the path to that section.
+
+    If direction == 'radial', the largest radial direction is used.
+
+    This is most useful to follow the trunk of an apical dendrite
+    without knowing the apical point, but only that apical trunk goes along y.
+    """
+
+    def __init__(
+        self,
+        name,
+        soma_distance=None,
+        sec_index=None,
+        sec_name=None,
+        direction=None,
+        comment=""
+    ):
+        """Constructor
+
+        Args:
+            name (str): name of this object
+            soma_distance (float): distance from soma to this compartment
+            sec_index (int): index of the section  to consider
+            sec_name (str): name of Neuron sections (ex: 'apic')
+            direction (list of 3 elements): 3d vector representing direction,
+                if None, default is [0, 1, 0]
+        """
+        super(NrnTrunkSomaDistanceCompLocation, self).__init__(
+            name,
+            soma_distance=soma_distance,
+            sec_index=sec_index,
+            sec_name=sec_name,
+            comment=comment
+        )
+
+        if direction is None:
+            direction = [0.0, 1.0, 0.0]
+        self.direction = direction
+
+    def set_sec_index(self, icell=None):
+        """Search for the point furthest away along given direction."""
+        points = np.array(
+            [
+                [
+                    section.x3d(section.n3d() - 1),
+                    section.y3d(section.n3d() - 1),
+                    section.z3d(section.n3d() - 1),
+                ]
+                for section in getattr(icell, self.seclist_name)
+            ]
+        )
+        if self.direction == 'radial':
+            self.sec_index = int(np.argmax(np.linalg.norm(points, axis=1)))
+        else:
+            self.sec_index = int(np.argmax(points.dot(self.direction)))
+
+    def instantiate(self, sim=None, icell=None):
+        """ """
+        if self.sec_index is None:
+            self.set_sec_index(icell=icell)
+        return super().instantiate(sim=sim, icell=icell)
+
+
 class EPhysLocInstantiateException(Exception):
 
     """All exception generated by location instantiation"""

bluepyopt/ephys/locations.py

@@ -123,18 +123,19 @@ def instantiate_determinism(self, deterministic, icell, isec, sim):
                 (self.suffix),
                 1 if deterministic else 0)
 
-            if not deterministic:
-                # Set the seeds
-                short_secname = sim.neuron.h.secname(sec=isec).split('.')[-1]
-                for iseg in isec:
-                    seg_name = '%s.%.19g' % (short_secname, iseg.x)
-                    getattr(sim.neuron.h,
-                            "setdata_%s" % self.suffix)(iseg.x, sec=isec)
-                    seed_id1 = icell.gid
-                    seed_id2 = self.hash_py(seg_name)
-                    getattr(
-                        sim.neuron.h,
-                        "setRNG_%s" % self.suffix)(seed_id1, seed_id2)
+            # Set the seeds even when deterministic,
+            # that way neuron's psection does not crash
+            # when encountering a stoch mech var that is not set (e.g. rng)
+            short_secname = sim.neuron.h.secname(sec=isec).split('.')[-1]
+            for iseg in isec:
+                seg_name = '%s.%.19g' % (short_secname, iseg.x)
+                getattr(sim.neuron.h,
+                        "setdata_%s" % self.suffix)(iseg.x, sec=isec)
+                seed_id1 = icell.gid
+                seed_id2 = self.hash_py(seg_name)
+                getattr(
+                    sim.neuron.h,
+                    "setRNG_%s" % self.suffix)(seed_id1, seed_id2)
         else:
             if not deterministic:
                 # can't do this for non-Stoch channels