def draw_mayavi(self, x, y, z, d, edges):
        "Draw the surface the first time"

        # rendering disabled
        self.mayavi.visualization.scene.disable_render = True

        points = mlab.pipeline.scalar_scatter(x, y, z, d / 2.0)
        dataset = points.mlab_source.dataset
        dataset.point_data.get_array(0).name = "diameter"
        dataset.lines = np.vstack(edges)
        dataset.point_data.update()
        self.dataset = dataset

        # The tube
        src = mlab.pipeline.set_active_attribute(points, point_scalars="diameter")
        stripper = mlab.pipeline.stripper(src)
        tube = mlab.pipeline.tube(stripper, tube_sides=6, tube_radius=1)
        tube.filter.capping = True
        #        tube.filter.use_default_normal = False
        tube.filter.vary_radius = "vary_radius_by_absolute_scalar"
        self.tube = tube

        # Setting the voltage
        # Making room for the voltage
        v = []
        for sec in h.allsec():
            sec.push()
            v.extend(np.repeat(0.0, h.n3d()))
            h.pop_section()

        v = np.array(v)
        self.draw_surface(v, "v")

        # ReEnable the rendering
        self.mayavi.visualization.scene.disable_render = False

def mkmitral(gid):
  nrn = getmitral(gid)
  
  m = h.Mitral()
  m.createsec(len(nrn.dend), len(nrn.tuft))
  m.subsets()
  m.topol(0) # need to connect secondary dendrites explicitly

  for i, d in enumerate(nrn.dend):
    
    # <<< check my changed if
    if(d.parent == nrn.soma): # <<< changed name
      m.secden[i].connect(m.soma(.5))
    else:
      m.secden[i].connect(m.secden[d.parent.index](1)) # <<< changed name
  
  m.geometry()
  m.segments() # depends on geometry
  m.geometry() # again to get the hillock stylized shape

  fillall(nrn, m)
  
  m.segments() # again to get the proper number of segments for tuft and secden
  m.soma.push()
  m.x = h.x3d(0)
  m.y = h.y3d(0)
  m.z = h.z3d(0)
  h.pop_section()
  m.memb()
  return m

    def retrieve_coordinate(self, sec):
        """Retrieve the coordinates of the section avoiding duplicates"""
        
        sec.push()
        x, y, z, d = [],[],[],[]

        tot_points = 0
        connect_next = False
        for i in range(int(h.n3d())):
            present = False
            x_i = h.x3d(i)
            y_i = h.y3d(i)
            z_i = h.z3d(i)
            d_i = h.diam3d(i)
            # Avoiding duplicates in the sec
            if x_i in x:
                ind = len(x) - 1 - x[::-1].index(x_i) # Getting the index of last value
                if y_i == y[ind]:
                    if z_i == z[ind]:
                        present = True
                    
            if not present:
                k =(x_i, y_i, z_i)
                x.append(x_i)
                y.append(y_i)
                z.append(z_i)
                d.append(d_i)                
        h.pop_section()
        #adding num 3d points per section
        self.n3dpoints_per_sec[sec.name()] = len(d)
        return (np.array(x),np.array(y),np.array(z),np.array(d))

 def build_sec_scalar(self, sec, var_value):
     
     sec.push()
     npoints = self.n3dpoints_per_sec[sec.name()]
     sec_scalar = np.repeat(var_value, npoints)
     h.pop_section()
     return sec_scalar

 def _addSynapses(self):
     """
     Adds all synapses to the neuron. Being this model composed by just a single
     compartment, all synapses are added to the soma.
     """
     if self.verbose:
         print('>>> Adding synapses to the model.')
     # TODO: take synapse parameters from:
     # Jaeger, D., De Schutter, E., & Bower, J. M. (1997).
     # The role of synaptic and voltage-gated currents in the control of Purkinje cell
     # spiking: a modeling study.
     # The Journal of Neuroscience, 17(1), 91-106.
     self.soma.push()
     for i in range(self.nSynapses):
         if self.synapseProperties['name'].lower() == 'ampa':
             syn = h.AMPA_S(self.soma(0.5))
             h.Erev_AMPA_S = self.synapseProperties['Erev']
         elif self.synapseProperties['name'].lower() == 'biexp':
             syn = h.Exp2Syn(self.soma(0.5))
             syn.tau1 = self.synapseProperties['tauRise']
             syn.tau2 = self.synapseProperties['tauDecay']
             syn.e = self.synapseProperties['Erev']
         else:
             raise Exception('Unknown synaptic model [%s]' % synapseProps['name'])
             return
         self.synapses.append(syn)
     h.pop_section()

def retrieve_coordinate(sec):
    sec.push()
    x, y, z, d = [],[],[],[]
    area = 0
    tot_points = 0
    connect_next = False
    for i in range(int(h.n3d())):
        present = False
	x_i = h.x3d(i)
	y_i = h.y3d(i)
	z_i = h.z3d(i)
	d_i = h.diam3d(i)
	a_i = h.area(0.5)
	if x_i in x:
            ind = len(x) - 1 - x[::-1].index(x_i) # Getting the index of last value
	    if y_i == y[ind]:
                if z_i == z[ind]:
                    present = True
                    
	if not present:
            k =(x_i, y_i, z_i)
	    x.append(x_i)
	    y.append(y_i)
	    z.append(z_i)
	    d.append(d_i)                
	    area += np.sum(a_i)
    h.pop_section()
        #adding num 3d points per section
    n3dpoints[sec.name()] = [np.array(x),np.array(y),np.array(z),np.array(d)]
    return (np.array(x),np.array(y),np.array(z),np.array(d),area)

        def append_v(sec, v):
            """ Append data to v """
            sec.push()
            for ii in xrange(1, int(nrn.n3d())):
                v.append(sec.v)
            nrn.pop_section()

            return v

def accumulate_density(sec, density, domain):
  sec.push()
  for i in range(int(h.n3d())):
    x,y = (h.x3d(i), h.y3d(i))
    r = (round(x, domain[0]),round(y, domain[1]))
    if not False in r:
      density[r] += 1
  h.pop_section()

def pr(sec):
  sec.push()
  for seg in sec:
    print '%s   x=%g   r=%g   t2.p=%g   p_t2=%g' % (sec.name(), seg.x, seg.t2.r, seg.t2.p, seg.p_t2),
    h.setdata_t2(seg.x)
    print '   f()=%g\n' % (h.f_t2()),
  print('\n')
  h.pop_section()

 def recurse_compartments(index, branches):
     for ii in xrange(int(h.s[index].nchild())):
         h.s[index].child[ii].push()
         child_index = cas_index()
         #print index,',',child_index
         branches.append([index,child_index])
         h.pop_section()
         branches = recurse_compartments(child_index, branches)
     return branches

 def append_children_voltage(parent, v):
     parent.push()
     sref = nrn.SectionRef()
     nrn.pop_section()
     if sref.child:
         for child in sref.child:
             v = append_v(child, v)
             v = append_children_voltage(parent = child,
                                         v = v)
     return v

 def retrieve_coordinates(self, sec):
     xyzds = []
     sec.push()
     for ii in xrange(int(nrn.n3d())):
         xyzds.append([nrn.x3d(ii),
                      nrn.y3d(ii),
                      nrn.z3d(ii),
                      nrn.diam3d(ii)])
     nrn.pop_section()
     return xyzds

def connect(v1, syn2, v3, syn4):
    l = list()
    print h.cas().name()
    l.append(h.NetCon(v1, syn2, 0, 0, 0.5))
    soma3.push()
    print h.cas().name()
    l.append(h.NetCon(v3, syn4, 0, 0, 1))
    h.pop_section()
    print h.cas().name()
    return l

    def build_tree(self):
        print "-"*100
        def append_data(sec, xyzdv, parent_id, connections):
            """ Append data to xyzdv """

            if self.var is 'v':
                v = sec.v
            else:
                raise AttributeError('Variable %s not implemented' % self.var)


            sec.push()
            for ii in xrange(1, int(nrn.n3d())):
                x = nrn.x3d(ii)
                y = nrn.y3d(ii)
                z = nrn.z3d(ii)
                d = nrn.diam3d(ii)
                xyzdv.append([x,y,z,d,v])
                child_id = len(xyzdv)-1
                if len(xyzdv)>1:
                    connections.append([child_id, parent_id])
                parent_id = child_id
            nrn.pop_section()

            return xyzdv, connections

        def append_children_data(parent, parent_id, xyzdv, connections):
            parent.push()
            sref = nrn.SectionRef()
            nrn.pop_section()
            if sref.child:
                for child in sref.child:
                    xyzdv, connections = append_data(child, xyzdv, parent_id, connections)
                    xyzdv, connections = append_children_data(parent = child,
                                                              parent_id = len(xyzdv)-1,
                                                              xyzdv = xyzdv,
                                                              connections = connections)
            return xyzdv, connections

        # Find data and connections
        root_section = self.root_section()
        root_section.push()
        xyzdv = [[nrn.x3d(0),
                 nrn.y3d(0),
                 nrn.z3d(0),
                 nrn.diam3d(0),
                 root_section.v]]
        nrn.pop_section()
        xyzdv, connections = append_data(root_section, xyzdv, 0, [])
        xyzdv, connections = append_children_data(root_section,
                                                  len(xyzdv)-1,
                                                  xyzdv,
                                                  connections)
        self.xyzdv = array(xyzdv)
        self.connections = array(connections)

 def basic_shape(self):
     self.soma.push()
     h.pt3dclear()
     h.pt3dadd(0, 0, 0, 1)
     h.pt3dadd(20, 0, 0, 1)
     h.pop_section()
     self.dend.push()
     h.pt3dclear()
     h.pt3dadd(15, 0, 0, 1)
     h.pt3dadd(215, 0, 0, 1)
     h.pop_section()

def retreive_coordinates(sec):
    ''' Only works with cell which have an xtra mechanism '''
    # Make sure to run h.setpointers() before running
    from neuron import h
    x=sec.sec(.5).x_xtra
    y=sec.sec(.5).y_xtra
    z=sec.sec(.5).z_xtra
    sec.sec.push()
    diam = h.diam3d(0)
    h.pop_section()
    return [x, y, z, diam]

 def __get_parent(self, sec, tree):
     """Recursive function used to create the tree list of section"""
     sec.push()
     secRef = h.SectionRef()
     if secRef.has_parent():
         parentSeg = secRef.parent()
         parentSec = parentSeg.sec
         tree.append(parentSec)
         tree = self.__get_parent(parentSec, tree)
     h.pop_section()
     return tree

 def append_children_data(parent, parent_id, xyzdv, connections):
     parent.push()
     sref = nrn.SectionRef()
     nrn.pop_section()
     if sref.child:
         for child in sref.child:
             xyzdv, connections = append_data(child, xyzdv, parent_id, connections)
             xyzdv, connections = append_children_data(parent = child,
                                                       parent_id = len(xyzdv)-1,
                                                       xyzdv = xyzdv,
                                                       connections = connections)
     return xyzdv, connections

def connectWithTMGSynapse(pre, post, E, taus, U, delay=1, weight=0.01):
    pre.sec.push()
    syn = h.tmgsyn(post)
    syn.e = E
    syn.tau_1 = taus['1']
    syn.tau_rec = taus['rec']
    syn.tau_facil = taus['facil']
    syn.U = U
    conn = h.NetCon(pre._ref_v, syn)
    conn.weight[0] = weight
    conn.delay = delay
    conn.threshold = 0
    h.pop_section()
    return syn,conn

 def find_middle_coordinates(self) :
     cell_list = []
     self.m_coordinates = []
     for n in range(self.num_neurons) :
         cell = []
         print "Neuron ", n
         for i in range(self.NSize[n]):
             exec "cell.append(h.neuron"+str(n)+"_tree["+str(i)+"])";
             cell[i].push()
             middle = int(h.n3d()/2)# It has to be integer!!
             self.m_coordinates.append((h.x3d(middle),h.y3d(middle),h.z3d(middle)))
             #print "Yo(", i, ") Middle is ", middle, Coordinates[i]
             h.pop_section()
         cell_list.append(cell)
     self.m_coordinates