def test_quantityexpr():
data = []
for (a, b, check_with_gnu) in valid_quantity_exprs:
print 'a:', a
print 'b:', b
A = NeuroUnitParser.QuantityExpr(a)
print 'LOADING B'
B = NeuroUnitParser.QuantityExpr(b)
if check_with_gnu:
verify_equivalence_with_gnuunits(a, b)
print "typeA:", type(A)
print "typeB:", type(B)
pcA = ((A - B) / A).dimensionless()
pcB = ((A - B) / B).dimensionless()
data.append([
a, b,
"$%s$" % (A.FormatLatex()),
"$%s$" % (B.FormatLatex()),
str(pcA),
str(pcB)
])
header = "A|B|Parsed(A)|Parsed(B)|PC(A)|PC(B)".split("|")
return Table(header=header, data=data)
def __init__(self,
eqnset,
default_parameters=None,
recordables_map=None,
recordables_data=None,
**kwargs):
super(NeuroUnitEqnsetPostSynaptic, self).__init__(**kwargs)
if isinstance(eqnset, basestring):
eqnset = NeuroUnitParser.EqnSet(eqnset)
self.eqnset = eqnset
self._default_parameters = default_parameters or {}
self.recordables_map = recordables_map or {}
self.recordables_data = recordables_data or {}
for param in eqnset.parameters:
print param
print param.symbol
print 'iii', param.get_dimension().as_quantities_unit(), type(
param.get_dimension().as_quantities_unit())
print "iiii", self._default_parameters[param.symbol], type(
self._default_parameters[param.symbol])
assert param.symbol in self._default_parameters
assert (param.get_dimension().as_quantities_unit() /
self._default_parameters[param.symbol]).rescale("")
def __init__(self,
eqnset,
default_parameters={},
recordables_map=None,
recordables_data=None,
**kwargs):
super(NeuroUnitEqnsetMechanism, self).__init__(**kwargs)
if isinstance(eqnset, basestring):
eqnset = NeuroUnitParser.EqnSet(eqnset)
#self.name = name if name is not None else ObjectLabeller.get_next_unamed_object_name(NeuroUnitEqnsetMechanism)
self._parameters = default_parameters
self.eqnset = eqnset
self.recordables_map = recordables_map or {}
self.recordables_data = recordables_data or {}
for param in eqnset.parameters:
print 'CHECKING'
print param
print param.symbol
print 'iii', param.get_dimension().as_quantities_unit(), type(
param.get_dimension().as_quantities_unit())
print "iiii", default_parameters[param.symbol], type(
default_parameters[param.symbol])
assert param.symbol in default_parameters
assert (param.get_dimension().as_quantities_unit() /
default_parameters[param.symbol]).rescale("")
print 'OK\n'
def test_quantitysimple():
data = []
for (a, b, check_with_gnu) in valid_quantitysimple:
A = NeuroUnitParser.QuantitySimple(a)
B = NeuroUnitParser.QuantitySimple(b)
if check_with_gnu:
verify_equivalence_with_gnuunits(a, b)
pcA = ((A - B) / A).dimensionless()
pcB = ((A - B) / B).dimensionless()
assert pcA == 0
assert pcB == 0
data.append([a, b, str(A), str(B), str(pcA), str(pcB)])
header = "A|B|Parsed(A)|Parsed(B)|PC(A)|PC(B)".split("|")
return Table(header=header, data=data)
def document_eqnsets(individual_reports=True):
all_redocs = []
for f in TestLocations.getEqnSetFiles():
f_basename = os.path.splitext( os.path.basename(f))[0]
# Load the EqnSet:
library_manager = NeuroUnitParser.File( open(f).read(), name=f_basename )
# Create the documentation:
local_redoc = MRedocWriterVisitor.build( library_manager)
# Create a local documentation file:
if individual_reports:
doc = Document(TableOfContents(), local_redoc)
doc.to_pdf( Join(TestLocations.getTestOutputDir(), 'eqnsets_%s.pdf' %f_basename ) )
# Add it to single large file:
all_redocs.append( local_redoc )
return all_redocs
def build_figures(eqnset):
plots = {}
# Find all assignments only dependant on 1 supplied values and parameters:
for a in eqnset.assignedvalues:
all_deps = eqnset.getSymbolDependancicesIndirect(
a, include_ass_in_output=False)
deps_sup = [d for d in all_deps if isinstance(d, SuppliedValue)]
deps_params = [d for d in all_deps if isinstance(d, Parameter)]
deps_state = [d for d in all_deps if isinstance(d, StateVariable)]
deps_reduce_ports = [
d for d in all_deps if isinstance(d, AnalogReducePort)
]
assert len(deps_sup + deps_params + deps_state +
deps_reduce_ports) == len(all_deps)
# Ignore anything deopendant on state variables:
if len(deps_state) != 0:
continue
# We can't be dependant on parameters:
if len(deps_params) != 0:
continue
if len(deps_sup) == 1:
sup = deps_sup[0]
meta = eqnset.getSymbolMetadata(sup)
if not meta:
continue
print meta
if not 'mf' in meta or not 'role' in meta['mf']:
continue
role = meta['mf']['role']
if role != 'MEMBRANEVOLTAGE':
continue
F = FunctorGenerator()
F.visit(eqnset)
f = F.assignment_evaluators[a.symbol]
try:
vVals = [-80, -70, -60, -40, -20, 0, 20, 40]
vVals = np.linspace(-80, 50, 22) #* pq.milli * pq.volt
oUnit = None
fOut = []
for v in vVals:
from neurounits.neurounitparser import NeuroUnitParser
vUnit = NeuroUnitParser.QuantitySimple('%f mV' % v)
vRes = f(V=vUnit, v=vUnit)
if oUnit is None:
oUnit = vRes.unit
assert vRes.unit == oUnit
fOut.append(vRes.magnitude)
except ZeroDivisionError:
color = 'r'
import pylab
f = pylab.figure(figsize=(2, 2))
ax = f.add_subplot(1, 1, 1)
ax.plot(vVals, vVals, color=color)
f.suptitle('ERROR PLOTTING: Graph of %s against %s ' %
(a.symbol, 'V'))
ax.set_xlabel('Membrane Voltage (mV)')
ax.set_ylabel('%s (%s)' % (a.symbol, oUnit))
ax.grid('on')
plots[a.symbol] = f
else:
color = 'b'
import pylab
f = pylab.figure(figsize=(2, 2))
ax = f.add_subplot(1, 1, 1)
ax.plot(vVals, fOut, color=color)
f.suptitle('Graph of %s against V' % a.symbol)
ax.set_xlabel('Membrane Voltage (mV)')
dim = FormatDimensionality(oUnit)
ax.set_ylabel('%s (%s)' %
(a.symbol, '$%s$' % dim if dim.strip() else ''))
ax.grid('on')
plots[a.symbol] = f
# Build figure groups based on the first term:
if len(plots) <= 3:
imgs = [Image(f) for f in sorted(plots.values())]
F = Figure(caption='Plots for channel', *imgs)
return [F]
states = set([k.split('_')[0] for k in plots.keys()])
img_sets = []
for s in states:
vs = [(k, v) for (k, v) in plots.iteritems() if k.split('_')[0] == s]
imgs = [Image(f[1]) for f in sorted(vs)]
img_sets.append((imgs, s))
ps = [
Figure(caption='State:%s' % state, *imgs) for (imgs, state) in img_sets
]
return ps
"""
# Add 'straight.plugin' into the python path
try:
import straight.plugin
except ImportError:
import sys, os
localdir = os.path.dirname(__file__)
ext_deps_dir = os.path.abspath(os.path.join(localdir, '../../ext_deps/'))
print ext_deps_dir
sys.path.append(os.path.join(ext_deps_dir, 'straight.plugin/'))
import straight.plugin
# Standard imports:
from neurounits.neurounitparser import NeuroUnitParser, MQ1
from neurounits.neurounitparser import NeuroUnitParserOptions
from neurounits.unit_expr_parsing.units_expr_yacc import ParseTypes
from neurounits.nuts_io import NutsIO
from neurounits.locations import Locations
from neurounits.ast import NineMLComponent
Q1 = lambda o: NeuroUnitParser.QuantitySimple(o).as_quantities_quantity()
Q2 = lambda o: NeuroUnitParser.QuantityExpr(o).as_quantities_quantity()