def build_traces(cls, header_info, data_array):
n_cols = data_array.shape[1]
# Get the time column:
time_data_raw = data_array[:, 0]
time_unit = unit(str(header_info.column_data[0]['unit']))
time_data = time_data_raw * time_unit
# Do we build as fixed or variable array:
trace_builder = (TraceFixedDT
if TraceFixedDT.is_array_fixed_dt(time_data) else
TraceVariableDT)
trcs = []
for i in range(1, n_cols):
d_i = data_array[:, i]
column_metadict = header_info.column_data[i]
dataUnit = unit(str(column_metadict.get('unit', '')))
data_label = str(column_metadict.get('label', 'Column%d' % i))
data_tags = str(column_metadict.get('tags', '')).split(',')
d = d_i * dataUnit
tr = trace_builder(time_data, d, name=data_label, tags=data_tags)
trcs.append(tr)
return trcs
def get_sample_k(env):
kStateVars = {'n': {'alpha': [-0.55, -0.01, -1.00, 55.0, -10.00],
'beta': [0.125, 0, 0, 65, 80]}}
k_chl = env.Channel(
StdChlAlphaBeta,
name='KChl',
ion='k',
equation='n*n*n*n',
conductance=unit('36:mS/cm2'),
reversalpotential=unit('-77:mV'),
statevars=kStateVars,
)
return k_chl
def reduce_to_variable_dt_trace(cls, original_trace, epsilon):
assert isinstance(original_trace, TracePointBased)
epsilon = unit(epsilon)
time_units = original_trace.time_unit
time_data = original_trace.time_pts_np
data_units = original_trace.data_unit
data_data = original_trace.data_pts_np
pts = zip(time_data.tolist(), data_data.tolist())
newpts = _simplify_points(pts, epsilon)
(new_time, new_data) = zip(*newpts)
new_trace = TraceVariableDT(np.array(new_time) * time_units,
np.array(new_data) * data_units,
name=original_trace.name,
comment=original_trace.comment,
tags=original_trace.tags)
print 'Simplified from N=%d to N=%d' % (original_trace.get_n(),
new_trace.get_n())
return new_trace
def build_hh_cell(sim, cell_area=None):
if cell_area is None:
cell_area = unit('5000:um2')
morphology = MorphologyBuilder.get_single_section_soma(area=cell_area)
cell = sim.create_cell(morphology=morphology)
# Apply the channels uniformly over the cell
env = sim.environment
modelsrc = StandardModels.HH52
cell.apply_channel(
ChannelLibrary.get_channel(modelsrc=modelsrc,
celltype=None,
channeltype="Na",
env=env))
cell.apply_channel(
ChannelLibrary.get_channel(modelsrc=modelsrc,
celltype=None,
channeltype="K",
env=env))
cell.apply_channel(
ChannelLibrary.get_channel(modelsrc=modelsrc,
celltype=None,
channeltype="Lk",
env=env))
return cell
def __init__(self, morphology=None, area=None, segmenter=None, initial_voltage=None, cell_tags=None, cell_type=None, **kwargs):
if area is not None:
assert morphology is None
morphology = MorphologyBuilder.get_single_section_soma(area=area)
if cell_tags == None:
cell_tags = []
from morphforge.simulation.base.segmentation.cellsegmenter import CellSegmenter_MaxCompartmentLength
super(Cell, self).__init__(**kwargs)
self.morphology = morphology
self._cell_type = cell_type
self.cell_segmenter = (segmenter if segmenter else CellSegmenter_MaxCompartmentLength())
self.cell_segmenter.connect_to_cell(self)
self.biophysics = CellBiophysics(self)
self.initial_voltage = initial_voltage or unit('-51:mV')
self.cell_tags = cell_tags
if self.name:
self.cell_tags = self.cell_tags + [self.name]
self.population = None
def get_sample_na(env):
na_state_vars = { 'm': {
'alpha': [-4.00,-0.10,-1.00,40.00,-10.00],
'beta': [4.00, 0.00, 0.00,65.00, 18.00]},
'h': {
'alpha': [0.07,0.00,0.00,65.00,20.00],
'beta': [1.00,0.00,1.00,35.00,-10.00]}
}
na_chl = env.Channel(
StdChlAlphaBeta,
name='NaChl',
ion='na',
equation='m*m*m*h',
conductance=unit('120:mS/cm2'),
reversalpotential=unit('50:mV'),
statevars=na_state_vars,
)
return na_chl
def _convert_to_unit(o, default_unit):
assert not isinstance(default_unit, pq.quantity.Quantity)
if isinstance(o, pq.quantity.Quantity):
return o.rescale(default_unit)
elif is_float(o) or is_int(o):
return o * morphforge.core.quantities.unit_string_parser.parse(default_unit).rescale(default_unit)
elif isinstance(o, (str, unicode)) and ':' in o:
return unit(o).rescale(default_unit)
else:
raise ValueError()
def plot(self, ax, all_traces, all_eventsets, time_range=None, linkage=None ) :
# Which traces are we plotting (rely on a mixon class):
trcs = [tr for tr in all_traces if self.addtrace_predicate(tr)]
eventsets = [tr for tr in all_eventsets if self.addeventset_predicate(tr)]
# Sort and plot:
for index, trace in enumerate( self.sort_traces(trcs) ):
color = linkage.color_allocations.get(trace, None) if linkage else None
self.plot_trace( trace, time_range=time_range, ax=ax, index=index, color=color)
for index, event_set in enumerate( self.sort_eventsets(eventsets) ):
self.plot_eventset( event_set, time_range=time_range, ax=ax, index=index+len(trcs) )
#ax.set_ylim( ( (-0.5) * pq.dimensionless, (len(eventsets)+0.5) * pq.dimensionless ) )
if len(trcs) == 0:
padding =0.5
ax.set_yunit( 1*pq.dimensionless )
ax.set_ylim( ( (-padding) * pq.dimensionless, (len(eventsets)-1+padding) * pq.dimensionless ) )
#Legend:
if self.legend_labeller is not None:
import math
import __builtin__ as BI
ncols = BI.max( int( math.floor( len(trcs) / 10.0) ), 1)
ax.legend(ncol=ncols)
if self.title:
ax.set_title( self.title )
# Label up the axis:
ax.set_xlabel('Time')
ax.set_xunit( unit('ms') )
ax.set_ylabel( self.get_selector_ylabel() )
if time_range is not None:
print 'Setting Time Range', time_range
ax.set_xlim( time_range )
if self.yrange is not None:
ax.set_ylim( self.yrange )
if self.yunit is not None:
print 'Setting Yunit', self.yunit
ax.set_display_unit(y=self.yunit)
# Turn the grid on:
ax.grid('on')
def build_traces(cls, header_info, data_array):
nCols = data_array.shape[1]
# Get the time column:
timeDataRaw = data_array[:,0]
timeUnit = unit( str(header_info.column_data[0]['unit'] ) )
timeData = timeDataRaw * timeUnit
# Do we build as fixed or variable array:
tBuilder = Trace_FixedDT if Trace_FixedDT.isArrayFixedDT(timeData) else Trace_VariableDT
trcs = []
for i in range(1,nCols):
d_i = data_array[:,i]
column_metadict = header_info.column_data[i]
dataUnit = unit( str(column_metadict.get('unit',"") ) )
dataLabel = str( column_metadict.get('label','Column%d'%i) )
dataTags = str( column_metadict.get('tags','') ).split(',')
d = d_i * dataUnit
tr = tBuilder(timeData, d, name=dataLabel, tags=dataTags)
trcs.append(tr)
return trcs
def build_hh_cell(sim, cell_area=None):
if cell_area is None:
cell_area = unit('5000:um2')
morphology = MorphologyBuilder.get_single_section_soma(area = cell_area)
cell = sim.create_cell(morphology=morphology)
# Apply the channels uniformly over the cell
env = sim.environment
modelsrc=StandardModels.HH52
cell.apply_channel( ChannelLibrary.get_channel(modelsrc=modelsrc, celltype=None, channeltype="Na", env=env) )
cell.apply_channel( ChannelLibrary.get_channel(modelsrc=modelsrc, celltype=None, channeltype="K", env=env) )
cell.apply_channel( ChannelLibrary.get_channel(modelsrc=modelsrc, celltype=None, channeltype="Lk", env=env) )
return cell
def newFunctor(
env,
_voltage_interpolation_values=voltage_interpolation_values):
old_chl = chl_functor(env)
assert isinstance(
old_chl, (StdChlAlphaBeta, StdChlAlphaBetaBeta
)) # or issubclass(StdChlAlphaBetaBeta, old_chl)
# New Name
if new_name is not None:
chl_name = new_name
else:
chl_name = old_chl.name + clone_name_suffix
# Interpolation voltages:
# voltage_interpolation_values=voltage_interpolation_values
if _voltage_interpolation_values is None:
_voltage_interpolation_values = linspace(-80, 60,
10) * unit('mV')
# Copy the state variables
new_state_vars = {}
for state_var in old_chl.get_state_variables():
alpha, beta = old_chl.get_alpha_beta_at_voltage(
statevar=state_var, V=_voltage_interpolation_values)
inf, tau = InfTauCalculator.alpha_beta_to_inf_tau(alpha, beta)
V = _voltage_interpolation_values.rescale('mV').magnitude
inf = inf.rescale(pq.dimensionless).magnitude
tau = tau.rescale('ms').magnitude
new_state_vars[state_var] = InfTauInterpolation(V=V,
inf=inf,
tau=tau)
chl = env.Channel(
MM_InfTauInterpolatedChannel,
name=chl_name,
ion=old_chl.ion,
equation=old_chl.eqn,
conductance=old_chl.conductance,
reversalpotential=old_chl.reversalpotential,
statevars_new=new_state_vars,
)
return chl
def newFunctor(env, _voltage_interpolation_values=voltage_interpolation_values):
old_chl = chl_functor(env)
assert isinstance(old_chl, (StdChlAlphaBeta,
StdChlAlphaBetaBeta)) # or issubclass(StdChlAlphaBetaBeta, old_chl)
# New Name
if new_name is not None:
chl_name = new_name
else:
chl_name = old_chl.name + clone_name_suffix
# Interpolation voltages:
# voltage_interpolation_values=voltage_interpolation_values
if _voltage_interpolation_values is None:
_voltage_interpolation_values = linspace(-80, 60, 10) * unit('mV')
# Copy the state variables
new_state_vars = {}
for state_var in old_chl.get_state_variables():
alpha, beta = old_chl.get_alpha_beta_at_voltage(statevar=state_var, V=_voltage_interpolation_values)
inf, tau = InfTauCalculator.alpha_beta_to_inf_tau(alpha, beta)
V = _voltage_interpolation_values.rescale('mV').magnitude
inf = inf.rescale(pq.dimensionless).magnitude
tau = tau.rescale('ms').magnitude
new_state_vars[state_var] = InfTauInterpolation(V=V, inf=inf, tau=tau)
chl = env.Channel(
MM_InfTauInterpolatedChannel,
name=chl_name,
ion=old_chl.ion,
equation=old_chl.eqn,
conductance=old_chl.conductance,
reversalpotential=old_chl.reversalpotential,
statevars_new=new_state_vars,
)
return chl
def __init__(self,
dur1,
amp1,
dur2='0:ms',
dur3='0:ms',
amp2='0:mV',
amp3='0:mV',
rs='0.1:MOhm',
**kwargs):
super(VoltageClampStepChange, self).__init__(**kwargs)
self.dur1 = unit(dur1)
self.dur2 = unit(dur2)
self.dur3 = unit(dur3)
self.amp1 = unit(amp1)
self.amp2 = unit(amp2)
self.amp3 = unit(amp3)
self.rs = unit(rs)
def __init__(self, morphology, simulation, name= None, segmenter=None, initial_voltage=None, cell_tags = [], **kwargs):
from morphforge.simulation.core.segmentation.cellsegmenter import DefaultCellSegementer
self.simulation = simulation
self.name = name if name else ObjectLabeller.getNextUnamedObjectName(Cell, 'AnonCell_')
self.morphology = morphology
self.cellSegmenter = segmenter if segmenter else DefaultCellSegementer()
self.cellSegmenter.connectToCell(self)
self.biophysics = CellBiophysics()
self.initial_voltage = initial_voltage or unit("-51:mV")
self.cell_tags = cell_tags
if self.name:
self.cell_tags = self.cell_tags + [self.name]
def reduce_to_variable_dt_trace(cls, original_trace, epsilon):
assert isinstance(original_trace, Trace_PointBased)
epsilon = unit(epsilon)
time_units = original_trace._time.units
time_data = original_trace._time.magnitude
data_units = original_trace._data.units
data_data = original_trace._data.magnitude
ep = epsilon
pts = zip(time_data.tolist(), data_data.tolist())
newpts = simplify_points(pts, ep)
new_time, new_data = zip(*newpts)
newTrace = Trace_VariableDT(np.array(new_time) * time_units, np.array(new_data) * data_units, name=original_trace.name, comment=original_trace.comment, tags=original_trace.tags)
print 'Simplified from N=%d to N=%d' % (original_trace.getN(), newTrace.getN())
return newTrace
def __init__(
self,
dur1,
amp1,
dur2='0:ms',
dur3='0:ms',
amp2='0:mV',
amp3='0:mV',
rs='0.1:MOhm',
**kwargs
):
super(VoltageClampStepChange, self).__init__(**kwargs)
self.dur1 = unit(dur1)
self.dur2 = unit(dur2)
self.dur3 = unit(dur3)
self.amp1 = unit(amp1)
self.amp2 = unit(amp2)
self.amp3 = unit(amp3)
self.rs = unit(rs)
def reduce_to_variable_dt_trace(cls, original_trace, epsilon):
assert isinstance(original_trace, TracePointBased)
epsilon = unit(epsilon)
time_units = original_trace.time_unit
time_data = original_trace.time_pts_np
data_units = original_trace.data_unit
data_data = original_trace.data_pts_np
pts = zip(time_data.tolist(), data_data.tolist())
newpts = _simplify_points(pts, epsilon)
(new_time, new_data) = zip(*newpts)
new_trace = TraceVariableDT(np.array(new_time) * time_units,
np.array(new_data) * data_units,
name=original_trace.name,
comment=original_trace.comment,
tags=original_trace.tags)
print 'Simplified from N=%d to N=%d' % (original_trace.get_n(),
new_trace.get_n())
return new_trace
def get_unit(self):
return unit('')
def get_unit(self):
return unit('nA')
def __init__(self, amp, dur, delay, **kwargs):
super(CurrentClampStepChange, self).__init__(**kwargs)
self.amp = unit(amp)
self.dur = unit(dur)
self.delay = unit(delay)
def __init__(self, amp, dur, delay, **kwargs):
super(CurrentClampStepChange, self).__init__(**kwargs)
self.amp = unit(amp)
self.dur = unit(dur)
self.delay = unit(delay)
def get_sample_lk(env):
lk_chl = env.Channel(StdChlLeak, name='LkChl',
conductance=unit('0.3:mS/cm2'),
reversalpotential=unit('-54.3:mV') )
return lk_chl
t_m = t_marker.match(st)
if not t_m:
assert False, "Can't parse: %s" % st
g = t_m.groupdict()
(t0, t1, d0, d1) = (g['t0'], g['t1'], g['d0'], g['d1'])
t0 = (int(t0) * xunit if t0 else None)
t1 = (int(t1) * xunit if t1 else None)
d0 = (int(d0) * yunit if d0 else None)
d1 = (int(d1) * yunit if d1 else None)
return LevelSelector(data_selector=DataSelector(d0, d1),
time_selector=TimeSelector(t0, t1))
l1 = TracePiecewise(pieces = [
TracePieceFunctionFlat(time_window=(0, 50)*pq.ms, x=unit("0:pA")),
TracePieceFunctionFlat(time_window=(50, 150)*pq.ms, x=unit("110:pA")),
TracePieceFunctionFlat(time_window=(150, 350)*pq.ms, x=unit("0:pA")),
])
sel1 = LevelSelectorGroup(" A, { 10:65 @ -1:1 }, B, { 10: @ 90:111 }, C", xunit=unit("ms"), yunit=unit("pA"))
matches = sel1.matchall(l1)
for m in matches:
print m
marker = r_m.groupdict()['name']
return LevelToken(symbol=marker)
t_m = t_marker.match(st)
if not t_m:
assert False, "Can't parse: %s" % st
g = t_m.groupdict()
(t0, t1, d0, d1) = (g['t0'], g['t1'], g['d0'], g['d1'])
t0 = (int(t0) * xunit if t0 else None)
t1 = (int(t1) * xunit if t1 else None)
d0 = (int(d0) * yunit if d0 else None)
d1 = (int(d1) * yunit if d1 else None)
return LevelSelector(data_selector=DataSelector(d0, d1),
time_selector=TimeSelector(t0, t1))
l1 = TracePiecewise(pieces=[
TracePieceFunctionFlat(time_window=(0, 50) * pq.ms, x=unit("0:pA")),
TracePieceFunctionFlat(time_window=(50, 150) * pq.ms, x=unit("110:pA")),
TracePieceFunctionFlat(time_window=(150, 350) * pq.ms, x=unit("0:pA")),
])
sel1 = LevelSelectorGroup(" A, { 10:65 @ -1:1 }, B, { 10: @ 90:111 }, C",
xunit=unit("ms"),
yunit=unit("pA"))
matches = sel1.matchall(l1)
for m in matches:
print m
