示例#1
0
def find_steadystate(ode, BCL, dt, num_of_beats=50, path="../ode/"):
    """
    Find a quasi steady state by pacing the 0D cell model at a given cycle length
    for a given number of beats.
    """
    # Compile the ODE solver module
    module, forward = create_module(ode, path=path)

    # Fetch model parameter list and init states
    model_params = module.init_parameter_values()
    states = module.init_state_values()

    # Find indices of various states/parameters
    V_index = module.state_indices("V")
    BCL_index = module.parameter_indices("stim_period")

    # Set the BCL
    model_params[BCL_index] = BCL

    # Start array for recording results
    V = [states[V_index]]

    # Solve ODE system over time
    t = 0.
    tstop = num_of_beats * BCL
    while t <= tstop:
        forward(states, t, dt, model_params)
        V.append(states[V_index])
        t += dt

    # Save the final state as the steady state
    sspath = "../data/steadystates/"
    np.save(sspath + "steadystate_%s_BCL%d" % (ode, BCL), states)
    return states
示例#2
0
def find_steadystates(ode, BCL_range, dt, num_of_beats=50, path="../ode/"):
    """
    Find the quasi steady state for a range of cycle lengths by pacing
    the 0D cell model at a given cycle length for a given number of beats,
    the default being 50 beats.
    """

    # Compile the ODE solver module
    module, forward = create_module(ode, path=path)

    # Fetch model parameter list and init states
    model_params = module.init_parameter_values()
    init_states = module.init_state_values()

    # Find indices of various states/parameters
    V_index = module.state_indices("V")
    BCL_index = module.parameter_indices("stim_period")

    for BCL in BCL_range:
        print "Pacing for BCL %d." % BCL

        # Load initial condition
        states = init_states
        # Set the BCL
        model_params[BCL_index] = BCL

        # Solve ODE system for given number of beats
        t = 0.; tstop = num_of_beats*BCL
        while t <= tstop:
            forward(states, t, dt, model_params)
            t += dt

        # Save the final state as the steady state   
        np.save("../data/steadystates/steadystate_%s_BCL%d" % (ode, BCL), states)
示例#3
0
def find_steadystate(ode, BCL, dt, num_of_beats=50, path="../ode/"):
    """
    Find a quasi steady state by pacing the 0D cell model at a given cycle length
    for a given number of beats.
    """
    # Compile the ODE solver module
    module, forward = create_module(ode, path=path)

    # Fetch model parameter list and init states
    model_params = module.init_parameter_values()
    states = module.init_state_values()

    # Find indices of various states/parameters
    V_index = module.state_indices("V")
    BCL_index = module.parameter_indices("stim_period")

    # Set the BCL
    model_params[BCL_index] = BCL

    # Start array for recording results
    V = [states[V_index]]

    # Solve ODE system over time
    t = 0.
    tstop = num_of_beats*BCL
    while t <= tstop:
    	forward(states, t, dt, model_params)
    	V.append(states[V_index])
    	t += dt	

    # Save the final state as the steady state
    sspath = "../data/steadystates/"
    np.save(sspath+"steadystate_%s_BCL%d" % (ode, BCL), states)
    return states
示例#4
0
def find_steadystates(ode, BCL_range, dt, num_of_beats=50, path="../ode/"):
    """
    Find the quasi steady state for a range of cycle lengths by pacing
    the 0D cell model at a given cycle length for a given number of beats,
    the default being 50 beats.
    """

    # Compile the ODE solver module
    module, forward = create_module(ode, path=path)

    # Fetch model parameter list and init states
    model_params = module.init_parameter_values()
    init_states = module.init_state_values()

    # Find indices of various states/parameters
    V_index = module.state_indices("V")
    BCL_index = module.parameter_indices("stim_period")

    for BCL in BCL_range:
        print "Pacing for BCL %d." % BCL

        # Load initial condition
        states = init_states
        # Set the BCL
        model_params[BCL_index] = BCL

        # Solve ODE system for given number of beats
        t = 0.
        tstop = num_of_beats * BCL
        while t <= tstop:
            forward(states, t, dt, model_params)
            t += dt

        # Save the final state as the steady state
        np.save("../data/steadystates/steadystate_%s_BCL%d" % (ode, BCL),
                states)
示例#5
0
def erp(ode, BCL_range, dt, start, threshold=0.8):
    """
    Calculate the effective refractatory period of an ode model for
    a range of BCLs. First the cell is paced for 50 cycles at the 
    given S1 BCL, then a S2 pulse of a lower cycle length is issued.
    If the action potential from the S2 pulse has a peak value of 
    less than the threshold ratio of the S1 peak, the cell is refractatory.
    The ERP is the smallest S2 cycle length where the cell is not refractatory.
    """
    module, forward = create_module(ode)
    model_params = module.init_parameter_values()
    init_states = module.init_state_values()

    # Find indices of various states/parameters
    V_index = module.state_indices("V")
    BCL_index = module.parameter_indices("stim_period")

    results = np.zeros((2, len(BCL_range)))
    for i, BCL in enumerate(BCL_range):
        # First pace cell for 50 cycles at S1
        try:
            sspath = "../data/steadystates/"
            S1 = np.load(sspath + "steadystate_%s_BCL%d.npy" % (ode, BCL))
        except:
            print "Pacing for BCL %d." % BCL
            # Load initial condition
            states = init_states
            # Set the BCL
            model_params[BCL_index] = BCL
            # Solve ODE system for given number of beats
            t = 0.
            tstop = 50 * BCL
            while t <= tstop:
                forward(states, t, dt, model_params)
                t += dt
            # Save the final state as the steady state
            np.save("../data/steadystates/steadystate_%s_BCL%d" % (ode, BCL),
                    states)
            S1 = states.copy()

        if i == 0:
            S2_range = np.arange(start, BCL, 0.1)
        else:
            S2_range = np.arange(results[1][i - 1], BCL, 0.1)

        for S2 in S2_range:
            print "Trying %g" % S2
            states = S1.copy()
            model_params[BCL_index] = S2
            V = []
            t = 0
            tstop = 2 * S2
            while t <= S2:
                forward(states, t, dt, model_params)
                V.append(states[V_index])
                t += dt

            Vpeak = max(V)

            V = []
            while t <= tstop:
                forward(states, t, dt, model_params)
                V.append(states[V_index])
                t += dt

            if max(V) > 0.8 * Vpeak:
                break

        print "BCL: %g  ERP: %s" % (BCL, S2)

        results[0][i] = BCL
        results[1][i] = S2

    np.save("../data/results/erp_%s" % ode, results)
示例#6
0
    
plt.xlabel(r"Time [ms]", fontsize=20)
plt.ylabel(r"V [mV]", fontsize=20)
#plt.title(r'MAP', fontsize=20)
plt.grid()
plt.legend([u"Koivumäki nSR", u"FK nSR"], prop={'size':20})
plt.savefig('../fig/compare_MAPS_nSR.png')
plt.show()
plt.close()

'''
# cAF
odes = ['hAM_KSMT_cAF', 'FK_cAF']

for i, ode in enumerate(odes):
    module, forward = create_module(ode)
    model_params = module.init_parameter_values()
    states = module.init_state_values()

    V_index = module.state_indices("V")
    offset_index = module.parameter_indices("stim_offset")
    model_params[offset_index] = 10
    
    # Start array for recording results
    V = [states[V_index]]

    t = 0; tstop = 400
    while t <= tstop:
        forward(states, t, dt, model_params)
        V.append(states[V_index])
        t += dt
示例#7
0
def pacing_dynamic(ode, BCL_range, dt, threshold=-60):
    """
    Calculate a restituion curve using dynamic pacing. The ODE model 
    is paced for 50 beats at every BCL value, and APD and DI are measured
    for the final beat.
    """

    # Create ODE solver
    module, forward = create_module(ode)

    # Get model parameters and initial conditions
    model_params = module.init_parameter_values()
    init_states = module.init_state_values()

    # Get parameter indices
    V_index = module.state_indices("V")
    BCL_index = module.parameter_indices("stim_period")

    # For storing the results
    results = np.zeros((3, len(BCL_range)))

    for i, BCL in enumerate(BCL_range):
        # Set BCL
        model_params[BCL_index] = BCL

        # Read in steady state from file
        try:
            sspath = "../data/steadystates/"
            states = np.load(sspath+"steadystate_%s_BCL%d.npy" % (ode, BCL))
        except:
            print "Pacing for BCL %d." % BCL
            # Load initial condition
            states = init_states
            # Solve ODE system for given number of beats
            num_of_beats = 50
            t = 0.; tstop = num_of_beats*BCL
            while t <= tstop:
                forward(states, t, dt, model_params)
                t += dt
            # Save the final state as the steady state   
            np.save(sspath+"steadystate_%s_BCL%d" % (ode, BCL), states)

        # Used to measure when potential crosses threshold
        cross_threshold = []
        Vp = states[V_index]

        t=0.; tstop = BCL;
        while t < tstop:
            forward(states, t, dt, model_params)
            V = states[V_index]

            if (V-threshold)*(Vp-threshold) < 0:
                cross_threshold.append(t)
            Vp = V
            t += dt

        try:
            APD = cross_threshold[-1] - cross_threshold[-2]
            DI = tstop - cross_threshold[-1]
        except:
            APD = 0
            DI = 0

        print "BCL: %g,  APD: %g,   DI: %g" % (BCL, APD, DI)

        results[0][i] = BCL
        results[1][i] = APD
        results[2][i] = DI

    np.save("../data/results/dynamic_%s" % ode, results)
示例#8
0
def pacing_S1S2(ode, S1, S2_range, dt, threshold=-60):
    """
    Calculate a restitution curve using S1-S2 pacing, take in
    the relevant ode model, the S1 length and the range of S2
    values to calculate APD/DI. Note that the steady state of 
    a BCL=S1 must be lying in /data/. If this does not exist 
    for the given ODE file, you can make it using steadystate.py.
    """
    module, forward = create_module(ode)
    model_params = module.init_parameter_values()
    
    # Pace 0D cell model and find quasi-steady state
    try:
        sspath = "../data/steadystates/"
        init_states = np.load(sspath+"steadystate_%s_BCL%d.npy" % (ode, S1))
    except:
        print "Pacing 0D model for BCL %g..." % S1,
        init_states = find_steadystate(S1, 50, dt, ode, plot_results=False)
        print "done."

    # Find indices of various states/parameters
    V_index = module.state_indices("V")
    BCL_index = module.parameter_indices("stim_period")

    def pulse_S2(S2):
        """Pulse the steady state with a single S2 pulse and measure APD/DI."""
        states = init_states
        model_params[BCL_index] = S2

        t = 0.; tstop = 2*S2
        while t <= S2:
            forward(states, t, dt, model_params)
            t += dt

        Vp = states[V_index]
        cross_threshold = []
        while t <= tstop:
            forward(states, t, dt, model_params)
            V = states[V_index]
            if (Vp-threshold)*(V-threshold) < 0:
                cross_threshold.append(t)
            Vp = V
            t += dt

        try:
            APD = cross_threshold[-1] - cross_threshold[-2]
            DI = tstop - cross_threshold[-1]
        except:
            APD = 0
            DI = 0

        return APD, DI

    results = np.zeros((3, len(S2_range)))

    for S2 in S2_range:
        APD, DI = pulse_S2(S2)
        results[0][i] = S2
        results[1][i] = APD
        results[2][i] = DI

        print "S2: %g,  APD: %g,   DI: %g" % (S2, APD, DI)

    np.save("../data/results/S1S2_%s" % ode, results)
示例#9
0
def pacing_dynamic(ode, BCL_range, dt, threshold=-60):
    """
    Calculate a restituion curve using dynamic pacing. The ODE model 
    is paced for 50 beats at every BCL value, and APD and DI are measured
    for the final beat.
    """

    # Create ODE solver
    module, forward = create_module(ode)

    # Get model parameters and initial conditions
    model_params = module.init_parameter_values()
    init_states = module.init_state_values()

    # Get parameter indices
    V_index = module.state_indices("V")
    BCL_index = module.parameter_indices("stim_period")

    # For storing the results
    results = np.zeros((3, len(BCL_range)))

    for i, BCL in enumerate(BCL_range):
        # Set BCL
        model_params[BCL_index] = BCL

        # Read in steady state from file
        try:
            sspath = "../data/steadystates/"
            states = np.load(sspath + "steadystate_%s_BCL%d.npy" % (ode, BCL))
        except:
            print "Pacing for BCL %d." % BCL
            # Load initial condition
            states = init_states
            # Solve ODE system for given number of beats
            num_of_beats = 50
            t = 0.
            tstop = num_of_beats * BCL
            while t <= tstop:
                forward(states, t, dt, model_params)
                t += dt
            # Save the final state as the steady state
            np.save(sspath + "steadystate_%s_BCL%d" % (ode, BCL), states)

        # Used to measure when potential crosses threshold
        cross_threshold = []
        Vp = states[V_index]

        t = 0.
        tstop = BCL
        while t < tstop:
            forward(states, t, dt, model_params)
            V = states[V_index]

            if (V - threshold) * (Vp - threshold) < 0:
                cross_threshold.append(t)
            Vp = V
            t += dt

        try:
            APD = cross_threshold[-1] - cross_threshold[-2]
            DI = tstop - cross_threshold[-1]
        except:
            APD = 0
            DI = 0

        print "BCL: %g,  APD: %g,   DI: %g" % (BCL, APD, DI)

        results[0][i] = BCL
        results[1][i] = APD
        results[2][i] = DI

    np.save("../data/results/dynamic_%s" % ode, results)
示例#10
0
    
plt.xlabel(r"Time [ms]", fontsize=20)
plt.ylabel(r"V [mV]", fontsize=20)
#plt.title(r'MAP', fontsize=20)
plt.grid()
plt.legend([u"Koivumäki nSR", u"FK nSR"], prop={'size':20})
plt.savefig('../fig/compare_MAPS_nSR.png')
plt.show()
plt.close()

'''
# cAF
odes = ['hAM_KSMT_cAF', 'FK_cAF']

for i, ode in enumerate(odes):
    module, forward = create_module(ode)
    model_params = module.init_parameter_values()
    states = module.init_state_values()

    V_index = module.state_indices("V")
    offset_index = module.parameter_indices("stim_offset")
    model_params[offset_index] = 10

    # Start array for recording results
    V = [states[V_index]]

    t = 0
    tstop = 400
    while t <= tstop:
        forward(states, t, dt, model_params)
        V.append(states[V_index])
示例#11
0
文件: erp.py 项目: jvbrink/atriapace
def erp(ode, BCL_range, dt, start, threshold=0.8):
    """
    Calculate the effective refractatory period of an ode model for
    a range of BCLs. First the cell is paced for 50 cycles at the 
    given S1 BCL, then a S2 pulse of a lower cycle length is issued.
    If the action potential from the S2 pulse has a peak value of 
    less than the threshold ratio of the S1 peak, the cell is refractatory.
    The ERP is the smallest S2 cycle length where the cell is not refractatory.
    """
    module, forward = create_module(ode)
    model_params = module.init_parameter_values()
    init_states = module.init_state_values()
    
    # Find indices of various states/parameters
    V_index = module.state_indices("V")
    BCL_index = module.parameter_indices("stim_period")

    results = np.zeros((2,len(BCL_range)))
    for i, BCL in enumerate(BCL_range):
        # First pace cell for 50 cycles at S1
        try:
            sspath = "../data/steadystates/"
            S1 = np.load(sspath+"steadystate_%s_BCL%d.npy" % (ode, BCL))
        except:
            print "Pacing for BCL %d." % BCL
            # Load initial condition
            states = init_states
            # Set the BCL
            model_params[BCL_index] = BCL
            # Solve ODE system for given number of beats
            t = 0.; tstop = 50*BCL
            while t <= tstop:
                forward(states, t, dt, model_params)
                t += dt
            # Save the final state as the steady state   
            np.save("../data/steadystates/steadystate_%s_BCL%d" % (ode, BCL), states)
            S1 = states.copy()

        if i == 0:
            S2_range = np.arange(start, BCL, 0.1)
        else:
            S2_range = np.arange(results[1][i-1], BCL, 0.1)
        
        for S2 in S2_range:
            print "Trying %g" % S2 
            states = S1.copy()
            model_params[BCL_index] = S2
            V = []
            t = 0; tstop = 2*S2
            while t <= S2:
                forward(states, t, dt, model_params)
                V.append(states[V_index])
                t += dt

            Vpeak = max(V)
            
            V = []
            while t <= tstop:
                forward(states, t, dt, model_params)
                V.append(states[V_index])
                t += dt
            
            if max(V) > 0.8*Vpeak:
                break

        print "BCL: %g  ERP: %s" % (BCL, S2)
        
        results[0][i] = BCL
        results[1][i] = S2

    np.save("../data/results/erp_%s" % ode, results)
示例#12
0
def pacing_dynamic(ode, BCL_range, dt, pulse_train_length=30e3, 
                   pacing_memory=True, threshold=-60):
    """
    Calculate a restitution curve using dynamic pacing, take 
    in the relevant ode model, the range of BCLs to be used.
    A pulse train of 30 seconds is the default. The regime steps
    straight from one BCL to the next, meaning it contains pacing memory.
    If pacing memory is turned of, we reload the inital states.
    """

    module, forward = create_module(ode)
    model_params = module.init_parameter_values()
    states = module.init_state_values()

    # Find indices of various states/parameters
    V_index = module.state_indices("V")
    BCL_index = module.parameter_indices("stim_period")

    def pulse_train(BCL, init_states):
        """
        Run a pulse train on the cell with given BCL and length, 
        and measure the APD and DI from the last pulse.
        """
        states = init_states
        model_params[BCL_index] = BCL

        t=0.; 
        if pulse_train_length > BCL*50.:
            tstop = np.ceil(pulse_train_length/BCL)*BCL
        else:
            tstop = BCL*50. 

        while t < tstop - BCL:
            forward(states, t, dt, model_params)
            t += dt

        cross_threshold = []
        Vp = states[V_index]
        while t <= tstop:
            forward(states, t, dt, model_params)
            V = states[V_index]
            if (V-threshold)*(Vp-threshold) < 0:
                cross_threshold.append(t)
            Vp = V
            t += dt
        
        APD = cross_threshold[-1] - cross_threshold[-2]
        DI = tstop - cross_threshold[-1] 

        return APD, DI, states

    results_BCL = []
    results_APD = []
    results_DI = []

    prev_states = init_states
    for BCL in BCL_range:
        states = prev_states if pacing_memory else init_states
        APD, DI, prev_states = pulse_train(BCL, states)
        
        results_BCL.append(BCL)
        results_APD.append(APD)
        results_DI.append(DI)

        print "BCL: %g,  APD: %g,   DI: %g" % (BCL, APD, DI)

    np.save("../data/resultss_dynamic_%s" % ode, 
            np.array((results_BCL, results_APD, results_DI)))
示例#13
0
def pacing_dynamic(ode,
                   BCL_range,
                   dt,
                   pulse_train_length=30e3,
                   pacing_memory=True,
                   threshold=-60):
    """
    Calculate a restitution curve using dynamic pacing, take 
    in the relevant ode model, the range of BCLs to be used.
    A pulse train of 30 seconds is the default. The regime steps
    straight from one BCL to the next, meaning it contains pacing memory.
    If pacing memory is turned of, we reload the inital states.
    """

    module, forward = create_module(ode)
    model_params = module.init_parameter_values()
    states = module.init_state_values()

    # Find indices of various states/parameters
    V_index = module.state_indices("V")
    BCL_index = module.parameter_indices("stim_period")

    def pulse_train(BCL, init_states):
        """
        Run a pulse train on the cell with given BCL and length, 
        and measure the APD and DI from the last pulse.
        """
        states = init_states
        model_params[BCL_index] = BCL

        t = 0.
        if pulse_train_length > BCL * 50.:
            tstop = np.ceil(pulse_train_length / BCL) * BCL
        else:
            tstop = BCL * 50.

        while t < tstop - BCL:
            forward(states, t, dt, model_params)
            t += dt

        cross_threshold = []
        Vp = states[V_index]
        while t <= tstop:
            forward(states, t, dt, model_params)
            V = states[V_index]
            if (V - threshold) * (Vp - threshold) < 0:
                cross_threshold.append(t)
            Vp = V
            t += dt

        APD = cross_threshold[-1] - cross_threshold[-2]
        DI = tstop - cross_threshold[-1]

        return APD, DI, states

    results_BCL = []
    results_APD = []
    results_DI = []

    prev_states = init_states
    for BCL in BCL_range:
        states = prev_states if pacing_memory else init_states
        APD, DI, prev_states = pulse_train(BCL, states)

        results_BCL.append(BCL)
        results_APD.append(APD)
        results_DI.append(DI)

        print "BCL: %g,  APD: %g,   DI: %g" % (BCL, APD, DI)

    np.save("../data/resultss_dynamic_%s" % ode,
            np.array((results_BCL, results_APD, results_DI)))