def __init__(self, h, a):
# define new units
#----------------------------------------------------
self.h = pq.UnitQuantity('dimensionless hubble parameter',
h,
symbol='hh')
self.a = pq.UnitQuantity('scale factor a = 1/(1+z)', a, symbol='aa')
Units.__init__(self)
def __init__(self):
self.cell = Organelle("cell")
self.nucleus = Organelle('nucleus')
self.cell.diameter = pq.Quantity(5, 'um')
self.cell.volume = pq.Quantity(50, 'um**3')
self.nucleus.diameter = pq.Quantity(2, 'um')
self.nucleus.volume = pq.UncertainQuantity(2.9, 'um**3', 0.2)
pq.nucleur_volume = pq.UnitQuantity('nuclear volume',
self.nucleus.volume,
symbol='NucVol')
pq.cell_volume = pq.UnitQuantity('cellular volume',
self.cell.volume,
symbol='CellVol')
def declare_unit(obj, unit_key, conversion, name, base=False):
"""
Create and return unit using specified package.
"""
if obj.package == 'Quantities':
unit_obj = pq.UnitQuantity(name,
definition=conversion,
symbol=unit_key)
if base:
unit = [(unit_obj, unit_key, conversion, name)]
obj._set_base_units_pq(unit)
else:
unit = [(unit_obj, conversion)]
obj.initialize_units(unit)
return unit_obj
if obj.package == 'Unum':
if conversion is None:
conversion = 0
obj.del_unit(unit_key)
unit_obj = unum.Unum.unit(unit_key, conversion, name)
if base:
unit = [(unit_obj, unit_key, conversion, name)]
obj._set_base_units_unum(unit)
else:
unit = [(unit_obj, conversion)]
obj.initialize_units(unit)
return unit_obj
def from_destructured(self, unit_dict):
unit = pq.UnitQuantity(
unit_dict.get('name'),
import_class(unit_dict.get('base').get('quantity')) *
unit_dict.get('base').get('coefficient'), unit_dict.get('symbol'))
return unit
def __init__(self):
""" Define units """
self.mF = pq.UnitQuantity('millifarad', pq.farad / 1e3, symbol='mF')
self.uF = pq.UnitQuantity('microfarad', pq.farad / 1e6, symbol='uF')
self.nF = pq.UnitQuantity('nanofarad', pq.farad / 1e9, symbol='nF')
self.pF = pq.UnitQuantity('picofarad', pq.farad / 1e12, symbol='pF')
self.mH = pq.UnitQuantity('millihenry', pq.henry / 1e3, symbol='mH')
self.uH = pq.UnitQuantity('microhenry', pq.henry / 1e6, symbol='uH')
self.nH = pq.UnitQuantity('nanohenry', pq.henry / 1e9, symbol='nH')
self.pH = pq.UnitQuantity('picohenry', pq.henry / 1e12, symbol='pH')
def __init__(self, observation={}, name="Cell Density Test"):
description = ("Tests the cell density within a single layer of model")
self.units = quantities.UnitQuantity('1000/mm3',
1e3 / quantities.mm**3,
symbol='1000/mm3')
required_capabilities = (cap.ProvidesDensityInfo, )
observation = self.format_data(observation)
self.figures = []
sciunit.Test.__init__(self, observation, name)
self.directory_output = './output/'
def iCSD(lfp_data):
#patch quantities with the SI unit Siemens if it does not exist
for symbol, prefix, definition, u_symbol in zip(
['siemens', 'S', 'mS', 'uS', 'nS', 'pS'],
['', '', 'milli', 'micro', 'nano', 'pico'],
[pq.A / pq.V, pq.A / pq.V, 'S', 'mS', 'uS', 'nS'],
[None, None, None, None, u'uS', None]):
if type(definition) is str:
definition = lastdefinition / 1000
if not hasattr(pq, symbol):
setattr(
pq, symbol,
pq.UnitQuantity(prefix + 'siemens',
definition,
symbol=symbol,
u_symbol=u_symbol))
lastdefinition = definition
#prepare lfp data for use, by changing the units to SI and append quantities,
#along with electrode geometry, conductivities and assumed source geometry
lfp_data = lfp_data * 1E-6 * pq.V # [uV] -> [V]
#z_data = np.linspace(100E-6, 2300E-6, 23) * pq.m # [m]
z_data = np.linspace(100E-6, 1000E-6, 32) * pq.m # [m]
#diam = 500E-6 * pq.m # [m]
diam = 250E-6 * pq.m # [m] bigger vals make smaller sources/sinks
h = 100E-6 * pq.m # [m] (makes no difference with spline iCSD method)
sigma = 0.3 * pq.S / pq.m # [S/m] or [1/(ohm*m)] (makes no difference with spline iCSD method)
sigma_top = 0.3 * pq.S / pq.m # [S/m] or [1/(ohm*m)]
# Input dictionaries for each method
spline_input = {
'lfp': lfp_data,
'coord_electrode': z_data,
'diam': diam,
'sigma': sigma,
'sigma_top': sigma,
'num_steps': 201, # Spatial CSD upsampling to N steps
'tol': 1E-12,
'f_type': 'gaussian',
'f_order': (20, 5),
}
# how to call!
csd_obj = icsd.SplineiCSD(**spline_input)
csd = csd_obj.get_csd()
csd = csd_obj.filter_csd(csd)
return csd
def patch_quantities():
"""patch quantities with the SI unit Siemens if it does not exist"""
for symbol, prefix, definition, u_symbol in zip(
['siemens', 'S', 'mS', 'uS', 'nS', 'pS'],
['', '', 'milli', 'micro', 'nano', 'pico'],
[pq.A / pq.V, pq.A / pq.V, 'S', 'mS', 'uS', 'nS'],
[None, None, None, None, u'µS', None]):
if type(definition) is str:
definition = lastdefinition / 1000
if not hasattr(pq, symbol):
setattr(
pq, symbol,
pq.UnitQuantity(prefix + 'siemens',
definition,
symbol=symbol,
u_symbol=u_symbol))
lastdefinition = definition
return
class RandomTest(sciunit.Test):
required_capabilities = (ProducesSpikes, )
score_type = sciunit.scores.ZScore
url = 'http://test-url.com'
units = pq.UnitQuantity('megaohm', pq.ohm * 1e6, symbol='Mohm') # Megaohms
observation_schema = [("Mean, Standard Deviation, N", {
'mean': {
'units': True,
'required': True
},
'std': {
'units': True,
'min': 0,
'required': True
},
'n': {
'type': 'integer',
'min': 1
}
}),
("Mean, Standard Error, N", {
'mean': {
'units': True,
'required': True
},
'sem': {
'units': True,
'min': 0,
'required': True
},
'n': {
'type': 'integer',
'min': 1,
'required': True
}
})]
def generate_prediction(self, model):
count = model.get_spike_count()
return 1 * pq.MOhm
import quantities as pq
import warnings
from neo.io.baseio import BaseIO
from neo.core import Segment, AnalogSignal, SpikeTrain
try:
unicode
PY2 = True
except NameError:
PY2 = False
UNITS_MAP = {
'spikes': pq.ms,
'v': pq.mV,
'gsyn': pq.UnitQuantity('microsiemens', 1e-6 * pq.S, 'uS',
'µS'), # checked
}
class BasePyNNIO(BaseIO):
"""
Base class for PyNN IO classes
"""
is_readable = True
is_writable = True
has_header = True
is_streameable = False # TODO - correct spelling to "is_streamable"
supported_objects = [Segment, AnalogSignal, SpikeTrain]
readable_objects = supported_objects
writeable_objects = supported_objects
mode = 'file'
"""
Small module to manage units and dimension analysis
"""
import quantities as pq
temperature = 300 * pq.K
kT = pq.UnitQuantity("k_B T", definition=300 * pq.K * 1 * pq.constants.k, symbol="kT")
length = pq.um
force = pq.UnitQuantity("nanonewton", definition=1e-9 * pq.N, symbol="nN")
energy = pq.UnitQuantity("femtojoules", definition=force * length, symbol="fJ")
time = pq.s
line_tension = energy / length
line_elasticity = energy / length ** 2
line_viscosity = force * time / length
area = length ** 2
area_tension = energy / area
area_elasticity = energy / area ** 2
vol = length ** 3
vol_tension = energy / vol
vol_elasticity = energy / vol ** 2
.. autoclass:: EphyviewerConfigurator
:members:
"""
import re
import numpy as np
import pandas as pd
import quantities as pq
import ephyviewer
from ..datasets.metadata import _abs_path
from ..gui.epochencoder import NeuroticWritableEpochSource
pq.mN = pq.UnitQuantity('millinewton', pq.N/1e3, symbol = 'mN'); # define millinewton
class EphyviewerConfigurator():
"""
A class for launching ephyviewer for a dataset with configurable viewers.
At initialization, invalid viewers are automatically disabled (e.g., the
video viewer is disabled if ``video_file`` is not given in ``metadata``).
Viewers can be hidden or shown before launch using the built-in methods.
Valid viewer names are:
* ``traces``
* ``traces_rauc``
* ``freqs``
* ``spike_trains``
def run(opt, star, planet, zodi):
exosim_msg('Run instrument model ... ')
st = time.time()
instrument_emission = Sed(star.sed.wl,
np.zeros(star.sed.wl.size, dtype=np.float64)* \
pq.W/pq.m**2/pq.um/pq.sr)
instrument_transmission = Sed(star.sed.wl,
np.ones(star.sed.wl.size, dtype=np.float64))
for op in opt.common_optics.optical_surface:
dtmp_tr = np.loadtxt(op.transmission.replace('__path__', opt.__path__),
delimiter=',')
dtmp_em = np.loadtxt(op.emissivity.replace('__path__', opt.__path__),
delimiter=',')
tr = Sed(dtmp_tr[:, 0] * pq.um, dtmp_tr[:, 1] * pq.dimensionless)
tr.rebin(opt.common.common_wl)
em = Sed(dtmp_em[:, 0] * pq.um, dtmp_em[:, 1] * pq.dimensionless)
em.rebin(opt.common.common_wl)
exolib.sed_propagation(star.sed, tr)
exolib.sed_propagation(zodi.sed, tr)
exolib.sed_propagation(instrument_emission,
tr,
emissivity=em,
temperature=op())
instrument_transmission.sed = instrument_transmission.sed * tr.sed
channel = {}
for ch in opt.channel:
#if ch.name != 'NIR Spec': continue
channel[ch.name] = Channel(star.sed,
planet.cr,
zodi.sed,
instrument_emission,
instrument_transmission,
options=ch)
ch_optical_surface = ch.optical_surface if isinstance(ch.optical_surface, list) else \
[ch.optical_surface]
for op in ch.optical_surface:
dtmp = np.loadtxt(op.transmission.replace('__path__',
opt.__path__),
delimiter=',')
tr = Sed(dtmp[:,0]*pq.um, \
dtmp[:,1]*pq.dimensionless)
tr.rebin(opt.common.common_wl)
em = Sed(dtmp[:,0]*pq.um, \
dtmp[:,2]*pq.dimensionless)
em.rebin(opt.common.common_wl)
exolib.sed_propagation(channel[ch.name].star, tr)
exolib.sed_propagation(channel[ch.name].zodi, tr)
exolib.sed_propagation(channel[ch.name].emission, \
tr, emissivity=em,temperature=op())
channel[ch.name].transmission.sed *= tr.sed
# BUG workaround. There is a bug in the binning function. If transmission is zero,
# it is rebiined to a finite, very small value. This needs to be fixed!
# For now, I set to zero all transmission smaller than an arbitrary value
#idx = np.where(channel[ch.name].transmission.sed < 1.0e-5)
#channel[ch.name].star.sed[idx] = 0.0*channel[ch.name].star.sed.units
#channel[ch.name].zodi.sed[idx] = 0.0*channel[ch.name].zodi.sed.units
#channel[ch.name].emission.sed[idx] = 0.0*channel[ch.name].emission.sed.units
#channel[ch.name].transmission.sed[idx] = 0.0*channel[ch.name].transmission.sed.units
# Convert spectral signals
dtmp = np.loadtxt(ch.qe().replace('__path__', opt.__path__),
delimiter=',')
qe = Sed(dtmp[:,0]*pq.um, \
dtmp[:,1]*pq.dimensionless)
Responsivity = qe.sed * qe.wl.rescale(
pq.m) / (spc.c * spc.h * pq.m * pq.J) * pq.UnitQuantity(
'electron', symbol='e-')
Re = scipy.interpolate.interp1d(qe.wl, Responsivity)
Aeff = 0.25 * np.pi * opt.common_optics.TelescopeEffectiveDiameter()**2
Omega_pix = 2.0 * np.pi * (1.0 -
np.cos(np.arctan(0.5 / ch.wfno()))) * pq.sr
Apix = ch.detector_pixel.pixel_size()**2
channel[ch.name].star.sed *= Aeff * \
Re(channel[ch.name].star.wl)*pq.UnitQuantity('electron', 1*pq.counts, symbol='e-')/pq.J
channel[ch.name].zodi.sed *= Apix * Omega_pix * \
Re(channel[ch.name].zodi.wl)*pq.UnitQuantity('electron', 1*pq.counts, symbol='e-')/pq.J
channel[ch.name].emission.sed *= Apix * Omega_pix * \
Re(channel[ch.name].emission.wl)*pq.UnitQuantity('electron', 1*pq.counts, symbol='e-')/pq.J
### create focal plane
#1# allocate focal plane with pixel oversampling such that Nyquist sampling is done correctly
fpn = ch.array_geometry()
fp = np.zeros((fpn * ch.osf()).astype(np.int))
#2# This is the current sampling interval in the focal plane.
fp_delta = ch.detector_pixel.pixel_size() / ch.osf()
#3# Load dispersion law
if ch.type == 'spectrometer':
if hasattr(ch, "dispersion"):
dtmp = np.loadtxt(ch.dispersion.path.replace(
'__path__', opt.__path__),
delimiter=',')
ld = scipy.interpolate.interp1d(dtmp[..., 2] * pq.um +
ch.dispersion().rescale(pq.um),
dtmp[..., 0],
bounds_error=False,
kind='slinear',
fill_value=0.0)
elif hasattr(ch, "ld"):
# wl = ld[0] + ld[1](x - ld[2]) = ld[1]*x + ld[0]-ldp[1]*ld[2]
ld = np.poly1d(
(ch.ld()[1], ch.ld()[0] - ch.ld()[1] * ch.ld()[2]))
else:
exolib.exosim_error("Dispersion law not defined.")
#4a# Estimate pixel and wavelength coordinates
x_pix_osr = np.arange(fp.shape[1]) * fp_delta
x_wav_osr = ld(x_pix_osr.rescale(
pq.um).magnitude) * pq.um # walength on each x pixel
channel[ch.name].wl_solution = x_wav_osr
elif ch.type == 'photometer':
#4b# Estimate pixel and wavelength coordinates
idx = np.where(channel[ch.name].transmission.sed >
channel[ch.name].transmission.sed.max() / np.e)
x_wav_osr = np.linspace(
channel[ch.name].transmission.wl[idx].min().item(),
channel[ch.name].transmission.wl[idx].max().item(),
8 * ch.osf()) * channel[ch.name].transmission.wl.units
x_wav_center = (channel[ch.name].transmission.wl[idx]*channel[ch.name].transmission.sed[idx]).sum() / \
channel[ch.name].transmission.sed[idx].sum()
channel[ch.name].wl_solution = np.repeat(x_wav_center, fp.shape[1])
else:
exolib.exosim_error(
"Channel should be either photometer or spectrometer.")
d_x_wav_osr = np.zeros_like(x_wav_osr)
idx = np.where(x_wav_osr > 0.0)
d_x_wav_osr[idx] = np.gradient(x_wav_osr[idx])
if np.any(d_x_wav_osr < 0): d_x_wav_osr *= -1.0
#5# Generate PSFs, one in each detector pixel along spectral axis
psf = exolib.Psf(x_wav_osr, ch.wfno(), \
fp_delta, shape='airy')
#6# Save results in Channel class
channel[ch.name].fp_delta = fp_delta
channel[ch.name].psf = psf
channel[ch.name].fp = fp
channel[ch.name].osf = np.int(ch.osf())
channel[ch.name].offs = np.int(ch.pix_offs())
channel[ch.name].planet.sed *= channel[ch.name].star.sed
channel[ch.name].star.rebin(x_wav_osr)
channel[ch.name].planet.rebin(x_wav_osr)
channel[ch.name].zodi.rebin(x_wav_osr)
channel[ch.name].emission.rebin(x_wav_osr)
channel[ch.name].transmission.rebin(x_wav_osr)
channel[ch.name].star.sed *= d_x_wav_osr
channel[ch.name].planet.sed *= d_x_wav_osr
channel[ch.name].zodi.sed *= d_x_wav_osr
channel[ch.name].emission.sed *= d_x_wav_osr
#7# Populate focal plane with monochromatic PSFs
if ch.type == 'spectrometer':
j0 = np.round(np.arange(fp.shape[1]) - psf.shape[1] // 2).astype(
np.int)
elif ch.type == 'photometer':
j0 = np.repeat(fp.shape[1] // 2, x_wav_osr.size)
else:
exolib.exosim_error(
"Channel should be either photometer or spectrometer.")
j1 = j0 + psf.shape[1]
idx = np.where((j0 >= 0) & (j1 < fp.shape[1]))[0]
i0 = fp.shape[0] // 2 - psf.shape[0] // 2 + channel[ch.name].offs
i1 = i0 + psf.shape[0]
for k in idx: channel[ch.name].fp[i0:i1, j0[k]:j1[k]] += psf[...,k] * \
channel[ch.name].star.sed[k]
#9# Now deal with the planet
planet_response = np.zeros(fp.shape[1])
i0p = np.unravel_index(np.argmax(channel[ch.name].psf.sum(axis=2)),
channel[ch.name].psf[..., 0].shape)[0]
for k in idx:
planet_response[j0[k]:j1[k]] += psf[i0p, :, k] * channel[
ch.name].planet.sed[k]
#9# Allocate pixel response function
kernel, kernel_delta = exolib.PixelResponseFunction(
channel[ch.name].psf.shape[0:2],
7 * ch.osf(), # NEED TO CHANGE FACTOR OF 7
ch.detector_pixel.pixel_size(),
lx=ch.detector_pixel.pixel_diffusion_length())
channel[ch.name].fp = exolib.fast_convolution(
channel[ch.name].fp, channel[ch.name].fp_delta, kernel,
kernel_delta)
## TODO CHANGE THIS: need to convolve planet with pixel response function
channel[ch.name].planet = Sed(
channel[ch.name].wl_solution,
planet_response / (1e-30 + fp[(i0 + i1) // 2, ...]))
## Fix units
channel[
ch.name].fp = channel[ch.name].fp * channel[ch.name].star.sed.units
channel[ch.name].planet.sed = channel[
ch.name].planet.sed * pq.dimensionless
## Deal with diffuse radiation
if ch.type == 'spectrometer':
channel[ch.name].zodi.sed = scipy.convolve(
channel[ch.name].zodi.sed,
np.ones(np.int(ch.slit_width() * channel[ch.name].opt.osf())),
'same') * channel[ch.name].zodi.sed.units
channel[ch.name].emission.sed = scipy.convolve(
channel[ch.name].emission.sed,
np.ones(np.int(ch.slit_width() * channel[ch.name].opt.osf())),
'same') * channel[ch.name].emission.sed.units
elif ch.type == 'photometer':
channel[ch.name].zodi.sed = np.repeat(
channel[ch.name].zodi.sed.sum(),
channel[ch.name].wl_solution.size)
channel[ch.name].zodi.wl = channel[ch.name].wl_solution
channel[ch.name].emission.sed = np.repeat(
channel[ch.name].emission.sed.sum(),
channel[ch.name].wl_solution.size)
channel[ch.name].emission.wl = channel[ch.name].wl_solution
else:
exolib.exosim_error(
"Channel should be either photometer or spectrometer.")
exosim_msg(' - execution time: {:.0f} msec.\n'.format(
(time.time() - st) * 1000.0))
return channel
pass
:param precision:
:param tex: Whether the string should be formatted for LaTeX.
"""
if tex:
unit_str = as_latex(value)
else:
attr = "unicode" if quantities.markup.config.use_unicode else "string"
unit_str = getattr(value.dimensionality, attr)
return precision % float(value.magnitude), unit_str
# Additional units to complement quantities
#: Per 100 electronVolts.
per100eV = quantities.UnitQuantity(
"per_100_eV",
1 / (100 * quantities.eV * quantities.constants.Avogadro_constant),
u_symbol="(100eV)**-1")
#: Decimetre
dm = decimetre = quantities.UnitQuantity("decimetre",
quantities.m / 10.0,
u_symbol="dm")
#: Square metre
m3 = quantities.metre**3
#: Square decimetre
dm3 = decimetre**3
#: Square cenimetre
cm3 = quantities.centimetre**3
:copyright: Copyright 2006-2015 by the PyNN team, see AUTHORS.
:license: CeCILL, see LICENSE for details.
"""
import logging
import numpy
import quantities as pq
import neo
import brian
from pyNN import recording
from . import simulator
mV = brian.mV
ms = brian.ms
uS = brian.uS
pq.uS = pq.UnitQuantity('microsiemens', 1e-6*pq.S, 'uS')
pq.nS = pq.UnitQuantity('nanosiemens', 1e-9*pq.S, 'nS')
logger = logging.getLogger("PyNN")
class Recorder(recording.Recorder):
"""Encapsulates data and functions related to recording model variables."""
_simulator = simulator
def __init__(self, population=None, file=None):
__doc__ = recording.Recorder.__doc__
recording.Recorder.__init__(self, population, file)
self._devices = {} # defer creation until first call of record()
def _create_device(self, group, variable):
"""
return self.dot_product(other) / (self.get_magnitude() *
other.get_magnitude())
def is_collinear(self, other):
value = abs(self.cos_theta(other))
return values_are_equal(1, value)
def __add__(self, other):
return Vector(self.x + other.x, self.y + other.y)
def __mul__(self, other):
return Vector(self.x * other, self.y * other)
def __truediv__(self, other):
return Vector(self.x / other, self.y / other)
def __sub__(self, other):
return Vector(self.x - other.x, self.y - other.y)
Vector.ZERO = Vector(0, 0)
NUMBER_OF_SIGNIFICANT_DIGITS = 3
TOLERANCE = 10**-8 # Used when checking if floats are equal
FACTOR_OF_SAFETY_BUCKLING = 3
FACTOR_OF_SAFETY_YIELDING = 2
YIELD_STRESS = 350 * pq.MPa
YOUNG_MODULUS = 200000 * pq.MPa
kN = pq.UnitQuantity("kiloNewton", pq.N * 1000, "kN")
from scipy.interpolate import interp1d
from elephant.current_source_density import icsd
import unittest
# patch quantities with the SI unit Siemens if it does not exist
for symbol, prefix, definition, u_symbol in zip(
['siemens', 'S', 'mS', 'uS', 'nS', 'pS'],
['', '', 'milli', 'micro', 'nano', 'pico'],
[pq.A / pq.V, pq.A / pq.V, 'S', 'mS', 'uS', 'nS'],
[None, None, None, None, u'µS', None]):
if isinstance(definition, str):
definition = lastdefinition / 1000
if not hasattr(pq, symbol):
setattr(pq, symbol, pq.UnitQuantity(
prefix + 'siemens',
definition,
symbol=symbol,
u_symbol=u_symbol))
lastdefinition = definition
def potential_of_plane(z_j, z_i=0. * pq.m,
C_i=1 * pq.A / pq.m**2,
sigma=0.3 * pq.S / pq.m):
'''
Return potential of infinite horizontal plane with constant
current source density at a vertical offset z_j.
Arguments
---------
z_j : float*pq.m
"""
sonde.quantities
~~~~~~~~~~~~~~~~
This module contains a few custom quantities that are used
primarily for unit conversion.
"""
from __future__ import absolute_import
import quantities as pq
#: Unit of concentration - milligrams per liter
mgl = pq.UnitQuantity('Concentration', pq.CompoundUnit("mg/L"), symbol='mg/L')
#: Unit of specific conductivity - milliSiemens per centimeter
mScm = pq.UnitQuantity('Specific Conductivity in MilliSiemens per Centimeter',
pq.CompoundUnit("1e-3*S/cm"),
symbol='mS/cm')
#: Unit of turbidity - nephelometric turbidity units
ntu = pq.UnitQuantity('Turbidity', pq.dimensionless, symbol='NTU')
#: Unit of salinity - practical salinity units
psu = pq.UnitQuantity('Salinity', pq.dimensionless, symbol='PSU')
ppt = psu
# nickname for dimensionless
dl = pq.dimensionless
#unit of speed
mps = pq.UnitQuantity('Speed', pq.m / pq.second, symbol='m/s')
#!/Library/Frameworks/Python.framework/Versions/Current/bin/python
# salines.py
#
#
# Created by Theodore Lindsay on 10/2/09.
# Copyright (c) 2009 University of Oregon. All rights reserved.
#
"""calculate recipe for a volume of saline given the desired concentrations"""
import quantities as pq
#from psilentplib import Struct
pq.molar = pq.UnitQuantity('molar', pq.mol/pq.liter, symbol='M')
class Struct:
"""general structure class"""
def __init__ (self, *argv, **argd):
if len(argd):
# Update by dictionary
self.__dict__.update (argd)
else:
# Update by position
attrs = filter (lambda x: x[0:2] != "__", dir(self))
for n in range(len(argv)):
setattr(self, attrs[n], argv[n])
class ion(object):
def __init__(self,species,concentration):
self.species = species
self.conc = concentration
self.mob = mob(species)
def getUnits():
pq.AU = pq.UnitQuantity('arbitrary units', 1, symbol='AU')
pq.uL = pq.UnitQuantity('microliter', 0.001 * pq.mL, symbol='uL')
pq.nL = pq.UnitQuantity('nanoliter', 0.001 * pq.uL, symbol='nL')
pq.pL = pq.UnitQuantity('picoliter', 0.001 * pq.nL, symbol='pL')
pq.fL = pq.UnitQuantity('femtoliter', 0.001 * pq.pL, symbol='fL')
pq.uM = pq.UnitQuantity('micromolar', 0.001 * pq.mM, symbol='uM')
pq.nM = pq.UnitQuantity('nanomolar', 0.001 * pq.uM, symbol='nM')
pq.Rgas = pq.UnitQuantity('gas constant',
1.987 * pq.cal / pq.Kelvin / pq.mol)
pq.kb = pq.UnitQuantity('Boltzmann\'s constant', 1.38E-23 * pq.J / pq.K)
pq.Cal = pq.UnitQuantity('Calorie', 1000 * pq.cal)
pq.plank = pq.UnitQuantity('Plank\'s constant', 6.626E-34 * pq.J * pq.s)
pq.molecule = pq.UnitQuantity('molecule',
pq.mole / 6.0221409e+23,
symbol='molecule')
return pq
+ ' please check the version number of Quantities.')
print(
'EGADS has imported an already installed version of Quantities. If issues occure,'
+ ' please check the version number of Quantities.')
except ImportError:
logging.exception(
'egads - __init__.py - EGADS couldn'
't find quantities. Please check for a valid installation of Quantities'
+ ' or the presence of Quantities in third-party software directory.')
raise ImportError(
'EGADS couldn'
't find quantities. Please check for a valid installation of Quantities'
+ ' or the presence of Quantities in third-party software directory.')
quantities.UnitQuantity('microgram',
quantities.gram / 1e6,
symbol='ug',
aliases=['micrograms'])
quantities.UnitQuantity('hectopascal',
quantities.Pa * 100,
symbol='hPa',
aliases=['hectopascals'])
def change_log_level(log_level='INFO'):
logging.debug('egads - __init__.py - change_log_level - log_level ' +
log_level)
logging.getLogger().setLevel(getattr(logging, log_level))
def set_log_options(log_level=None, log_path=None):
logging.debug('egads - __init__.py - set_log_options - log_level ' +
:copyright: Copyright 2006-2013 by the PyNN team, see AUTHORS.
:license: CeCILL, see LICENSE for details.
"""
import logging
import numpy
import quantities as pq
import neo
import brian
from pyNN import recording
from . import simulator
mV = brian.mV
ms = brian.ms
uS = brian.uS
pq.uS = pq.UnitQuantity('microsiemens', 1e-6 * pq.S, 'uS')
logger = logging.getLogger("PyNN")
class Recorder(recording.Recorder):
"""Encapsulates data and functions related to recording model variables."""
_simulator = simulator
def __init__(self, population=None, file=None):
__doc__ = recording.Recorder.__doc__
recording.Recorder.__init__(self, population, file)
self._devices = {} # defer creation until first call of record()
def _create_device(self, group, variable):
"""Create a Brian recording device."""
class NewportESP301Axis(object):
"""
Encapsulates communication concerning a single axis
of an ESP-301 controller. This class should not be
instantiated by the user directly, but is
returned by `NewportESP301.axis`.
"""
# quantities micro inch
micro_inch = pq.UnitQuantity('micro-inch', pq.inch / 1e6, symbol='uin')
# Some more work might need to be done here to make
# the encoder_step and motor_step functional
# I really don't have a concrete idea how I'm
# going to do this until I have a physical device
_unit_dict = {
0: pq.count,
1: pq.count,
2: pq.mm,
3: pq.um,
4: pq.inch,
5: pq.mil,
6: micro_inch, # compound unit for micro-inch
7: pq.deg,
8: pq.grad,
9: pq.rad,
10: pq.mrad,
11: pq.urad,
}
def __init__(self, controller, axis_id):
if not isinstance(controller, NewportESP301):
raise TypeError("Axis must be controlled by a Newport ESP-301 "
"motor controller.")
self._controller = controller
self._axis_id = axis_id + 1
self._units = self.units
# CONTEXT MANAGERS ##
@contextmanager
def _units_of(self, units):
"""
Sets the units for the corresponding axis to a those given by an integer
label (see `NewportESP301Units`), ensuring that the units are properly
reset at the completion of the context manager.
"""
old_units = self._get_units()
self._set_units(units)
yield
self._set_units(old_units)
# PRIVATE METHODS ##
def _get_units(self):
"""
Returns the integer label for the current units set for this axis.
.. seealso::
NewportESP301Units
"""
return NewportESP301Units(
int(self._newport_cmd("SN?", target=self.axis_id)))
def _set_units(self, new_units):
return self._newport_cmd("SN",
target=self.axis_id,
params=[int(new_units)])
# PROPERTIES ##
@property
def axis_id(self):
"""
Get axis number of Newport Controller
:type: `int`
"""
return self._axis_id
@property
def is_motion_done(self):
"""
`True` if and only if all motion commands have
completed. This method can be used to wait for
a motion command to complete before sending the next
command.
:type: `bool`
"""
return bool(int(self._newport_cmd("MD?", target=self.axis_id)))
@property
def acceleration(self):
"""
Gets/sets the axis acceleration
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport unit
:type: `~quantities.Quantity` or `float`
"""
return assume_units(
float(self._newport_cmd("AC?", target=self.axis_id)),
self._units / (pq.s**2))
@acceleration.setter
def acceleration(self, newval):
if newval is None:
return
newval = float(
assume_units(newval, self._units / (pq.s**2)).rescale(
self._units / (pq.s**2)).magnitude)
self._newport_cmd("AC", target=self.axis_id, params=[newval])
@property
def deceleration(self):
"""
Gets/sets the axis deceleration
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport :math:`\\frac{unit}{s^2}`
:type: `~quantities.Quantity` or float
"""
return assume_units(
float(self._newport_cmd("AG?", target=self.axis_id)),
self._units / (pq.s**2))
@deceleration.setter
def deceleration(self, newval):
if newval is None:
return
newval = float(
assume_units(newval, self._units / (pq.s**2)).rescale(
self._units / (pq.s**2)).magnitude)
self._newport_cmd("AG", target=self.axis_id, params=[newval])
@property
def estop_deceleration(self):
"""
Gets/sets the axis estop deceleration
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport :math:`\\frac{unit}{s^2}`
:type: `~quantities.Quantity` or float
"""
return assume_units(
float(self._newport_cmd("AE?", target=self.axis_id)),
self._units / (pq.s**2))
@estop_deceleration.setter
def estop_deceleration(self, decel):
decel = float(
assume_units(decel, self._units / (pq.s**2)).rescale(
self._units / (pq.s**2)).magnitude)
self._newport_cmd("AE", target=self.axis_id, params=[decel])
@property
def jerk(self):
"""
Gets/sets the jerk rate for the controller
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport unit
:type: `~quantities.Quantity` or `float`
"""
return assume_units(
float(self._newport_cmd("JK?", target=self.axis_id)),
self._units / (pq.s**3))
@jerk.setter
def jerk(self, jerk):
jerk = float(
assume_units(jerk, self._units / (pq.s**3)).rescale(
self._units / (pq.s**3)).magnitude)
self._newport_cmd("JK", target=self.axis_id, params=[jerk])
@property
def velocity(self):
"""
Gets/sets the axis velocity
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport :math:`\\frac{unit}{s}`
:type: `~quantities.Quantity` or `float`
"""
return assume_units(
float(self._newport_cmd("VA?", target=self.axis_id)),
self._units / pq.s)
@velocity.setter
def velocity(self, velocity):
velocity = float(
assume_units(velocity, self._units / (pq.s)).rescale(
self._units / pq.s).magnitude)
self._newport_cmd("VA", target=self.axis_id, params=[velocity])
@property
def max_velocity(self):
"""
Gets/sets the axis maximum velocity
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport :math:`\\frac{unit}{s}`
:type: `~quantities.Quantity` or `float`
"""
return assume_units(
float(self._newport_cmd("VU?", target=self.axis_id)),
self._units / pq.s)
@max_velocity.setter
def max_velocity(self, newval):
if newval is None:
return
newval = float(
assume_units(newval, self._units / pq.s).rescale(self._units /
pq.s).magnitude)
self._newport_cmd("VU", target=self.axis_id, params=[newval])
@property
def max_base_velocity(self):
"""
Gets/sets the maximum base velocity for stepper motors
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport :math:`\\frac{unit}{s}`
:type: `~quantities.Quantity` or `float`
"""
return assume_units(
float(self._newport_cmd("VB?", target=self.axis_id)),
self._units / pq.s)
@max_base_velocity.setter
def max_base_velocity(self, newval):
if newval is None:
return
newval = float(
assume_units(newval, self._units / pq.s).rescale(self._units /
pq.s).magnitude)
self._newport_cmd("VB", target=self.axis_id, params=[newval])
@property
def jog_high_velocity(self):
"""
Gets/sets the axis jog high velocity
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport :math:`\\frac{unit}{s}`
:type: `~quantities.Quantity` or `float`
"""
return assume_units(
float(self._newport_cmd("JH?", target=self.axis_id)),
self._units / pq.s)
@jog_high_velocity.setter
def jog_high_velocity(self, newval):
if newval is None:
return
newval = float(
assume_units(newval, self._units / pq.s).rescale(self._units /
pq.s).magnitude)
self._newport_cmd("JH", target=self.axis_id, params=[newval])
@property
def jog_low_velocity(self):
"""
Gets/sets the axis jog low velocity
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport :math:`\\frac{unit}{s}`
:type: `~quantities.Quantity` or `float`
"""
return assume_units(
float(self._newport_cmd("JW?", target=self.axis_id)),
self._units / pq.s)
@jog_low_velocity.setter
def jog_low_velocity(self, newval):
if newval is None:
return
newval = float(
assume_units(newval, self._units / pq.s).rescale(self._units /
pq.s).magnitude)
self._newport_cmd("JW", target=self.axis_id, params=[newval])
@property
def homing_velocity(self):
"""
Gets/sets the axis homing velocity
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport :math:`\\frac{unit}{s}`
:type: `~quantities.Quantity` or `float`
"""
return assume_units(
float(self._newport_cmd("OH?", target=self.axis_id)),
self._units / pq.s)
@homing_velocity.setter
def homing_velocity(self, newval):
if newval is None:
return
newval = float(
assume_units(newval, self._units / pq.s).rescale(self._units /
pq.s).magnitude)
self._newport_cmd("OH", target=self.axis_id, params=[newval])
@property
def max_acceleration(self):
"""
Gets/sets the axis max acceleration
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport :math:`\\frac{unit}{s^2}`
:type: `~quantities.Quantity` or `float`
"""
return assume_units(
float(self._newport_cmd("AU?", target=self.axis_id)),
self._units / (pq.s**2))
@max_acceleration.setter
def max_acceleration(self, newval):
if newval is None:
return
newval = float(
assume_units(newval, self._units / (pq.s**2)).rescale(
self._units / (pq.s**2)).magnitude)
self._newport_cmd("AU", target=self.axis_id, params=[newval])
@property
def max_deceleration(self):
"""
Gets/sets the axis max decceleration.
Max deaceleration is always the same as acceleration.
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport :math:`\\frac{unit}{s^2}`
:type: `~quantities.Quantity` or `float`
"""
return self.max_acceleration
@max_deceleration.setter
def max_deceleration(self, decel):
decel = float(
assume_units(decel, self._units / (pq.s**2)).rescale(
self._units / (pq.s**2)).magnitude)
self.max_acceleration = decel
@property
def position(self):
"""
Gets real position on axis in units
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport unit
:type: `~quantities.Quantity` or `float`
"""
return assume_units(
float(self._newport_cmd("TP?", target=self.axis_id)), self._units)
@property
def desired_position(self):
"""
Gets desired position on axis in units
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport unit
:type: `~quantities.Quantity` or `float`
"""
return assume_units(
float(self._newport_cmd("DP?", target=self.axis_id)), self._units)
@property
def desired_velocity(self):
"""
Gets the axis desired velocity in unit/s
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport unit/s
:type: `~quantities.Quantity` or `float`
"""
return assume_units(
float(self._newport_cmd("DP?", target=self.axis_id)),
self._units / pq.s)
@property
def home(self):
"""
Gets/sets the axis home position.
Default should be 0 as that sets current position as home
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport unit
:type: `~quantities.Quantity` or `float`
"""
return assume_units(
float(self._newport_cmd("DH?", target=self.axis_id)), self._units)
@home.setter
def home(self, newval=0):
if newval is None:
return
newval = float(
assume_units(newval, self._units).rescale(self._units).magnitude)
self._newport_cmd("DH", target=self.axis_id, params=[newval])
@property
def units(self):
"""
Get the units that all commands are in reference to.
:type: `~quantities.Quantity` with units corresponding to
units of axis connected or int which corresponds to Newport
unit number
"""
self._units = self._get_pq_unit(self._get_units())
return self._units
@units.setter
def units(self, newval):
if newval is None:
return
if isinstance(newval, int):
self._units = self._get_pq_unit(NewportESP301Units(int(newval)))
elif isinstance(newval, pq.Quantity):
self._units = newval
newval = self._get_unit_num(newval)
self._set_units(newval)
@property
def encoder_resolution(self):
"""
Gets/sets the resolution of the encode. The minimum number of units
per step. Encoder functionality must be enabled.
:units: The number of units per encoder step
:type: `~quantities.Quantity` or `float`
"""
return assume_units(
float(self._newport_cmd("SU?", target=self.axis_id)), self._units)
@encoder_resolution.setter
def encoder_resolution(self, newval):
if newval is None:
return
newval = float(
assume_units(newval, self._units).rescale(self._units).magnitude)
self._newport_cmd("SU", target=self.axis_id, params=[newval])
@property
def full_step_resolution(self):
"""
Gets/sets the axis resolution of the encode. The minimum number of
units per step. Encoder functionality must be enabled.
:units: The number of units per encoder step
:type: `~quantities.Quantity` or `float`
"""
return assume_units(
float(self._newport_cmd("FR?", target=self.axis_id)), self._units)
@full_step_resolution.setter
def full_step_resolution(self, newval):
if newval is None:
return
newval = float(
assume_units(newval, self._units).rescale(self._units).magnitude)
self._newport_cmd("FR", target=self.axis_id, params=[newval])
@property
def left_limit(self):
"""
Gets/sets the axis left travel limit
:units: The limit in units
:type: `~quantities.Quantity` or `float`
"""
return assume_units(
float(self._newport_cmd("SL?", target=self.axis_id)), self._units)
@left_limit.setter
def left_limit(self, limit):
limit = float(
assume_units(limit, self._units).rescale(self._units).magnitude)
self._newport_cmd("SL", target=self.axis_id, params=[limit])
@property
def right_limit(self):
"""
Gets/sets the axis right travel limit
:units: units
:type: `~quantities.Quantity` or `float`
"""
return assume_units(
float(self._newport_cmd("SR?", target=self.axis_id)), self._units)
@right_limit.setter
def right_limit(self, limit):
limit = float(
assume_units(limit, self._units).rescale(self._units).magnitude)
self._newport_cmd("SR", target=self.axis_id, params=[limit])
@property
def error_threshold(self):
"""
Gets/sets the axis error threshold
:units: units
:type: `~quantities.Quantity` or `float`
"""
return assume_units(
float(self._newport_cmd("FE?", target=self.axis_id)), self._units)
@error_threshold.setter
def error_threshold(self, newval):
if newval is None:
return
newval = float(
assume_units(newval, self._units).rescale(self._units).magnitude)
self._newport_cmd("FE", target=self.axis_id, params=[newval])
@property
def current(self):
"""
Gets/sets the axis current (amps)
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport :math:`\\text{A}`
:type: `~quantities.Quantity` or `float`
"""
return assume_units(
float(self._newport_cmd("QI?", target=self.axis_id)), pq.A)
@current.setter
def current(self, newval):
if newval is None:
return
current = float(assume_units(newval, pq.A).rescale(pq.A).magnitude)
self._newport_cmd("QI", target=self.axis_id, params=[current])
@property
def voltage(self):
"""
Gets/sets the axis voltage
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport :math:`\\text{V}`
:type: `~quantities.Quantity` or `float`
"""
return assume_units(
float(self._newport_cmd("QV?", target=self.axis_id)), pq.V)
@voltage.setter
def voltage(self, newval):
if newval is None:
return
voltage = float(assume_units(newval, pq.V).rescale(pq.V).magnitude)
self._newport_cmd("QV", target=self.axis_id, params=[voltage])
@property
def motor_type(self):
"""
Gets/sets the axis motor type
* 0 = undefined
* 1 = DC Servo
* 2 = Stepper motor
* 3 = commutated stepper motor
* 4 = commutated brushless servo motor
:type: `int`
:rtype: `NewportESP301MotorType`
"""
return NewportESP301MotorType(
int(self._newport_cmd("QM?", target=self._axis_id)))
@motor_type.setter
def motor_type(self, newval):
if newval is None:
return
self._newport_cmd("QM", target=self._axis_id, params=[int(newval)])
@property
def feedback_configuration(self):
"""
Gets/sets the axis Feedback configuration
:type: `int`
"""
return int(self._newport_cmd("ZB?", target=self._axis_id)[:-2], 16)
@feedback_configuration.setter
def feedback_configuration(self, newval):
if newval is None:
return
self._newport_cmd("ZB", target=self._axis_id, params=[int(newval)])
@property
def position_display_resolution(self):
"""
Gets/sets the position display resolution
:type: `int`
"""
return int(self._newport_cmd("FP?", target=self._axis_id))
@position_display_resolution.setter
def position_display_resolution(self, newval):
if newval is None:
return
self._newport_cmd("FP", target=self._axis_id, params=[int(newval)])
@property
def trajectory(self):
"""
Gets/sets the axis trajectory
:type: `int`
"""
return int(self._newport_cmd("TJ?", target=self._axis_id))
@trajectory.setter
def trajectory(self, newval):
if newval is None:
return
self._newport_cmd("TJ", target=self._axis_id, params=[int(newval)])
@property
def microstep_factor(self):
"""
Gets/sets the axis microstep_factor
:type: `int`
"""
return int(self._newport_cmd("QS?", target=self._axis_id))
@microstep_factor.setter
def microstep_factor(self, newval):
if newval is None:
return
newval = int(newval)
if newval < 1 or newval > 250:
raise ValueError("Microstep factor must be between 1 and 250")
else:
self._newport_cmd("QS", target=self._axis_id, params=[newval])
@property
def hardware_limit_configuration(self):
"""
Gets/sets the axis hardware_limit_configuration
:type: `int`
"""
return int(self._newport_cmd("ZH?", target=self._axis_id)[:-2])
@hardware_limit_configuration.setter
def hardware_limit_configuration(self, newval):
if newval is None:
return
self._newport_cmd("ZH", target=self._axis_id, params=[int(newval)])
@property
def acceleration_feed_forward(self):
"""
Gets/sets the axis acceleration_feed_forward setting
:type: `int`
"""
return float(self._newport_cmd("AF?", target=self._axis_id))
@acceleration_feed_forward.setter
def acceleration_feed_forward(self, newval):
if newval is None:
return
self._newport_cmd("AF", target=self._axis_id, params=[float(newval)])
@property
def proportional_gain(self):
"""
Gets/sets the axis proportional_gain
:type: `float`
"""
return float(self._newport_cmd("KP?", target=self._axis_id)[:-1])
@proportional_gain.setter
def proportional_gain(self, newval):
if newval is None:
return
self._newport_cmd("KP", target=self._axis_id, params=[float(newval)])
@property
def derivative_gain(self):
"""
Gets/sets the axis derivative_gain
:type: `float`
"""
return float(self._newport_cmd("KD?", target=self._axis_id))
@derivative_gain.setter
def derivative_gain(self, newval):
if newval is None:
return
self._newport_cmd("KD", target=self._axis_id, params=[float(newval)])
@property
def integral_gain(self):
"""
Gets/sets the axis integral_gain
:type: `float`
"""
return float(self._newport_cmd("KI?", target=self._axis_id))
@integral_gain.setter
def integral_gain(self, newval):
if newval is None:
return
self._newport_cmd("KI", target=self._axis_id, params=[float(newval)])
@property
def integral_saturation_gain(self):
"""
Gets/sets the axis integral_saturation_gain
:type: `float`
"""
return float(self._newport_cmd("KS?", target=self._axis_id))
@integral_saturation_gain.setter
def integral_saturation_gain(self, newval):
if newval is None:
return
self._newport_cmd("KS", target=self._axis_id, params=[float(newval)])
@property
def encoder_position(self):
"""
Gets the encoder position
:type:
"""
with self._units_of(NewportESP301Units.encoder_step):
return self.position
# MOVEMENT METHODS #
def search_for_home(
self,
search_mode=NewportESP301HomeSearchMode.zero_position_count.value):
"""
Searches this axis only
for home using the method specified by ``search_mode``.
:param NewportESP301HomeSearchMode search_mode: Method to detect when
Home has been found.
"""
self._controller.search_for_home(axis=self.axis_id,
search_mode=search_mode)
def move(self, position, absolute=True, wait=False, block=False):
"""
:param position: Position to set move to along this axis.
:type position: `float` or :class:`~quantities.Quantity`
:param bool absolute: If `True`, the position ``pos`` is
interpreted as relative to the zero-point of the encoder.
If `False`, ``pos`` is interpreted as relative to the current
position of this axis.
:param bool wait: If True, will tell axis to not execute other
commands until movement is finished
:param bool block: If True, will block code until movement is finished
"""
position = float(
assume_units(position, self._units).rescale(self._units).magnitude)
if absolute:
self._newport_cmd("PA", params=[position], target=self.axis_id)
else:
self._newport_cmd("PR", params=[position], target=self.axis_id)
if wait:
self.wait_for_position(position)
if block:
sleep(0.003)
mot = self.is_motion_done
while not mot:
mot = self.is_motion_done
def move_to_hardware_limit(self):
"""
move to hardware travel limit
"""
self._newport_cmd("MT", target=self.axis_id)
def move_indefinitely(self):
"""
Move until told to stop
"""
self._newport_cmd("MV", target=self.axis_id)
def abort_motion(self):
"""
Abort motion
"""
self._newport_cmd("AB", target=self.axis_id)
def wait_for_stop(self):
"""
Waits for axis motion to stop before next command is executed
"""
self._newport_cmd("WS", target=self.axis_id)
def stop_motion(self):
"""
Stop all motion on axis. With programmed deceleration rate
"""
try:
self._newport_cmd("ST", target=self.axis_id)
except NewportError as e:
raise NewportError(e)
def wait_for_position(self, position):
"""
Wait for axis to reach position before executing next command
:param position: Position to wait for on axis
:type position: float or :class:`~quantities.Quantity`
"""
position = float(
assume_units(position, self._units).rescale(self._units).magnitude)
self._newport_cmd("WP", target=self.axis_id, params=[position])
def wait_for_motion(self, poll_interval=0.01, max_wait=None):
"""
Blocks until all movement along this axis is complete, as reported
by `~NewportESP301Axis.is_motion_done`.
:param float poll_interval: How long (in seconds) to sleep between
checking if the motion is complete.
:param float max_wait: Maximum amount of time to wait before
raising a `IOError`. If `None`, this method will wait
indefinitely.
"""
# FIXME: make sure that the controller is not in
# programming mode, or else this might not work.
# In programming mode, the "WS" command should be
# sent instead, and the two parameters to this method should
# be ignored.
poll_interval = float(
assume_units(poll_interval, pq.s).rescale(pq.s).magnitude)
max_wait = float(assume_units(max_wait, pq.s).rescale(pq.s).magnitude)
tic = time()
while True:
if self.is_motion_done:
return
else:
if max_wait is None or (time() - tic) < max_wait:
sleep(poll_interval)
else:
raise IOError("Timed out waiting for motion to finish.")
def enable(self):
"""
Turns motor axis on.
"""
self._newport_cmd("MO", target=self._axis_id)
def disable(self):
"""
Turns motor axis off.
"""
self._newport_cmd("MF", target=self._axis_id)
def setup_axis(self, **kwargs):
"""
Setup a non-newport DC servo motor stage. Necessary parameters are.
* 'motor_type' = type of motor see 'QM' in Newport documentation
* 'current' = motor maximum current (A)
* 'voltage' = motor voltage (V)
* 'units' = set units (see NewportESP301Units)(U)
* 'encoder_resolution' = value of encoder step in terms of (U)
* 'max_velocity' = maximum velocity (U/s)
* 'max_base_velocity' = maximum working velocity (U/s)
* 'homing_velocity' = homing speed (U/s)
* 'jog_high_velocity' = jog high speed (U/s)
* 'jog_low_velocity' = jog low speed (U/s)
* 'max_acceleration' = maximum acceleration (U/s^2)
* 'acceleration' = acceleration (U/s^2)
* 'deceleration' = set deceleration (U/s^2)
* 'error_threshold' = set error threshold (U)
* 'proportional_gain' = PID proportional gain (optional)
* 'derivative_gain' = PID derivative gain (optional)
* 'interal_gain' = PID internal gain (optional)
* 'integral_saturation_gain' = PID integral saturation (optional)
* 'trajectory' = trajectory mode (optional)
* 'position_display_resolution' (U per step)
* 'feedback_configuration'
* 'full_step_resolution' = (U per step)
* 'home' = (U)
* 'acceleration_feed_forward' = bewtween 0 to 2e9
* 'reduce_motor_torque' = (time(ms),percentage)
"""
self.motor_type = kwargs.get('motor_type')
self.feedback_configuration = kwargs.get('feedback_configuration')
self.full_step_resolution = kwargs.get('full_step_resolution')
self.position_display_resolution = kwargs.get('position_display_'
'resolution')
self.current = kwargs.get('current')
self.voltage = kwargs.get('voltage')
self.units = int(kwargs.get('units'))
self.encoder_resolution = kwargs.get('encoder_resolution')
self.max_acceleration = kwargs.get('max_acceleration')
self.max_velocity = kwargs.get('max_velocity')
self.max_base_velocity = kwargs.get('max_base_velocity')
self.homing_velocity = kwargs.get('homing_velocity')
self.jog_high_velocity = kwargs.get('jog_high_velocity')
self.jog_low_velocity = kwargs.get('jog_low_velocity')
self.acceleration = kwargs.get('acceleration')
self.velocity = kwargs.get('velocity')
self.deceleration = kwargs.get('deceleration')
self.estop_deceleration = kwargs.get('estop_deceleration')
self.jerk = kwargs.get('jerk')
self.error_threshold = kwargs.get('error_threshold')
self.proportional_gain = kwargs.get('proportional_gain')
self.derivative_gain = kwargs.get('derivative_gain')
self.integral_gain = kwargs.get('integral_gain')
self.integral_saturation_gain = kwargs.get('integral_saturation_gain')
self.home = kwargs.get('home')
self.microstep_factor = kwargs.get('microstep_factor')
self.acceleration_feed_forward = kwargs.get(
'acceleration_feed_forward')
self.trajectory = kwargs.get('trajectory')
self.hardware_limit_configuration = kwargs.get('hardware_limit_'
'configuration')
if 'reduce_motor_torque_time' in kwargs and 'reduce_motor_torque_percentage' in kwargs:
motor_time = kwargs['reduce_motor_torque_time']
motor_time = int(
assume_units(motor_time, pq.ms).rescale(pq.ms).magnitude)
if motor_time < 0 or motor_time > 60000:
raise ValueError("Time must be between 0 and 60000 ms")
percentage = kwargs['reduce_motor_torque_percentage']
percentage = int(
assume_units(percentage,
pq.percent).rescale(pq.percent).magnitude)
if percentage < 0 or percentage > 100:
raise ValueError("Time must be between 0 and 60000 ms")
self._newport_cmd("QR",
target=self._axis_id,
params=[motor_time, percentage])
# update motor configuration
self._newport_cmd("UF", target=self._axis_id)
self._newport_cmd("QD", target=self._axis_id)
# save configuration
self._newport_cmd("SM")
return self.read_setup()
def read_setup(self):
"""
Returns dictionary containing:
'units'
'motor_type'
'feedback_configuration'
'full_step_resolution'
'position_display_resolution'
'current'
'max_velocity'
'encoder_resolution'
'acceleration'
'deceleration'
'velocity'
'max_acceleration'
'homing_velocity'
'jog_high_velocity'
'jog_low_velocity'
'estop_deceleration'
'jerk'
'proportional_gain'
'derivative_gain'
'integral_gain'
'integral_saturation_gain'
'home'
'microstep_factor'
'acceleration_feed_forward'
'trajectory'
'hardware_limit_configuration'
:rtype: dict of `quantities.Quantity`, float and int
"""
config = dict()
config['units'] = self.units
config['motor_type'] = self.motor_type
config['feedback_configuration'] = self.feedback_configuration
config['full_step_resolution'] = self.full_step_resolution
config[
'position_display_resolution'] = self.position_display_resolution
config['current'] = self.current
config['max_velocity'] = self.max_velocity
config['encoder_resolution'] = self.encoder_resolution
config['acceleration'] = self.acceleration
config['deceleration'] = self.deceleration
config['velocity'] = self.velocity
config['max_acceleration'] = self.max_acceleration
config['homing_velocity'] = self.homing_velocity
config['jog_high_velocity'] = self.jog_high_velocity
config['jog_low_velocity'] = self.jog_low_velocity
config['estop_deceleration'] = self.estop_deceleration
config['jerk'] = self.jerk
# config['error_threshold'] = self.error_threshold
config['proportional_gain'] = self.proportional_gain
config['derivative_gain'] = self.derivative_gain
config['integral_gain'] = self.integral_gain
config['integral_saturation_gain'] = self.integral_saturation_gain
config['home'] = self.home
config['microstep_factor'] = self.microstep_factor
config['acceleration_feed_forward'] = self.acceleration_feed_forward
config['trajectory'] = self.trajectory
config[
'hardware_limit_configuration'] = self.hardware_limit_configuration
return config
def get_status(self):
"""
Returns Dictionary containing values:
'units'
'position'
'desired_position'
'desired_velocity'
'is_motion_done'
:rtype: dict
"""
status = dict()
status['units'] = self.units
status['position'] = self.position
status['desired_position'] = self.desired_position
status['desired_velocity'] = self.desired_velocity
status['is_motion_done'] = self.is_motion_done
return status
@staticmethod
def _get_pq_unit(num):
"""
Gets the units for the specified axis.
:units: The units for the attached axis
:type num: int
"""
return NewportESP301Axis._unit_dict[num]
def _get_unit_num(self, quantity):
"""
Gets the integer label used by the Newport ESP 301 corresponding to a
given `~quantities.Quantity`.
:param quantities.Quantity quantity: Units to return a label for.
:return int:
"""
for num, quant in self._unit_dict.items():
if quant == quantity:
return num
raise KeyError(
"{0} is not a valid unit for Newport Axis".format(quantity))
# pylint: disable=protected-access
def _newport_cmd(self, cmd, **kwargs):
"""
Passes the newport command from the axis class to the parent controller
:param cmd:
:param kwargs:
:return:
"""
return self._controller._newport_cmd(cmd, **kwargs)
# 3. CHILLED WATER
# 3. 1. Measured Chilled water
df['measured_chilled_water_AH2'] = df['measured_chw']
#m_chwp = np.zeros((N,2))
#m_chwp_cost = np.empty((N,2))
#chwt = np.array(power_cost['measured_chw']['Readings'])
#
#m_chwp[:,0] = chwt[:,0]
#m_chwp[:,1] = chwt[:,1] * 3.517 / chw_eff
#m_chwp_cost[:,0] = chwt[:,0]
#m_chwp_cost[:,1] = np.array([m_chwp[i,1] * elec_price[i,1] \
# for i in range(N)])
# 3. 2. Calculate chilled water cost
cfm = pq.UnitQuantity('cfm', pq.foot**3/pq.minute, symbol='cfm')
df['chilled_water_AH2'] = np.nan
df['hot_water_AH2'] = np.nan
df['total_zone_load_AH2'] = np.nan
df['total_VAV_box_airflow'] = np.nan
#for rh_name in rh_coils:
# df_zone['coil_closed_temp_change_' + rh_name] = np.nan
# df_zone['hot_water_' +rh_name] = np.nan
# df_zone['instantaneous_zone_load_' + rh_name] = np.nan
for i in range(9, df.shape[0]):
chw_AH2 = 0.0 * pq.W
all_sats = []*pq.F
for coil_name in chw_coils:
mat = np.array(df[str(coil_name) + '_MAT'][i-9:i+1]) * pq.F
sat = np.array(df[str(coil_name) + '_SAT'][i-9:i+1]) * pq.F
###############################
""" Physical quantities.
Holds things related to physical quantities, eg atomic units using the
*quantities* package.
"""
__docformat__ = "restructuredtext en"
__all__ = [
'a0', 'bohr_radius', 'h', 'planck', 'h_bar', 'reduced_planck',
'electronic_mass', 'Ry', 'rydberg', 'Kb', 'boltzmann'
]
import quantities as pq
h = pq.UnitQuantity("planck", 4.1356673310e-15 * pq.eV * pq.s)
""" Planck's constant. """
planck = h
""" Planck's constant. """
h_bar = pq.UnitQuantity("h_bar", h / 2e0 / pq.pi, symbol='h_bar')
""" Reduced Planck's constant. """
reduced_plank = h_bar
""" Reduced Planck's constant. """
Ry = pq.UnitQuantity('Rydberg', 0.5 * pq.hartree, symbol='Ry')
""" Rydberg energy units. """
rydberg = Ry
""" Rydberg energy units. """
a0 = pq.UnitQuantity('bohr_radius', 0.529177249 * pq.angstrom, symbol='a0')
""" Bohr radius, unit of length of atomic units. """
# constants
YEAR = 2013 * pq.year
_DIRNAME = os.path.dirname(__file__)
_DATA = os.path.join(_DIRNAME, '..', 'data')
_FORMULAS = os.path.join(_DIRNAME, '..', 'formulas')
_CALCS = os.path.join(_DIRNAME, '..', 'calcs')
_MODELS = os.path.join(_DIRNAME, '..', 'models')
_OUTPUTS = os.path.join(_DIRNAME, '..', 'outputs')
_SIMULATIONS = os.path.join(_DIRNAME, '..', 'simulations')
# add extra units to registry
UREG = pq.unit_registry # registry of units
LUMEN = pq.UnitLuminousIntensity('lumen', pq.cd * pq.sr, 'lm',
aliases=['lumens'])
LUX = pq.UnitLuminousIntensity('lux', LUMEN / pq.m ** 2, 'lx')
MB = pq.UnitQuantity('millibar', pq.milli * pq.bar, 'mB',
aliases=['mBar', 'mb', 'mbar', 'millibars'])
FA = pq.UnitQuantity('femtoampere', pq.femto * pq.ampere, 'fA',
aliases=['femtoamp', 'femtoAmp', 'femtoamps', 'femtoAmps',
'femtoamperes', 'femtoAmpere', 'femtoAmperes',
'fAmp', 'fAmps'])
def _listify(x):
"""
If x is not a list, make it a list.
"""
return list(x) if isinstance(x, (list, tuple)) else [x]
class Registry(dict):
"""
def calculate_score(self, simulation_result, score_instance):
model_class = general_hlp.import_class(
score_instance.model_instance.model_class.import_path)
model_url = score_instance.model_instance.url
model_name = os.path.basename(model_url)
model_path = os.path.join(settings.DOWNLOADED_MODEL_DIR, model_name)
model_hlp.download_and_save_model(model_path, model_url)
model_instance = model_class(model_path,
name=score_instance.model_instance.name,
backend=ScidashCacheBackend.name)
model_instance.set_memory_cache(simulation_result)
test_class = general_hlp.import_class(
score_instance.test_instance.test_class.import_path)
observation = copy.deepcopy(score_instance.test_instance.observation)
params = copy.deepcopy(score_instance.test_instance.params)
try:
destructured = json.loads(
score_instance.test_instance.test_class.units)
except json.JSONDecodeError:
units = general_hlp.import_class(
score_instance.test_instance.test_class.units)
else:
if destructured.get('name', False):
base_unit = general_hlp.import_class(
destructured.get('base').get('quantity'))
units = pq.UnitQuantity(
destructured.get('name'),
base_unit * destructured.get('base').get('coefficient'),
destructured.get('symbol'))
else:
units = destructured
for key in observation:
if not isinstance(units, dict):
observation[key] = int(
observation[key]) * units if key != 'n' else int(
observation[key])
else:
observation[key] = int(
observation[key]) * units[key] if key != 'n' else int(
observation[key])
params_units = score_instance.test_instance.test_class.params_units
for key in params_units:
params_units[key] = general_hlp.import_class(params_units[key])
processed_params = {}
for key in params:
if params[key] is not None:
processed_params[key] = float(params[key]) * params_units[key]
test_instance = test_class(observation=observation, **processed_params)
score = test_instance.judge(model_instance).json(add_props=True,
string=False)
self.update_score(score_instance, score)
return score
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------
import quantities as pq
# Conductances:
mS = pq.UnitQuantity('milli-Siemen', pq.milli * pq.siemens, symbol='mS')
uS = pq.UnitQuantity('micro-Siemen', pq.micro * pq.siemens, symbol='uS')
nS = pq.UnitQuantity('nano-Siemen', pq.nano * pq.siemens, symbol='nS')
pS = pq.UnitQuantity('pico-Siemen', pq.pico * pq.siemens, symbol='pS')
# Capacitances:
mF = pq.UnitQuantity('millifarad', pq.milli * pq.farad, symbol='mF')
uF = pq.UnitQuantity('microfarad', pq.micro * pq.farad, symbol='uF')
nF = pq.UnitQuantity('nanofarad', pq.nano * pq.farad, symbol='nF')
pF = pq.UnitQuantity('picofarad', pq.pico * pq.farad, symbol='pF')
# Areas:
um2 = pq.UnitQuantity('micrometer-squared', pq.um ** 2, symbol='um2')
cm2 = pq.UnitQuantity('centimeter-squared', pq.cm ** 2, symbol='cm2')
mm2 = pq.UnitQuantity('micrometer-squared', pq.mm ** 2, symbol='mm2')
m2 = pq.UnitQuantity('meter-squared', pq.m ** 2, symbol='m2')
import cython
import numpy as np
import quantities as pq
import rmgpy.constants as constants
from rmgpy.exceptions import QuantityError
from rmgpy.rmgobject import RMGObject, expand_to_dict
################################################################################
# Explicitly set the default units to SI
pq.set_default_units('si')
# These units are not defined by the quantities package, but occur frequently
# in data handled by RMG, so we define them manually
pq.UnitQuantity('kilocalories', pq.cal * 1e3, symbol='kcal')
pq.UnitQuantity('kilojoules', pq.J * 1e3, symbol='kJ')
pq.UnitQuantity('kilomoles', pq.mol * 1e3, symbol='kmol')
pq.UnitQuantity('molecule', pq.mol / 6.02214179e23, symbol='molecule')
pq.UnitQuantity('molecules', pq.mol / 6.02214179e23, symbol='molecules')
pq.UnitQuantity('debye', 1.0 / (constants.c * 1e21) * pq.C * pq.m, symbol='De')
################################################################################
# Units that should not be used in RMG-Py:
NOT_IMPLEMENTED_UNITS = ['degC', 'C', 'degF', 'F', 'degR', 'R']
################################################################################
class Units(RMGObject):
class NewportESP301Axis(object):
"""
Encapsulates communication concerning a single axis
of an ESP-301 controller. This class should not be
instantiated by the user directly, but is
returned by `NewportESP301.axis`.
"""
# quantities micro inch
micro_inch = pq.UnitQuantity('micro-inch',pq.inch/1e6, symbol = 'uin')
# Some more work might need to be done here to make
# the encoder_step and motor_step functional
# I really don't have a concrete idea how I'm
# going to do this until I have a physical device
_unit_dict = {
0 : pq.count,
1 : pq.count,
2 : pq.mm,
3 : pq.um,
4 : pq.inch,
5 : pq.mil,
6 : micro_inch, #compound unit for micro-inch
7 : pq.deg,
8 : pq.grad,
9 : pq.rad,
10 : pq.mrad,
11 : pq.urad,
}
def __init__(self, controller, axis_id):
if not isinstance(controller, NewportESP301):
raise TypeError("Axis must be controlled by a Newport ESP-301 motor controller.")
# TODO: check axis_id
self._controller = controller
self._axis_id = axis_id
self._units = self.units
## CONTEXT MANAGERS ##
@contextmanager
def _units_of(self, units):
"""
Sets the units for the corresponding axis to a those given by an integer
label (see `NewportESP301Units`), ensuring that the units are properly
reset at the completion of the context manager.
"""
old_units = self._get_units()
self._set_units(units)
yield
self._set_units(old_units)
## PRIVATE METHODS ##
def _get_units(self):
"""
Returns the integer label for the current units set for this axis.
.. seealso::
NewportESP301Units
"""
return NewportESP301Units(
self._controller._newport_cmd("SN?", target=self.axis_id)
)
def _set_units(self, new_units):
return self._controller._newport_cmd(
"SN", target=self.axis_id,
params=[int(new_units)]
)
## PROPERTIES ##
@property
def axis_id(self):
"""
Get axis number of Newport Controller
:type: `int`
"""
return self._axis_id
@property
def is_motion_done(self):
"""
`True` if and only if all motion commands have
completed. This method can be used to wait for
a motion command to complete before sending the next
command.
:type: `bool`
"""
return bool(int(self._controller._newport_cmd("MD?", target=self.axis_id)))
@property
def acceleration(self):
"""
Get acceleration
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport unit
:param accel: Sets acceleration
:type accel: `~quantities.Quantity` or `float`
"""
return assume_units(float(self._controller._newport_cmd("AC?", target=self.axis_id)),
self._units/(pq.s**2))
@acceleration.setter
def acceleration(self,accel):
accel = float(assume_units(accel,self._units/(pq.s**2)).rescale(
self._units/(pq.s**2)).magnitude)
return self._controller._newport_cmd("AC",target=self.axis_id,params=[accel])
@property
def deceleration(self):
"""
Gets deceleration
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport :math:`\\frac{unit}{s^2}`
:param decel: Sets deceleration
:type decel: `~quantities.Quantity` or float
"""
return assume_units(float(self._controller._newport_cmd("AG?", target=self.axis_id)),
self._units/(pq.s**2))
@deceleration.setter
def deceleration(self,decel):
decel = float(assume_units(decel,self._units/(pq.s**2)).rescale(
self._units/(pq.s**2)).magnitude)
return self._controller._newport_cmd("AG",target=self.axis_id,params=[decel])
@property
def estop_deceleration(self):
"""
Gets estop_deceleration
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport :math:`\\frac{unit}{s^2}`
:param decel: Sets deceleration
:type decel: `~quantities.Quantity` or float
"""
return assume_units(float(self._controller._newport_cmd("AE?", target=self.axis_id)),
self._units/(pq.s**2))
@estop_deceleration.setter
def estop_deceleration(self,decel):
decel = float(assume_units(decel,self._units/(pq.s**2)).rescale(
self._units/(pq.s**2)).magnitude)
return self._controller._newport_cmd("AE",target=self.axis_id,params=[decel])
@property
def jerk(self):
"""
Gets and sets the jerk rate for the controller
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport unit
:param accel: Sets acceleration
:type accel: `~quantities.Quantity` or `float`
"""
return assume_units(float(self._controller._newport_cmd("JK?", target=self.axis_id)),
self._units/(pq.s**3))
@jerk.setter
def jerk(self,jerk):
jerk = float(assume_units(jerk,self._units/(pq.s**3)).rescale(
self._units/(pq.s**3)).magnitude)
return self._controller._newport_cmd("JK",target=self.axis_id,params=[jerk])
@property
def velocity(self):
"""
Gets velocity
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport :math:`\\frac{unit}{s}`
:param velocity: Sets velocity
:type velocity: `~quantities.Quantity` or `float`
"""
return assume_units(float(self._controller._newport_cmd("VA?", target=self.axis_id)),
self._units/(pq.s))
@velocity.setter
def velocity(self,velocity):
velocity = float(assume_units(velocity,self._units/(pq.s)).rescale(
self._units/(pq.s)).magnitude)
return self._controller._newport_cmd("VA",target=self.axis_id,params=[velocity])
@property
def max_velocity(self):
"""
Get the maximum velocity
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport :math:`\\frac{unit}{s}`
:param velocity: Sets the maximum velocity
:type velocity: `~quantities.Quantity` or `float`
"""
return assume_units(float(self._controller._newport_cmd("VU?", target=self.axis_id)),
self._units/pq.s)
@max_velocity.setter
def max_velocity(self,velocity):
velocity = float(assume_units(velocity,self._units/(pq.s)).rescale(
self._units/(pq.s)).magnitude)
return self._controller._newport_cmd("VU", target=self.axis_id,params=[velocity])
@property
def max_base_velocity(self):
"""
Get the maximum base velocity for stepper motors
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport :math:`\\frac{unit}{s}`
:param velocity: Sets the maximum velocity
:type velocity: `~quantities.Quantity` or `float`
"""
return assume_units(float(self._controller._newport_cmd("VB?", target=self.axis_id)),
self._units/pq.s)
@max_base_velocity.setter
def max_base_velocity(self,velocity):
velocity = float(assume_units(velocity,self._units/(pq.s)).rescale(
self._units/(pq.s)).magnitude)
return self._controller._newport_cmd("VB", target=self.axis_id,params=[velocity])
@property
def jog_high_velocity(self):
"""
Gets and sets jog high velocity
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport :math:`\\frac{unit}{s}`
:param jog_high_velocity: Sets velocity
:type jog_high_velocity: `~quantities.Quantity` or `float`
"""
return assume_units(float(self._controller._newport_cmd("JH?", target=self.axis_id)),
self._units/(pq.s))
@jog_high_velocity.setter
def jog_high_velocity(self,jog_high_velocity):
jog_high_velocity = float(assume_units(jog_high_velocity,self._units/(pq.s)).rescale(
self._units/(pq.s)).magnitude)
return self._controller._newport_cmd("JH",target=self.axis_id,params=[jog_high_velocity])
@property
def jog_low_velocity(self):
"""
Gets and sets jog low velocity
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport :math:`\\frac{unit}{s}`
:param jog_low_velocity: Sets velocity
:type jog_low_velocity: `~quantities.Quantity` or `float`
"""
return assume_units(float(self._controller._newport_cmd("JW?", target=self.axis_id)),
self._units/(pq.s))
@jog_low_velocity.setter
def jog_low_velocity(self,jog_low_velocity):
jog_low_velocity = float(assume_units(jog_low_velocity,self._units/(pq.s)).rescale(
self._units/(pq.s)).magnitude)
return self._controller._newport_cmd("JW",target=self.axis_id,params=[jog_low_velocity])
@property
def homing_velocity(self):
"""
Gets and sets the homing velocity
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport :math:`\\frac{unit}{s}`
:param homing_velocity: Sets velocity
:type homing_velocity: `~quantities.Quantity` or `float`
"""
return assume_units(float(self._controller._newport_cmd("OH?", target=self.axis_id)),
self._units/(pq.s))
@homing_velocity.setter
def homing_velocity(self,homing_velocity):
homing_velocity = float(assume_units(homing_velocity,self._units/(pq.s)).rescale(
self._units/(pq.s)).magnitude)
return self._controller._newport_cmd("OH",target=self.axis_id,params=[homing_velocity])
@property
def max_acceleration(self):
"""
Get max acceleration
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport :math:`\\frac{unit}{s^2}`
:param accel: Sets the maximum acceleration
:type accel: `~quantities.Quantity` or `float`
"""
return assume_units(float(self._controller._newport_cmd("AU?", target=self.axis_id)),
self._units/(pq.s**2))
@max_acceleration.setter
def max_acceleration(self,accel):
accel = float(assume_units(accel,self._units/(pq.s**2)).rescale(
self._units/(pq.s**2)).magnitude)
return self._controller._newport_cmd("AU",target=self.axis_id,params=[accel])
# Max deacceleration is always the same as accelleration
@property
def max_deceleration(self):
"""
Get max deceleration
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport :math:`\\frac{unit}{s^2}`
:param decel: Sets maximum deceleration
:type: `~quantities.Quantity` or `float`
"""
return self.max_acceleration
@max_deceleration.setter
def max_deacceleration(self,decel):
decel = float(assume_units(decel,self._units/(pq.s**2)).rescale(
self._units/(pq.s**2)).magnitude)
return self.max_acceleration(decel)
@property
def position(self):
"""
Gets real position on axis in units
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport unit
:type: `~quantities.Quantity` or `float`
"""
return assume_units(float(self._controller._newport_cmd("TP?", target=self.axis_id)),
self._units)
@property
def desired_position(self):
"""
Gets desired position on axis in units
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport unit
:type: `~quantities.Quantity` or `float`
"""
return assume_units(float(self._controller._newport_cmd("DP?", target=self.axis_id)),
self._units)
@property
def desired_velocity(self):
"""
Gets desired velocity on axis in unit/s
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport unit/s
:type: `~quantities.Quantity` or `float`
"""
return assume_units(float(self._controller._newport_cmd("DP?", target=self.axis_id)),
self._units/pq.s)
@property
def home(self):
"""
Get home position
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of current newport unit
:param home: Sets home position of axis
:type home: `~quantities.Quantity` or `float`
"""
return assume_units(float(self._controller._newport_cmd("DH?", target=self.axis_id)),
self._units)
#default should be 0 as that sets current position as home
@home.setter
def home(self, home=0):
home = float(assume_units(home,self._units).rescale(
self._units).magnitude)
return self._controller._newport_cmd("DH", target=self.axis_id, params=[home])
@property
def units(self):
"""
Get the units that all commands are in reference to.
:param unit: Set the reference unit for axis
:type unit: `~quantities.Quantity` with units corresponding to
units of axis connected or int which corresponds to Newport
unit number
:rtype: `~quantities.Quantity`
"""
self._units = self.get_pq_unit(self._get_units())
return self._units
@units.setter
def units(self,unit):
if isinstance(unit, int):
self._units = self.get_pq_unit(NewportESP301Units(int(unit)))
elif isinstance(unit,pq.Quantity):
self._units = unit
unit = self.get_unit_num(unit)
return self._set_units(unit)
@property
def encoder_resolution(self):
"""
Get the resolution of the encode. The minimum number of units per step.
Encoder functionality must be enabled
:units: The number of units per encoder step
:param resolution: Sets the encoder resolution of axis
:type resolution: `~quantities.Quantity` or `float`
"""
return assume_units(float(self._controller._newport_cmd("SU?",target=self.axis_id)),
self._units)
@encoder_resolution.setter
def encoder_resolution(self, resolution):
resolution = float(assume_units(resolution,self._units).rescale(
self._units).magnitude)
return self._controller._newport_cmd("SU",target=self.axis_id,params=[resolution])
@property
def full_step_resolution(self):
"""
Get the resolution of the encode. The minimum number of units per step.
Encoder functionality must be enabled
:units: The number of units per encoder step
:param full_step_resolution: Sets the encoder resolution of axis
:type full_step_resolution: `~quantities.Quantity` or `float`
"""
return assume_units(float(self._controller._newport_cmd("FR?",target=self.axis_id)),
self._units)
@full_step_resolution.setter
def full_step_resolution(self, full_step_resolution):
full_step_resolution = float(assume_units(full_step_resolution,self._units).rescale(
self._units).magnitude)
return self._controller._newport_cmd("FR",target=self.axis_id,params=[full_step_resolution])
@property
def left_limit(self):
"""
Get the left travel limit
:units: The limit in units
:param limit: Set the travel limit
:type: `~quantities.Quantity` or `float`
"""
return assume_units(float(self._controller._newport_cmd("SL?",target=self.axis_id)),
self._units)
@left_limit.setter
def left_limit(self, limit):
limit = float(assume_units(limit,self._units).rescale(
self._units).magnitude)
return self._controller._newport_cmd("SL",target=self.axis_id,params=[limit])
@property
def right_limit(self):
"""
Get the right travel limit
:units: units
:param limit: Set the travel limit
:type: `~quantities.Quantity` or `float`
"""
return assume_units(float(self._controller._newport_cmd("SR?",target=self.axis_id)),
self._units)
@right_limit.setter
def right_limit(self, limit):
limit = float(assume_units(limit,self._units).rescale(
self._units).magnitude)
return self._controller._newport_cmd("SR",target=self.axis_id,params=[limit])
@property
def error_threshold(self):
"""
Get and set the error threshold
:units: units
:param error_threshold: Set the travel limit
:type: `~quantities.Quantity` or `float`
"""
return assume_units(float(self._controller._newport_cmd("FE?",target=self.axis_id)),
self._units)
@error_threshold.setter
def error_threshold(self, error_threshold):
error_threshold = float(assume_units(error_threshold,self._units).rescale(
self._units).magnitude)
return self._controller._newport_cmd("FE",target=self.axis_id,params=[error_threshold])
@property
def current(self):
"""
Get and set the current
:units: A
:param current: Set the current
:type: `~quantities.Quantity` or `float`
"""
return assume_units(float(self._controller._newport_cmd("QI?",target=self.axis_id)),
pq.A)
@current.setter
def current(self, current):
current = float(assume_units(current,pq.A).rescale(
pq.A).magnitude)
return self._controller._newport_cmd("QI",target=self.axis_id,params=[current])
@property
def voltage(self):
"""
Get and set the current
:units: A
:param voltage: Set the voltage
:type: `~quantities.Quantity` or `float`
"""
return assume_units(float(self._controller._newport_cmd("QV?",target=self.axis_id)),
self.V)
@voltage.setter
def voltage(self, voltage):
voltage = float(assume_units(voltage,pq.V).rescale(
pq.V).magnitude)
return self._controller._newport_cmd("QV",target=self.axis_id,params=[voltage])
@property
def motor_type(self):
"""
Get and set the motor type
* 0 = undefined
* 1 = DC Servo
* 2 = Stepper motor
* 3 = commutated stepper motor
* 4 = commutated brushless servo motor
:param int motor_type: Type of motor
"""
return NewportESP301MotorType( int(self._controller._newport_cmd("QM?",target=self._axis_id)) )
@motor_type.setter
def motor_type(self, motor_type):
self._controller._newport_cmd("QM",target=self._axis_id,params=[int(motor_type)])
@property
def feedback_configuration(self):
"""
Get and set Feedback configuration
:param int feedback_configuration:
"""
return int(self._controller._newport_cmd("ZB?",target=self._axis_id)[:-2],16)
@feedback_configuration.setter
def feedback_configuration(self, feedback_configuration):
self._controller._newport_cmd("ZB",target=self._axis_id,params=[int(feedback_configuration)])
@property
def position_display_resolution(self):
"""
Get and set the position display resolution
:param int position_display_resolution:
"""
return int(self._controller._newport_cmd("FP?",target=self._axis_id))
@position_display_resolution.setter
def position_display_resolution(self, position_display_resolution):
self._controller._newport_cmd("FP",target=self._axis_id,params=[int(position_display_resolution)])
@property
def trajectory(self):
"""
Get and set the trajectory
:param int trajectory:
"""
return int(self._controller._newport_cmd("TJ?",target=self._axis_id))
@trajectory.setter
def trajectory(self, trajectory):
self._controller._newport_cmd("TJ",target=self._axis_id,params=[int(trajectory)])
@property
def microstep_factor(self):
"""
Get and set the microstep_factor
:param int microstep_factor:
"""
return int(self._controller._newport_cmd("QS?",target=self._axis_id))
@microstep_factor.setter
def microstep_factor(self, microstep_factor):
factor = int(microstep_factor)
if factor >= 1 and factor <= 250 :
self._controller._newport_cmd("QS",target=self._axis_id,params=[factor])
else:
raise ValueError("Microstep factor must be between 1 and 250")
@property
def hardware_limit_configuration(self):
"""
Get and set the hardware_limit_configuration
:param int hardware_limit_configuration:
"""
return int(self._controller._newport_cmd("ZH?",target=self._axis_id)[:-2])
@hardware_limit_configuration.setter
def hardware_limit_configuration(self, hardware_limit_configuration):
self._controller._newport_cmd("ZH",target=self._axis_id,params=[int(hardware_limit_configuration)])
@property
def acceleration_feed_forward(self):
"""
Get and set the acceleration_feed_forward
:param int acceleration_feed_forward:
"""
return float(self._controller._newport_cmd("AF?",target=self._axis_id))
@acceleration_feed_forward.setter
def acceleration_feed_forward(self, acceleration_feed_forward):
self._controller._newport_cmd("AF",target=self._axis_id,params=[float(acceleration_feed_forward)])
@property
def proportional_gain(self):
"""
Get and set the proportional_gain
:param float proportional_gain:
"""
return float(self._controller._newport_cmd("KP?",target=self._axis_id)[:-1])
@proportional_gain.setter
def proportional_gain(self, proportional_gain):
self._controller._newport_cmd("KP",target=self._axis_id,params=[float(proportional_gain)])
@property
def derivative_gain(self):
"""
Get and set the derivative_gain
:param float derivative_gain:
"""
return float(self._controller._newport_cmd("KD?",target=self._axis_id))
@derivative_gain.setter
def derivative_gain(self, derivative_gain):
self._controller._newport_cmd("KD",target=self._axis_id,params=[float(derivative_gain)])
@property
def integral_gain(self):
"""
Get and set the integral_gain
:param float integral_gain:
"""
return float(self._controller._newport_cmd("KI?",target=self._axis_id))
@integral_gain.setter
def integral_gain(self, integral_gain):
self._controller._newport_cmd("KI",target=self._axis_id,params=[float(integral_gain)])
@property
def integral_saturation_gain(self):
"""
Get and set the integral_saturation_gain
:param float integral_saturation_gain:
"""
return float(self._controller._newport_cmd("KS?",target=self._axis_id))
@integral_saturation_gain.setter
def integral_saturation_gain(self,integral_saturation_gain):
self._controller._newport_cmd("KS",target=self._axis_id,params=[float(integral_saturation_gain)])
@property
def encoder_position(self):
with self._units_of(NewportESP301Units.encoder_step):
return self.position
## MOVEMENT METHODS ##
def search_for_home(self,
search_mode=NewportESP301HomeSearchMode.zero_position_count.value
):
"""
Searches this axis only
for home using the method specified by ``search_mode``.
:param NewportESP301HomeSearchMode search_mode: Method to detect when
Home has been found.
"""
self._controller._home(axis=self.axis_id, search_mode=search_mode)
def move(self, position, absolute=True,wait=False,block=False):
"""
:param position: Position to set move to along this axis.
:type position: `float` or :class:`~quantities.Quantity`
:param bool absolute: If `True`, the position ``pos`` is
interpreted as relative to the zero-point of the encoder.
If `False`, ``pos`` is interpreted
as relative to the current position of this axis.
:param bool wait: If True, will tell axis to not execute other
commands until movement is finished
:param bool block: If True, will block code until movement is finished
"""
position = float(assume_units(position,self._units).rescale(
self._units).magnitude)
# TODO: handle unit conversions here.
if absolute:
self._controller._newport_cmd("PA", params=[position], target=self.axis_id)
else:
self._controller._newport_cmd("PR", params=[position], target=self.axis_id)
if wait:
self.wait_for_position(position)
if block:
sleep(0.003)
mot = self.is_motion_done
while not mot:
mot = self.is_motion_done
def move_to_hardware_limit(self):
"""
move to hardware travel limit
"""
self._controller._newport_cmd("MT", target=self.axis_id)
def move_indefinitely(self):
"""
Move until told to stop
"""
self._controller._newport_cmd("MV", target=self.axis_id)
def abort_motion(self):
"""
Abort motion
"""
self._controller._newport_cmd("AB", target=self.axis_id)
def wait_for_stop(self):
"""
Waits for axis motion to stop before next command is executed
"""
self._controller._newport_cmd("WS",target=self.axis_id)
def stop_motion(self):
"""
Stop all motion on axis. With programmed deceleration rate
"""
try:
self._controller._newport_cmd("ST",target=self.axis_id)
except NewportError, e:
print e
