# -*- coding: utf-8 -*-

"""Copyright (C) 2012 Computational Neuroscience Group, NMBU.

This program 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 3 of the License, or

(at your option) any later version.

This program 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.

"""

from __future__ import division

import os

import posixpath

import sys

import unittest

import numpy as np

import LFPy

import neuron

import pickle

import random

# for nosetests to run load mechanisms

if "win32" in sys.platform:

    pth = os.path.join(LFPy.__path__[0], 'test', 'nrnmech.dll')

    pth = pth.replace(os.sep, posixpath.sep)

    if not pth in neuron.nrn_dll_loaded:

        neuron.h.nrn_load_dll(pth)

        neuron.nrn_dll_loaded.append(pth)

else:

    neuron.load_mechanisms(os.path.join(LFPy.__path__[0], 'test'))

class testCell(unittest.TestCase):

    """

    test class LFPy.Cell

    """

    def test_cell_tvec_00(self):

        stickParams = {

            'dt' : 2**-3,

            'tstart' : 0.,

            'tstop' : 100.,

        }

        tvec = stickSimulationTesttvec(**stickParams)

        tvec_numpy = np.linspace(0, stickParams['tstop'],

                    int(stickParams['tstop']/stickParams['dt']) + 1)

        np.testing.assert_equal(tvec, tvec_numpy)

    def test_cell_tvec_01(self):

        stickParams = {

            'dt' : 2**-3,

            'tstart' : 0.,

            'tstop' : 10000.,

        }

        tvec = stickSimulationTesttvec(**stickParams)

        tvec_numpy = np.linspace(0, stickParams['tstop'],

                    int(stickParams['tstop']/stickParams['dt']) + 1)

        np.testing.assert_equal(tvec, tvec_numpy)

    def test_cell_tvec_02(self):

        stickParams = {

            'dt' : 0.1,

            'tstart' : 0,

            'tstop' : 100,

        }

        tvec = stickSimulationTesttvec(**stickParams)

        tvec_numpy = np.linspace(0, stickParams['tstop'],

                    int(stickParams['tstop']/stickParams['dt']) + 1)

        np.testing.assert_equal(tvec, tvec_numpy)

    def test_cell_tvec_03(self):

        stickParams = {

            'dt' : 0.1,

            'tstart' : 0,

            'tstop' : 10000,

        }

        tvec = stickSimulationTesttvec(**stickParams)

        tvec_numpy = np.linspace(0, stickParams['tstop'],

                    int(stickParams['tstop']/stickParams['dt']) + 1)

        np.testing.assert_equal(tvec, tvec_numpy)

    def test_cell_tvec_04(self):

        stickParams = {

            'dt' : 0.2,

            'tstart' : 0,

            'tstop' : 100,

        }

        tvec = stickSimulationTesttvec(**stickParams)

        tvec_numpy = np.linspace(0, stickParams['tstop'],

                    int(stickParams['tstop']/stickParams['dt']) + 1)

        np.testing.assert_equal(tvec, tvec_numpy)

    def test_cell_tvec_05(self):

        stickParams = {

            'dt' : 0.2,

            'tstart' : 0,

            'tstop' : 10000,

        }

        tvec = stickSimulationTesttvec(**stickParams)

        tvec_numpy = np.linspace(0, stickParams['tstop'],

                    int(stickParams['tstop']/stickParams['dt']) + 1)

        np.testing.assert_equal(tvec, tvec_numpy)

    def test_cell_tvec_06(self):

        stickParams = {

            'dt' : 2**-3,

            'tstart' : -100,

            'tstop' : 100,

        }

        tvec = stickSimulationTesttvec(**stickParams)

        tvec_numpy = np.linspace(0, stickParams['tstop'],

                    int(stickParams['tstop']/stickParams['dt']) + 1)

        np.testing.assert_equal(tvec, tvec_numpy)

    def test_cell_tvec_07(self):

        stickParams = {

            'dt' : 2**-3,

            'tstart' : -100,

            'tstop' : 10000,

        }

        tvec = stickSimulationTesttvec(**stickParams)

        tvec_numpy = np.linspace(0, stickParams['tstop'],

                    int(stickParams['tstop']/stickParams['dt']) + 1)

        np.testing.assert_equal(tvec, tvec_numpy)

    def test_cell_tvec_08(self):

        stickParams = {

            'dt' : 0.1,

            'tstart' : -100,

            'tstop' : 10000,

        }

        try:

            stickSimulationTesttvec(**stickParams)

        except AssertionError:

            pass

    def test_cell_tvec_09(self):

        stickParams = {

            'dt' : 0.2,

            'tstart' : -100,

            'tstop' : 10000,

        }

        try:

            stickSimulationTesttvec(**stickParams)

        except AssertionError:

            pass

    def test_cell_set_pos_00(self):

        '''test LFPy.Cell.set_pos'''

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ))

        np.testing.assert_allclose(cell.somapos, [0, 0, 0])

    def test_cell_set_pos_01(self):

        '''test LFPy.Cell.set_pos'''

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ))

        cell.set_pos(10., 20., -30.)

        np.testing.assert_allclose(cell.somapos, [10., 20., -30.])

    def test_cell_set_pos_02(self):

        '''test LFPy.Cell.set_pos'''

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ),

                          pt3d=True)

        cell.set_pos(10., 20., -30.)

        np.testing.assert_allclose(cell.somapos, [10., 20., -30.])

    def test_cell_set_pos_03(self):

        '''test LFPy.Cell.set_pos'''

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ))

        cell.set_pos(10., 20., -30.)

        cell.set_pos(10., 20., -30.)

        cell.set_pos(10., 20., -30.)

        np.testing.assert_allclose(cell.somapos, [10., 20., -30.])

    def test_cell_set_pos_04(self):

        '''test LFPy.Cell.set_pos'''

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ),

                          pt3d=True)

        cell.set_pos(10., 20., -30.)

        cell.set_pos(10., 20., -30.)

        cell.set_pos(10., 20., -30.)

        np.testing.assert_allclose(cell.somapos, [10., 20., -30.])

    def test_cell_set_pos_05(self):

        '''test LFPy.Cell.set_pos'''

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ))

        np.testing.assert_allclose(cell.somapos,

                                   [cell.xmid[0], cell.ymid[0], cell.zmid[0]])

    def test_cell_set_pos_06(self):

        '''test LFPy.Cell.set_pos'''

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ),

                         pt3d=True)

        np.testing.assert_allclose(cell.somapos,

                                   [cell.xmid[0], cell.ymid[0], cell.zmid[0]])

    def test_cell_set_rotation_00(self):

        '''test LFPy.Cell.set_rotation()'''

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ))

        ystarts = cell.ystart.copy()

        ymids = cell.ymid.copy()

        yends = cell.yend.copy()

        zstarts = cell.zstart.copy()

        zmids = cell.zmid.copy()

        zends = cell.zend.copy()

        # test rotation 180 deg around x-axis

        cell.set_rotation(x=np.pi)

        # assert that y- and z-coordinates are inverted, using absolute

        # tolerances

        np.testing.assert_allclose(cell.ystart, -ystarts, atol=1e-07)

        np.testing.assert_allclose(cell.ymid, -ymids, atol=1e-07)

        np.testing.assert_allclose(cell.yend, -yends, atol=1e-07)

        np.testing.assert_allclose(cell.zstart, -zstarts, atol=1e-07)

        np.testing.assert_allclose(cell.zmid, -zmids, atol=1e-07)

        np.testing.assert_allclose(cell.zend, -zends, atol=1e-07)

    def test_cell_set_rotation_01(self):

        '''test LFPy.Cell.set_rotation()'''

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ))

        xstarts = cell.xstart.copy()

        xmids = cell.xmid.copy()

        xends = cell.xend.copy()

        zstarts = cell.zstart.copy()

        zmids = cell.zmid.copy()

        zends = cell.zend.copy()

        # test rotation 180 deg around y-axis

        cell.set_rotation(y=np.pi)

        # assert that y- and z-coordinates are inverted, using absolute

        # tolerances

        np.testing.assert_allclose(cell.xstart, -xstarts, atol=1e-07)

        np.testing.assert_allclose(cell.xmid, -xmids, atol=1e-07)

        np.testing.assert_allclose(cell.xend, -xends, atol=1e-07)

        np.testing.assert_allclose(cell.zstart, -zstarts, atol=1e-07)

        np.testing.assert_allclose(cell.zmid, -zmids, atol=1e-07)

        np.testing.assert_allclose(cell.zend, -zends, atol=1e-07)

    def test_cell_set_rotation_02(self):

        '''test LFPy.Cell.set_rotation()'''

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ))

        xstarts = cell.xstart.copy()

        xmids = cell.xmid.copy()

        xends = cell.xend.copy()

        ystarts = cell.ystart.copy()

        ymids = cell.ymid.copy()

        yends = cell.yend.copy()

        # test rotation 180 deg around z-axis

        cell.set_rotation(z=np.pi)

        # assert that y- and z-coordinates are inverted, using absolute

        # tolerances

        np.testing.assert_allclose(cell.xstart, -xstarts, atol=1e-07)

        np.testing.assert_allclose(cell.xmid, -xmids, atol=1e-07)

        np.testing.assert_allclose(cell.xend, -xends, atol=1e-07)

        np.testing.assert_allclose(cell.ystart, -ystarts, atol=1e-07)

        np.testing.assert_allclose(cell.ymid, -ymids, atol=1e-07)

        np.testing.assert_allclose(cell.yend, -yends, atol=1e-07)

    def test_cell_set_rotation_03(self):

        '''test LFPy.Cell.set_rotation()'''

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ),

                         pt3d=True)

        ystarts = cell.ystart.copy()

        ymids = cell.ymid.copy()

        yends = cell.yend.copy()

        zstarts = cell.zstart.copy()

        zmids = cell.zmid.copy()

        zends = cell.zend.copy()

        # test rotation 180 deg around x-axis

        cell.set_rotation(x=np.pi)

        # assert that y- and z-coordinates are inverted, using absolute

        # tolerances

        np.testing.assert_allclose(cell.ystart, -ystarts, atol=1e-07)

        np.testing.assert_allclose(cell.ymid, -ymids, atol=1e-07)

        np.testing.assert_allclose(cell.yend, -yends, atol=1e-07)

        np.testing.assert_allclose(cell.zstart, -zstarts, atol=1e-07)

        np.testing.assert_allclose(cell.zmid, -zmids, atol=1e-07)

        np.testing.assert_allclose(cell.zend, -zends, atol=1e-07)

    def test_cell_set_rotation_04(self):

        '''test LFPy.Cell.set_rotation()'''

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ),

                         pt3d=True)

        xstarts = cell.xstart.copy()

        xmids = cell.xmid.copy()

        xends = cell.xend.copy()

        zstarts = cell.zstart.copy()

        zmids = cell.zmid.copy()

        zends = cell.zend.copy()

        # test rotation 180 deg around y-axis

        cell.set_rotation(y=np.pi)

        # assert that y- and z-coordinates are inverted, using absolute

        # tolerances

        np.testing.assert_allclose(cell.xstart, -xstarts, atol=1e-07)

        np.testing.assert_allclose(cell.xmid, -xmids, atol=1e-07)

        np.testing.assert_allclose(cell.xend, -xends, atol=1e-07)

        np.testing.assert_allclose(cell.zstart, -zstarts, atol=1e-07)

        np.testing.assert_allclose(cell.zmid, -zmids, atol=1e-07)

        np.testing.assert_allclose(cell.zend, -zends, atol=1e-07)

    def test_cell_set_rotation_05(self):

        '''test LFPy.Cell.set_rotation()'''

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ),

                         pt3d=True)

        xstarts = cell.xstart.copy()

        xmids = cell.xmid.copy()

        xends = cell.xend.copy()

        ystarts = cell.ystart.copy()

        ymids = cell.ymid.copy()

        yends = cell.yend.copy()

        # test rotation 180 deg around z-axis

        cell.set_rotation(z=np.pi)

        # assert that y- and z-coordinates are inverted, using absolute

        # tolerances

        np.testing.assert_allclose(cell.xstart, -xstarts, atol=1e-07)

        np.testing.assert_allclose(cell.xmid, -xmids, atol=1e-07)

        np.testing.assert_allclose(cell.xend, -xends, atol=1e-07)

        np.testing.assert_allclose(cell.ystart, -ystarts, atol=1e-07)

        np.testing.assert_allclose(cell.ymid, -ymids, atol=1e-07)

        np.testing.assert_allclose(cell.yend, -yends, atol=1e-07)

    def test_cell_set_rotation_06(self):

        '''test LFPy.Cell.set_rotation()'''

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test', 'stick.hoc'))

        xstarts = cell.xstart.copy()

        xmids = cell.xmid.copy()

        xends = cell.xend.copy()

        ystarts = cell.ystart.copy()

        ymids = cell.ymid.copy()

        yends = cell.yend.copy()

        zstarts = cell.zstart.copy()

        zmids = cell.zmid.copy()

        zends = cell.zend.copy()

        # test rotation: 90 deg around x-axis, 90 deg around y-axis, 90 deg around z-axis

        cell.set_rotation(x=np.pi / 2., y=np.pi, z=np.pi / 4.)

        # revert rotation: -90 deg around x-axis, -90 deg around y-axis, -90 deg around z-axis, rotation_order='zyx'

        cell.set_rotation(x=-np.pi / 2., y=-np.pi, z=-np.pi / 4., rotation_order='zyx')

        # assert that x-, y- and z-coordinates are same as beginning, using absolute

        # tolerances

        np.testing.assert_allclose(cell.xstart, xstarts, atol=1e-07)

        np.testing.assert_allclose(cell.xmid, xmids, atol=1e-07)

        np.testing.assert_allclose(cell.xend, xends, atol=1e-07)

        np.testing.assert_allclose(cell.ystart, ystarts, atol=1e-07)

        np.testing.assert_allclose(cell.ymid, ymids, atol=1e-07)

        np.testing.assert_allclose(cell.yend, yends, atol=1e-07)

        np.testing.assert_allclose(cell.zstart, zstarts, atol=1e-07)

        np.testing.assert_allclose(cell.zmid, zmids, atol=1e-07)

        np.testing.assert_allclose(cell.zend, zends, atol=1e-07)

    def test_cell_chiral_morphology_00(self):

        '''test LFPy.Cell.chiral_morphology()'''

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ))

        xstarts = cell.xstart.copy()

        xmids = cell.xmid.copy()

        xends = cell.xend.copy()

        ystarts = cell.ystart.copy()

        ymids = cell.ymid.copy()

        yends = cell.yend.copy()

        zstarts = cell.zstart.copy()

        zmids = cell.zmid.copy()

        zends = cell.zend.copy()

        # test rotation 180 deg around x-axis

        cell.chiral_morphology(axis='x')

        # assert that y- and z-coordinates are inverted, using absolute

        # tolerances

        np.testing.assert_allclose(cell.xstart, -xstarts, atol=1e-07)

        np.testing.assert_allclose(cell.xmid, -xmids, atol=1e-07)

        np.testing.assert_allclose(cell.xend, -xends, atol=1e-07)

        np.testing.assert_allclose(cell.ystart, ystarts, atol=1e-07)

        np.testing.assert_allclose(cell.ymid, ymids, atol=1e-07)

        np.testing.assert_allclose(cell.yend, yends, atol=1e-07)

        np.testing.assert_allclose(cell.zstart, zstarts, atol=1e-07)

        np.testing.assert_allclose(cell.zmid, zmids, atol=1e-07)

        np.testing.assert_allclose(cell.zend, zends, atol=1e-07)

    def test_cell_chiral_morphology_01(self):

        '''test LFPy.Cell.chiral_morphology()'''

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ))

        xstarts = cell.xstart.copy()

        xmids = cell.xmid.copy()

        xends = cell.xend.copy()

        ystarts = cell.ystart.copy()

        ymids = cell.ymid.copy()

        yends = cell.yend.copy()

        zstarts = cell.zstart.copy()

        zmids = cell.zmid.copy()

        zends = cell.zend.copy()

        # test rotation 180 deg around y-axis

        cell.chiral_morphology(axis='y')

        # assert that y- and z-coordinates are inverted, using absolute

        # tolerances

        np.testing.assert_allclose(cell.xstart, xstarts, atol=1e-07)

        np.testing.assert_allclose(cell.xmid, xmids, atol=1e-07)

        np.testing.assert_allclose(cell.xend, xends, atol=1e-07)

        np.testing.assert_allclose(cell.ystart, -ystarts, atol=1e-07)

        np.testing.assert_allclose(cell.ymid, -ymids, atol=1e-07)

        np.testing.assert_allclose(cell.yend, -yends, atol=1e-07)

        np.testing.assert_allclose(cell.zstart, zstarts, atol=1e-07)

        np.testing.assert_allclose(cell.zmid, zmids, atol=1e-07)

        np.testing.assert_allclose(cell.zend, zends, atol=1e-07)

    def test_cell_chiral_morphology_02(self):

        '''test LFPy.Cell.chiral_morphology()'''

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ))

        xstarts = cell.xstart.copy()

        xmids = cell.xmid.copy()

        xends = cell.xend.copy()

        ystarts = cell.ystart.copy()

        ymids = cell.ymid.copy()

        yends = cell.yend.copy()

        zstarts = cell.zstart.copy()

        zmids = cell.zmid.copy()

        zends = cell.zend.copy()

        # test rotation 180 deg around z-axis

        cell.chiral_morphology(axis='z')

        # assert that y- and z-coordinates are inverted, using absolute

        # tolerances

        np.testing.assert_allclose(cell.xstart, xstarts, atol=1e-07)

        np.testing.assert_allclose(cell.xmid, xmids, atol=1e-07)

        np.testing.assert_allclose(cell.xend, xends, atol=1e-07)

        np.testing.assert_allclose(cell.ystart, ystarts, atol=1e-07)

        np.testing.assert_allclose(cell.ymid, ymids, atol=1e-07)

        np.testing.assert_allclose(cell.yend, yends, atol=1e-07)

        np.testing.assert_allclose(cell.zstart, -zstarts, atol=1e-07)

        np.testing.assert_allclose(cell.zmid, -zmids, atol=1e-07)

        np.testing.assert_allclose(cell.zend, -zends, atol=1e-07)

    def test_cell_get_rand_prob_area_norm_00(self):

        '''test LFPy.Cell.get_rand_prob_area_norm()'''

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                 'ball_and_sticks.hoc' ))

        p = cell.get_rand_prob_area_norm()

        self.assertAlmostEqual(p.sum(), 1.)

        self.assertTrue(p.min() >= 0.)

        self.assertTrue(p.max() <= 1.)

    def test_cell_get_rand_prob_area_norm_from_idx(self):

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                 'ball_and_sticks.hoc' ))

        p = cell.get_rand_prob_area_norm_from_idx(idx=cell.get_idx(section='allsec'))

        self.assertListEqual(cell.get_rand_prob_area_norm().tolist(), p.tolist())

    def test_cell_get_rand_prob_area_norm_from_idx_00(self):

        '''test LFPy.Cell.get_rand_prob_area_norm()'''

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ))

        p = cell.get_rand_prob_area_norm_from_idx(idx=np.array([0]))

        np.testing.assert_equal(p, np.array([1.]))

    def test_cell_get_intersegment_vector_00(self):

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ))

        idx0 = 0

        idx1 = 1

        vector = cell.get_intersegment_vector(idx0=idx0, idx1=idx1)

        self.assertListEqual(vector,

                            [cell.xmid[idx1] - cell.xmid[idx0],

                             cell.ymid[idx1] - cell.ymid[idx0],

                             cell.zmid[idx1] - cell.zmid[idx0]])

    def test_cell_get_intersegment_distance_00(self):

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ))

        idx0 = 0

        idx1 = 1

        distance = cell.get_intersegment_distance(idx0=idx0, idx1=idx1)

        vector = cell.get_intersegment_vector(idx0=idx0, idx1=idx1)

        self.assertEqual(np.sqrt(np.array(vector)**2).sum(), distance)

    def test_cell_get_idx_00(self):

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ),

                         nsegs_method=None)

        self.assertListEqual(cell.get_idx(section='soma').tolist(), [0])

        self.assertListEqual(cell.get_idx(section='soma[0]').tolist(), [0])

        self.assertListEqual(cell.get_idx(section='dend[0]').tolist(), [1])

        self.assertListEqual(cell.get_idx(section='dend[1]').tolist(), [2])

        self.assertListEqual(cell.get_idx(section='dend[2]').tolist(), [3])

        self.assertListEqual(cell.get_idx(section='dend').tolist(), [1, 2, 3])

        self.assertListEqual(cell.get_idx(section='allsec').tolist(),

                             [0, 1, 2, 3])

        self.assertListEqual(cell.get_idx(section=['soma', 'dend']).tolist(),

                             [0, 1, 2, 3])

        self.assertListEqual(cell.get_idx(section='apic').tolist(), [])

    def test_cell_get_closest_idx_00(self):

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ),

                         nsegs_method=None)

        self.assertEqual(cell.get_closest_idx(x=0, y=0, z=0),

                             cell.get_idx(section='soma')[0])

        self.assertEqual(cell.get_closest_idx(x=-25, y=0, z=175),

                             cell.get_idx(section='dend[1]')[0])

    def test_cell_get_closest_idx_01(self):

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ))

        x = -41.7

        z = 156.7

        sec_name = "dend"

        idx1 = cell.get_closest_idx(x=x, z=z)

        idx2 = cell.get_closest_idx(x=x, z=z, section=sec_name)

        self.assertEqual(idx1, idx2)

    def test_cell_get_idx_children_00(self):

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ))

        np.testing.assert_array_equal(cell.get_idx_children(parent='soma[0]'),

                                      cell.get_idx(section='dend[0]'))

    def test_cell_get_idx_parent_children_00(self):

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ))

        np.testing.assert_array_equal(cell.get_idx_parent_children(parent='soma[0]'),

                                      cell.get_idx(section=['soma[0]',

                                                            'dend[0]']))

    def test_cell_get_idx_name_00(self):

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ))

        np.testing.assert_array_equal(cell.get_idx_name(idx=np.array([0])),

                                                np.array([[0, 'soma[0]', 0.5]],

                                                         dtype=object))

    def test_cell_get_rand_idx_area_norm_00(self):

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ))

        idx = cell.get_rand_idx_area_norm(nidx=1000000)

        # compute histogram and correlate with segment area

        bins = np.arange(cell.totnsegs+1)

        hist, bin_edges = np.histogram(idx, bins=bins)

        # compute Pearson correlation coefficients between area and histogram

        # reporting success if within 4 decimal places

        self.assertAlmostEqual(np.corrcoef(cell.area, hist)[0, 1], 1., places=4)

        # check if min and max is in the range of segment indices

        self.assertEqual(idx.min(), 0)

        self.assertEqual(idx.max(), cell.totnsegs-1)

    def test_cell_set_synapse_00(self):

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ))

        cell.set_synapse(idx=0, syntype='ExpSyn', record_curret=False,

                         record_potential=False, weight=1.,

                         **dict(e=10., tau=2.))

        self.assertTrue('ExpSyn' in cell.synlist[0].hname())

        self.assertEqual(len(cell.synlist), 1)

        self.assertEqual(len(cell.netconlist), 1)

        self.assertEqual(len(cell.netstimlist), 1)

        self.assertEqual(cell.synlist[0].e, 10.)

        self.assertEqual(cell.synlist[0].tau, 2.)

        self.assertEqual(cell.netconlist[0].weight[0], 1.)

    def test_cell_set_point_process_00(self):

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ))

        cell.set_point_process(idx=0, pptype='IClamp', record_current=False,

                               **dict(delay=1., amp=1.))

        self.assertEqual(cell.stimlist[0].hname(), 'IClamp[0]')

        self.assertEqual(len(cell.stimlist), 1)

        self.assertEqual(cell.stimlist[0].delay, 1.)

        self.assertEqual(cell.stimlist[0].amp, 1.)

    def test_cell_strip_hoc_objects_00(self):

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ))

        cell.strip_hoc_objects()

        for attribute in dir(cell):

            self.assertNotEqual(str(type(getattr(cell, attribute))),

                                'hoc.HocObject')

    def test_cell_cellpickler_00(self):

        cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',

                                                  'ball_and_sticks.hoc' ))

        cell_pickle = cell.cellpickler(filename=None, pickler=pickle.dumps)

        pickled_cell = pickle.loads(cell_pickle)

        for attribute in dir(cell):

            if attribute.startswith('__') or attribute.startswith('_'):

                pass

            else:

                self.assertEqual(type(getattr(cell, attribute)),

                                 type(getattr(pickled_cell, attribute)))

    def test_cell_get_axial_currents_from_vmem_00(self):

        '''

        Check Kirchhoff in single dend.

        '''

        neuron.h('forall delete_section()')

        dend1 = neuron.h.Section(name='dend1')

        dend2 = neuron.h.Section(name='dend2')

        dend2.connect(dend1(1.), 0)

        morphology = neuron.h.SectionList()

        morphology.wholetree()

        cell = cell_w_synapse_from_sections(morphology)

        iaxial, d_list, pos_list = cell.get_axial_currents_from_vmem()

        np.testing.assert_almost_equal(-iaxial[0], cell.imem[0], decimal=9)

        np.testing.assert_allclose(-iaxial[0], cell.imem[0], rtol=1E-5)

        np.testing.assert_almost_equal(iaxial[1], cell.imem[1], decimal=9)

        np.testing.assert_allclose(iaxial[1], cell.imem[1], rtol=1E-5)

    def test_cell_get_axial_currents_from_vmem_01(self):

        '''

        Check Kirchhoff in soma when single dend connected to soma mid.

        '''

        neuron.h('forall delete_section()')

        soma = neuron.h.Section(name='soma')

        dend = neuron.h.Section(name='dend')

        dend.connect(soma(0.5), 0)

        morphology = neuron.h.SectionList()

        morphology.wholetree()

        cell = cell_w_synapse_from_sections(morphology)

        iaxial, d_list, pos_list = cell.get_axial_currents_from_vmem()

        np.testing.assert_almost_equal(-iaxial[0], cell.imem[0], decimal=9)

        np.testing.assert_almost_equal(-iaxial[1], cell.imem[0], decimal=9)

        np.testing.assert_allclose(-iaxial[0], cell.imem[0], rtol=1E-4)

        np.testing.assert_allclose(-iaxial[1], cell.imem[0], rtol=1E-4)

    def test_cell_get_axial_currents_from_vmem_02(self):

        '''

        Check Kirchhoff in soma when single dend connected to soma end.

        '''

        neuron.h('forall delete_section()')

        soma = neuron.h.Section(name='soma')

        dend = neuron.h.Section(name='dend')

        dend.connect(soma(1.0), 0)

        morphology = neuron.h.SectionList()

        morphology.wholetree()

        cell = cell_w_synapse_from_sections(morphology)

        iaxial, d_list, pos_list = cell.get_axial_currents_from_vmem()

        np.testing.assert_almost_equal(-iaxial[0], cell.imem[0], decimal=9)

        np.testing.assert_allclose(-iaxial[0], cell.imem[0], rtol=1E-4)

        np.testing.assert_almost_equal(iaxial[1], cell.imem[1], decimal=9)

        np.testing.assert_allclose(iaxial[1], cell.imem[1], rtol=1E-4)

        np.testing.assert_almost_equal(iaxial[0], iaxial[1], decimal=9)

        np.testing.assert_allclose(iaxial[0], iaxial[1], rtol=1E-4)

    def test_cell_get_axial_currents_from_vmem_03(self):

        '''

        Check Kirchhoff in soma when single dend connected to random soma point.

        '''

        neuron.h('forall delete_section()')