def validate_observation(self, observation,
united_keys=['value','mean'], nonunited_keys=[]):
try:
assert type(observation) is dict
assert any([key in observation for key in united_keys]) \
or len(nonunited_keys)
for key in united_keys:
if key in observation:
assert type(observation[key]) is pq.quantity.Quantity
for key in nonunited_keys:
if key in observation:
assert type(observation[key]) is not pq.quantity.Quantity \
or observation[key].units == pq.Dimensionless
except Exception as e:
key_str = 'and/or a '.join(['%s key' % key for key in united_keys])
msg = ("Observation must be a dictionary with a %s and each key "
"must have units from the quantities package." % key_str)
raise sciunit.ObservationError(msg)
for key in united_keys:
if key in observation:
provided = observation[key].simplified.units
required = self.units.simplified.units
if provided != required: # Units don't match spec.
msg = ("Units of %s are required for %s but units of %s "
"were provided" % (required.dimensionality.__str__(),
key,
provided.dimensionality.__str__())
)
raise sciunit.ObservationError(msg)
def validate_observation(self, observation):
for val in observation.values(): # val0: a list with synapses fraction in each of the
# Hippocampus CA1 layers (SO, SP, SR, SLM) and OUT (=0.0 by default)
# for each m-type cell (AA, BP, BS, CCKBC, Ivy, OLM, PC, PPA, SCA, Tri)
assert type(val) is quantities.Quantity, \
sciunit.ObservationError("Observation about synapses fraction in each CA1-layer"
"must be of the form {'mean': XX}")
def validate_observation(self, observation):
try:
for key, val in observation["density"].items():
assert type(observation["density"][key]) is quantities.Quantity
except Exception:
raise sciunit.ObservationError(
("Observation must return a dictionary of the form:"
"{'density': {'mean': 'XX 1000/mm3', 'std': 'YY 1000/mm3'}}"))
def validate_observation(self, observation):
try:
for key0 in observation.keys():
for key, val in observation["diameter"].items():
assert type(
observation["diameter"][key]) is quantities.Quantity
except Exception:
raise sciunit.ObservationError(
("Observation must return a dictionary of the form:"
"{'diameter': {'min': 'XX um', 'max': 'YY um'}}"))
def validate_observation(self, observation):
try:
assert type(observation) is dict, 'Observation must be a dict'
assert type(observation['spike_trains']) is list, \
"observation['spike_trains'] must be a list"
for spike_train in observation['spike_trains']:
assert type(spike_train) is SpikeTrain, \
"Each spike_train must be a NeuroTools SpikeTrain"
assert type(observation['current']) is AnalogSignal, \
"observation['current'] must be a NeuroTools AnalogSignal"
except AssertionError, e:
raise sciunit.ObservationError(e.message)
def validate_observation(self, observation):
try:
for key0 in observation.keys():
for key, val in observation[key0]["height"].items():
assert type(observation[key0]["height"]
[key]) is quantities.Quantity
except Exception:
raise sciunit.ObservationError((
"Observation must return a dictionary of the form:"
"{'Layer 1': {'height': {'mean': 'X0 um', 'std': 'Y0 um'}},"
" 'Layer 2/3': {'height': {'mean': 'X1 um', 'std': 'Y1 um'}},"
" ... }))"
))
def validate_observation(self, observation):
if observation.size == 0:
raise sciunit.ObservationError("Observation is empty!")
