def from_file(cls, name): cores = nest.NumProcesses() total_times = [] total_senders = [] for rank in range(cores): filename = name + '.' + str(rank) + '.npy' data = np.load(filename) times = data.item().get('times') senders = data.item().get('senders') total_times.append(times) total_senders.append(senders) return SpikeRecording(np.concatenate(total_times), np.concatenate(total_senders))
def simulate(self): if nest.NumProcesses() > 1: sys.exit("For simplicity, this example only works " + "for a single process.") nest.EnableStructuralPlasticity() print("Starting simulation") sim_steps = numpy.arange(0, self.t_sim, self.record_interval) for i, step in enumerate(sim_steps): nest.Simulate(self.record_interval) self.record_ca() self.record_connectivity() if i % 20 == 0: print("Progress: " + str(i / 2) + "%") print("Simulation finished successfully")
def test_local_vps(self): num_procs = nest.NumProcesses() n_vp = 3 * num_procs nest.SetKernelStatus({'total_num_virtual_procs': n_vp}) local_vps = list(nest.GetLocalVPs()) # Use thread-vp mapping of neurons to check mapping in kernel nrns = nest.GetLocalNodeCollection( nest.Create('iaf_psc_delta', 2 * n_vp)) for n in nrns: thrd = n.get('thread') vp = n.get('vp') assert vp == local_vps[thrd]
def reset_nest(self): nest.ResetKernel() nest.SetKernelStatus({ 'resolution': params.dt, 'print_time': True, 'structural_plasticity_update_interval': int(params.msp_update_interval / params.dt), # update interval for MSP in time steps 'local_num_threads': 1, 'grng_seed': params.grng_seed, 'rng_seeds': range(params.seed + 1, params.seed + 1 + nest.NumProcesses()) })
def main(config_file): nest.SetKernelStatus({"total_num_virtual_procs": comm.Get_size()}) print nest.NumProcesses() print comm.Get_size() configure = config.from_json(config_file) io.setup_output_dir(configure) graph = PointGraph.from_config(configure, network_format=TabularNetwork_AI, property_schema=AIPropertySchema) graph.add_weight_function(fn.wmax) graph.add_weight_function(fn.gaussianLL) net = PointNetwork.from_config(configure, graph) net.run(configure['run']['duration']) assert (spike_files_equal(configure['output']['spikes_ascii'], 'expected/spikes.txt'))
def test_consistent_local_vps(): """ Test local_vps field of kernel status. This test ensures that the PyNEST-generated local_vps information agrees with the thread-VP mappings in the kernel. """ num_procs = nest.NumProcesses() n_vp = 3 * num_procs nest.SetKernelStatus({'total_num_virtual_procs': n_vp}) local_vps = list(nest.GetLocalVPs()) # Use thread-vp mapping of neurons to check mapping in kernel nrns = nest.GetLocalNodeCollection(nest.Create('iaf_psc_delta', 2 * n_vp)) vp_direct = list(nrns.vp) vp_indirect = [local_vps[t] for t in nrns.thread] assert vp_direct == vp_indirect
def main_pynest(parameters): P = parameters assert P.sim_name == "pynest" timer = Timer() import nest timer.mark("import") nest.SetKernelStatus({"resolution": 0.1}) timer.mark("setup") p = nest.Create("iaf_psc_alpha", n=P.n, params={"I_e": 1000.0}) timer.mark("build") # todo: add recording and data retrieval nest.Simulate(P.sim_time) timer.mark("run") mpi_rank = nest.Rank() num_processes = nest.NumProcesses() data = P.as_dict() data.update(num_processes=num_processes, timings=timer.marks) return mpi_rank, data
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, # WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # """ Functions for logging, writing and reading from file. """ import nest from bmtk.simulator.core.io_tools import IOUtils # Want users to be able to use NEST whether or not it is compiled in parallel mode or not, which means checking if # the method nest.SyncPRocesses (aka MPI Barrier) exists. If it doesn't try getting barrier from mpi4py rank = nest.Rank() n_nodes = nest.NumProcesses() try: barrier = nest.SyncProcesses except AttributeError as exc: try: from mpi4py import MPI barrier = MPI.COMM_WORLD.Barrier except: # Barrier is just an empty function, no problem if running on one core. barrier = lambda: None class NestIOUtils(IOUtils): def __init__(self): super(NestIOUtils, self).__init__() self.mpi_rank = rank
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # import os import glob import csv import pandas as pd from bmtk.utils.reports.spike_trains import SpikeTrains, sort_order, sort_order_lu from bmtk.simulator.pointnet.io_tools import io from bmtk.simulator.pointnet.nest_utils import nest_version import nest try: MPI_RANK = nest.Rank() N_HOSTS = nest.NumProcesses() except Exception as e: MPI_RANK = 0 N_HOSTS = 1 def create_spike_detector_nest2(label): return nest.Create("spike_detector", 1, { 'label': label, 'withtime': True, 'withgid': True, 'to_file': True })
""" import os import subprocess as sp import unittest import nest import numpy as np try: from mpi4py import MPI HAVE_MPI4PY = True except ImportError: HAVE_MPI4PY = False HAVE_MPI = nest.ll_api.sli_func("statusdict/have_mpi ::") MULTIPLE_PROCESSES = nest.NumProcesses() > 1 @unittest.skipIf(not HAVE_MPI4PY, 'mpi4py is not available') class ConnectArraysMPICase(unittest.TestCase): """ This TestCase uses mpi4py to collect and assert results from all processes, and is supposed to only be run with multiple processes. If running with nosetests or pytest, this TestCase is ignored when run with a single process, and called from TestConnectArraysMPI using multiple processes. """ non_unique = np.array([1, 1, 3, 5, 4, 5, 9, 7, 2, 8], dtype=np.uint64) # The test class is instantiated by the unittest framework regardless of the value of # HAVE_MPI4PY, even though all tests will be skipped in case it is False. In this
def setUp(self): """Ensure NEST is run with correct number of MPI procs.""" assert nest.NumProcesses() == self.req_num_mpi_procs nest.set_verbosity('M_ERROR') nest.ResetKernel()
# connect noise generator to all neurons nest.CopyModel('static_synapse_hom_w', 'excitatory_input', {'weight': J_E, 'delay': delay}) nest.Connect(noise, nodes, syn_spec='excitatory_input') # connect all recorded E/I neurons to the respective detector nest.Connect(nodes_E[:N_rec], spikes_E) nest.Connect(nodes_I[:N_rec], spikes_I) # Simulate ----------------------------------------------------- # Visualization of initial membrane potential and initial weight # distribution only if we run on single MPI process if nest.NumProcesses() == 1: pylab.figure() # membrane potential V_E = nest.GetStatus(nodes_E[:N_rec], 'V_m') V_I = nest.GetStatus(nodes_I[:N_rec], 'V_m') pylab.subplot(2, 1, 1) pylab.hist([V_E, V_I], bins=10) pylab.xlabel('Membrane potential V_m [mV]') pylab.legend(('Excitatory', 'Inibitory')) pylab.title('Initial distribution of membrane potentials') pylab.draw() # weight of excitatory connections w = nest.GetStatus(nest.GetConnections(nodes_E[:N_rec],
# # 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/>. import nest import unittest HAVE_GSL = nest.ll_api.sli_func('statusdict/have_gsl ::') @unittest.skipIf(nest.NumProcesses() < 2, 'Requires >= 2 MPI process') @unittest.skipIf(not HAVE_GSL, 'GSL is not available') def test_simulation_completes(): """ Ensure that simulation of structural plasticity completes with MPI. This is a regression test for issue #576 concerning crashing simulations when running MPI-parallel. """ nest.ResetKernel() nest.resolution = 0.1 nest.EnableStructuralPlasticity() nest.structural_plasticity_update_interval = 1000.0
#! ============================== nest.ResetKernel() nest.SetKernelStatus({'local_num_threads': 6}) nest.SetKernelStatus({'overwrite_files': True}) nest.SetKernelStatus({'resolution': resolution, 'print_time': True}) msd = 1457427778 #int(time.time()) # Master seed... N_vp = nest.GetKernelStatus(['total_num_virtual_procs' ])[0] # Number of virtual processes... pyrngs = [np.random.RandomState(s) for s in range(msd, msd + N_vp)] # Seeding the Python RNGs nest.SetKernelStatus({'grng_seed': msd + N_vp}) # Seeding the global RNG nest.SetKernelStatus({'rng_seeds': range(msd + N_vp + 1, msd + 2 * N_vp + 1) }) # Seeding the per-process RNGs totMPIproc = nest.NumProcesses() if loc_h == 0: print('Reading input files and setting parameters') #! Setting Parameters #! ============================== # Network numbers N_rows = 48 N_columns = 48 stencil = 4 ExtNeu = 400 ExtNeuF = float(ExtNeu) simDuration = 10000.0 totConn = 1.5120 totConnPerMod = 0.9