コード例 #1
0
ファイル: netrxd.py プロジェクト: Helveg/netpyne
def _addStates(self, params):
    from .. import sim

    for label, param in params.items():
        # regions
        if 'regions' not in param:
            print(
                '  Error creating State %s: "regions" parameter was missing' %
                (label))
            continue
        if not isinstance(param['regions'], list):
            param['regions'] = [param['regions']]
        try:
            nrnRegions = [
                self.rxd['regions'][region]['hObj']
                for region in param['regions']
                if self.rxd['regions'][region]['hObj'] != None
            ]
        except:
            print('  Error creating State %s: could not find regions %s' %
                  (label, param['regions']))

        # initial
        if 'initial' not in param:
            param['initial'] == None
        if isinstance(param['initial'], basestring):  # string-based func
            funcStr = self._replaceRxDStr(param['initial'],
                                          constants=True,
                                          regions=True,
                                          species=False)

            # create final function dynamically from string
            importStr = ' from neuron import crxd as rxd \n from netpyne import sim'
            afterDefStr = 'sim.net.rxd["states"]["%s"]["initialFunc"] = initial' % (
                label)
            funcStr = 'def initial (node): \n%s \n return %s \n%s' % (
                importStr, funcStr, afterDefStr)  # convert to lambda function
            try:
                exec(funcStr, {'rxd': rxd}, {'sim': sim})
                initial = sim.net.rxd["species"][label]["initialFunc"]
            except:
                print(
                    '  Error creating State %s: cannot evaluate "initial" expression -- "%s"'
                    % (label, param['initial']))
                continue
        else:
            initial = param['initial']

        # call rxd method to create Region
        if nrnRegions:
            self.rxd['states'][label]['hObj'] = rxd.State(regions=nrnRegions,
                                                          initial=initial)
        else:
            self.rxd['states'][label]['hObj'] = None
        print('  Created State %s' % (label))
コード例 #2
0
ファイル: wave1d_125_1.py プロジェクト: vogdb/nrn
kserca = 0.1
kip3 = 0.15
kact = 0.4
ip3rtau = 2000
h.CVode().active(1)
h.cvode.atol(1e-10)

# define the regions for the rxd
cyt = rxd.Region(h.allsec(), nrn_region='i', geometry=rxd.FractionalVolume(fc, surface_fraction=1))
er = rxd.Region(h.allsec(), geometry=rxd.FractionalVolume(fe))
cyt_er_membrane = rxd.Region(h.allsec(), geometry=rxd.FixedPerimeter(1))

# the species and other states
ca = rxd.Species([cyt, er], d=caDiff, name='ca', charge=2, initial=cac_init)
ip3 = rxd.Species(cyt, d=ip3Diff, initial=ip3_init)
ip3r_gate_state = rxd.State(cyt_er_membrane, initial=0.8)
h_gate = ip3r_gate_state[cyt_er_membrane]


# pumps and channels between ER and Cytosol

serca = rxd.MultiCompartmentReaction(ca[cyt]>ca[er], gserca/((kserca / (1000. * ca[cyt])) ** 2 + 1), membrane=cyt_er_membrane, custom_dynamics=True)
leak = rxd.MultiCompartmentReaction(ca[er]!=ca[cyt], gleak, gleak, membrane=cyt_er_membrane)

minf = ip3[cyt] * 1000. * ca[cyt] / (ip3[cyt] + kip3) / (1000. * ca[cyt] + kact)
k = gip3r * (minf * h_gate) ** 3 
ip3r = rxd.MultiCompartmentReaction(ca[er]!=ca[cyt], k, k, membrane=cyt_er_membrane)
ip3rg = rxd.Rate(h_gate, (1. / (1 + 1000. * ca[cyt] / (0.3)) - h_gate) / ip3rtau)


コード例 #3
0
ファイル: hh.py プロジェクト: vogdb/nrn
                charge=1,
                initial=init(54.4, 2.5),
                ecs_boundary_conditions=2.5)

na = rxd.Species([cyt, mem, ecs],
                 name='na',
                 d=1e3,
                 charge=1,
                 initial=init(10.0, 140.0),
                 ecs_boundary_conditions=140)
x = rxd.Species([cyt, mem, ecs], name='x', charge=1)

ki, ko, nai, nao, xi, xo = k[cyt], k[ecs], na[cyt], na[ecs], x[cyt], x[ecs]

# gates
ngate = rxd.State([cyt, mem], name='ngate', initial=0.24458654944007166)
mgate = rxd.State([cyt, mem], name='mgate', initial=0.028905534475191907)
hgate = rxd.State([cyt, mem], name='hgate', initial=0.7540796658225246)

# somaA parameter
pA = rxd.Parameter([cyt, mem],
                   name='paramA',
                   initial=lambda nd: 1 if nd.segment in somaA else 0)

#What
# gates
m_gate = rxd.Rate(mgate, (minf - mgate) / mtau)
h_gate = rxd.Rate(hgate, (hinf - hgate) / htau)
n_gate = rxd.Rate(ngate, (ninf - ngate) / ntau)

# Nernst potentials