Devices

data/DIAD/uc_pchip_data.csv

@@ -649,7 +649,7 @@ uc_id,eng,phy
 159,0.00000000,0.00000000
 159,1.00000000,0.16260000
 160,0.00000000,0.00000000
-160,1.00000000,0.15960000
+160,1.00000000,0.15210000
 161,0.00000000,0.00000000
 161,1.00000000,0.15210000
 162,0.00000000,0.00000000

data/DIAD/uc_poly_data.csv

@@ -156,11 +156,11 @@ uc_id,coeff,val
 289,0,0.000000
 289,1,0.002032
 290,0,0.000000
-290,1,0.001471
+290,1,0.002071
 291,0,0.000000
-291,1,0.002071
+291,1,0.002074
 292,0,0.000000
-292,1,0.002074
+292,1,0.002078
 293,0,0.000000
 293,1,0.002068
 294,0,0.000000
@@ -500,11 +500,11 @@ uc_id,coeff,val
 461,0,0.000000
 461,1,0.002026
 462,0,0.000000
-462,1,0.001464
+462,1,0.002057
 463,0,0.000000
-463,1,0.002057
+463,1,0.002015
 464,0,0.000000
-464,1,0.002015
+464,1,0.002064
 465,0,0.000000
 465,1,0.002078
 466,0,0.000000

pytac/device.py

@@ -5,32 +5,29 @@
 
 
 class Device(object):
-    def __init__(self, cs, enabled=True, rb_pv=None, sp_pv=None):
+    def __init__(self, name, cs, enabled=True, rb_suffix=None, sp_suffix=None):
         """A device attached on an element.
 
         Contains a control system, readback and setpoint pvs. A readback
         or setpoint pv is required when creating a device otherwise a
         PvException is raised. The device is enabled by default.
 
         Args:
+            name: prefix of EPICS PVs for this device
             cs (ControlSystem): Control system object used to get and set
                 the value of a pv.
             enabled (bool-like): Whether the device is enabled.  May be
                 a PvEnabler object.
-            rb_pv (string): A readback pv. This value cannot be changed.
-            sp_pv (string): A setpoint pv. This value can be read and also
-                changed.
+            rb_suffix (string): suffix of EPICS readback pv
+            sp_suffix (string): suffix of EPICS setpoint pv
         """
-        self.rb_pv = rb_pv
-        self.sp_pv = sp_pv
+        self.name = name
         self._cs = cs
-        self._enabled = enabled
-        if rb_pv is not None:
-            self.name = rb_pv.split(':')[0]
-        elif sp_pv is not None:
-            self.name = sp_pv.split(':')[0]
-        else:
-            raise PvException("Readback or setpoint pvs need to be given")
+        if rb_suffix is not None:
+            self.rb_pv = name + rb_suffix
+        if sp_suffix is not None:
+            self.sp_pv = name + sp_suffix
+        self._enabled = True
 
     def is_enabled(self):
         """Check whether an device is enabled or disabled.
@@ -51,11 +48,9 @@ def put_value(self, value):
         Raises:
             PvException: An exception occured when no setpoint pv exists.
         """
-        # Not sure if this method will need a handle flag to set
-        # an initial value for readback pvs. Suppose not:
-        if self.sp_pv is not None:
+        try:
             self._cs.put(self.sp_pv, value)
-        else:
+        except AttributeError:
             raise PvException("""This device {0} has no setpoint pv."""
                               .format(self.name))
 

pytac/load_csv.py

@@ -87,14 +87,15 @@ def load(mode, control_system, directory=None):
     with open(os.path.join(directory, mode, 'devices.csv')) as devices:
         csv_reader = csv.DictReader(devices)
         for item in csv_reader:
+            name = item['name']
             enable_pv = item['enable_pv']
             enable_value = item['enable_value']
             get_pv = item['get_pv']
             set_pv = item['set_pv']
             pve = True
             if enable_pv and enable_value:
                 pve = device.PvEnabler(enable_pv, enable_value, control_system)
-            d = device.Device(control_system, pve, get_pv, set_pv)
+            d = device.Device(name, control_system, pve, get_pv, set_pv)
             lat[int(item['id']) - 1].add_device(item['field'], d, control_system)
 
     with open(os.path.join(directory, mode, 'families.csv')) as families:

test/constants.py

@@ -0,0 +1,7 @@
+PREFIX = 'prefix'
+RB_SUFFIX = ':rb'
+SP_SUFFIX = ':sp'
+RB_PV = PREFIX + RB_SUFFIX
+SP_PV = PREFIX + SP_SUFFIX
+
+LATTICE = 'lattice'

test/data/dummy/devices.csv

@@ -1,3 +1,3 @@
-id,field,get_pv,set_pv,enable_pv,enable_value
-2,b1,Q1:RB,Q1:SP,SR01C-DI-EBPM-01:CF:ENABLED_S,1
-4,b2,S1:RB,S1:SP,SR01C-DI-EBPM-01:CF:ENABLED_S,1
+id,name,field,get_pv,set_pv,enable_pv,enable_value
+2,Q1,b1,:RB,:SP,SR01C-DI-EBPM-01:CF:ENABLED_S,1
+4,S1,b2,:RB,:SP,SR01C-DI-EBPM-01:CF:ENABLED_S,1

test/test_device.py

@@ -3,55 +3,51 @@
 import pytest
 import mock
 
+from constants import PREFIX, RB_SUFFIX, SP_SUFFIX, RB_PV, SP_PV
+
 
-SP_PV = 'SR01A-PC-SQUAD-01:SETI'
-RB_PV = 'SR01A-PC-SQUAD-01:I'
 ENABLE_PV = 'SR01C-DI-EBPM-01:CF:ENABLED_S'
 ENABLED_VALUE = '1.0'
 
-@pytest.fixture
-def create_device(readback=RB_PV, setpoint=SP_PV, _enable_pv=ENABLE_PV, _enabled_value=ENABLED_VALUE):
-    _rb = readback
-    _sp = setpoint
+
+def create_device(prefix=PREFIX, rb_suff=RB_SUFFIX, sp_suff=SP_SUFFIX, enabled=True):
     mock_cs = mock.MagicMock()
     mock_cs.get.return_value = '1.0'
-    if _enable_pv and _enabled_value:
-        pve = pytac.device.PvEnabler(_enable_pv, _enabled_value, mock_cs)
-        device = pytac.device.Device(cs=mock.MagicMock(), enabled=pve, rb_pv=_rb, sp_pv=_sp)
-    else:
-        device = pytac.device.Device(cs=mock.MagicMock(), enabled=True, rb_pv=_rb, sp_pv=_sp)
+    device = pytac.device.Device(prefix, mock.MagicMock(), enabled=enabled, rb_suffix=rb_suff, sp_suffix=sp_suff)
     return device
 
 
-def test_set_device_value(create_device):
-    create_device.put_value(40)
-    create_device._cs.put.assert_called_with(SP_PV, 40)
+def test_set_device_value():
+    device = create_device()
+    device.put_value(40)
+    device._cs.put.assert_called_with(PREFIX + SP_SUFFIX, 40)
 
 
 def test_device_invalid_sp_raise_exception():
-    device2 = create_device(RB_PV, None)
+    device2 = create_device(PREFIX, RB_SUFFIX, None)
     with pytest.raises(PvException):
         device2.put_value(40)
-    with pytest.raises(PvException):
-        create_device(None, None)
 
 
-def test_get_device_value(create_device):
+def test_get_device_value():
+    device = create_device()
     with pytest.raises(PvException):
-        create_device.get_value('non_existent')
+        device.get_value('non_existent')
 
 
 def test_is_enabled_empty_string():
-    device = create_device(_enabled_value='')
+    device = create_device(enabled=False)
     assert device.is_enabled()
 
-def test_is_enabled(create_device):
-    assert create_device.is_enabled()
+
+def test_device_is_enabled_by_default():
+    device = create_device()
+    assert device.is_enabled()
 
 
-def test_is_disabled():
-    device = create_device(_enabled_value='3')
-    assert not device.is_enabled()
+def test_is_disabled_if_False_enabler():
+    device = create_device(enabled=False)
+    assert device.is_enabled()
 
 
 def test_PvEnabler():

test/test_element.py

@@ -7,8 +7,11 @@
 import pytac
 
 
-RB_PV = 'rb_pv'
-SP_PV = 'sp_pv'
+PREFIX = 'prefix'
+RB_SUFF = ':rb'
+RB_PV = PREFIX + RB_SUFF
+SP_SUFF = ':sp'
+SP_PV = PREFIX + SP_SUFF
 
 DUMMY_VALUE_1 = 40.0
 DUMMY_VALUE_2 = 4.7
@@ -28,8 +31,8 @@ def test_element(length=0.0, uc=mock_uc()):
     mock_cs.get.return_value = DUMMY_VALUE_1
 
     element = pytac.element.Element('dummy', 1.0, 'Quad')
-    device1 = pytac.device.Device(mock_cs, True, RB_PV, SP_PV)
-    device2 = pytac.device.Device(mock_cs, True, SP_PV, RB_PV)
+    device1 = pytac.device.Device(PREFIX, mock_cs, True, RB_SUFF, SP_SUFF)
+    device2 = pytac.device.Device(PREFIX, mock_cs, True, SP_SUFF, RB_SUFF)
 
     element.add_device('x', device1, uc)
     element.add_device('y', device2, uc)

test/test_lattice.py

@@ -6,7 +6,7 @@
 from pytac.units import PolyUnitConv
 from pytac.exceptions import ElementNotFoundException, PvException
 
-DUMMY_NAME = 'dummy'
+from constants import PREFIX, RB_SUFFIX, SP_SUFFIX, RB_PV, SP_PV, LATTICE
 
 
 @pytest.fixture
@@ -15,10 +15,11 @@ def simple_element(identity=1):
 
     # Create devices and attach them to the element
     element = pytac.element.Element(identity, 0, 'BPM')
-    rb_pv = 'readback_pv'
-    sp_pv = 'setpoint_pv'
-    device1 = pytac.device.Device(mock.MagicMock(), True, sp_pv, rb_pv)
-    device2 = pytac.device.Device(mock.MagicMock(), True, sp_pv, rb_pv)
+    prefix = 'prefix'
+    rb_suff = ':rb'
+    sp_suff = ':sp'
+    device1 = pytac.device.Device(prefix, mock.MagicMock(), True, sp_suff, rb_suff)
+    device2 = pytac.device.Device(prefix, mock.MagicMock(), True, sp_suff, rb_suff)
     element.add_to_family('family')
 
     element.add_device('x', device1, uc)
@@ -29,19 +30,19 @@ def simple_element(identity=1):
 
 @pytest.fixture
 def simple_element_and_lattice(simple_element):
-    l = pytac.lattice.Lattice(DUMMY_NAME, mock.MagicMock(), 1)
+    l = pytac.lattice.Lattice(LATTICE, mock.MagicMock(), 1)
     l.add_element(simple_element)
     return simple_element, l
 
 
 def test_create_lattice():
-    l = pytac.lattice.Lattice(DUMMY_NAME, mock.MagicMock(), 1)
+    l = pytac.lattice.Lattice(LATTICE, mock.MagicMock(), 1)
     assert(len(l)) == 0
-    assert l.name == DUMMY_NAME
+    assert l.name == LATTICE
 
 
 def test_non_negative_lattice():
-    l = pytac.lattice.Lattice(DUMMY_NAME, mock.MagicMock(), 1)
+    l = pytac.lattice.Lattice(LATTICE, mock.MagicMock(), 1)
     assert(len(l)) >= 0
 
 
@@ -70,13 +71,13 @@ def test_get_all_families(simple_element_and_lattice):
 def test_get_family_values(simple_element_and_lattice):
     element, lattice = simple_element_and_lattice
     lattice.get_family_values('family', 'x')
-    lattice._cs.get.assert_called_with(['readback_pv'])
+    lattice._cs.get.assert_called_with([RB_PV])
 
 
 def test_set_family_values(simple_element_and_lattice):
     element, lattice = simple_element_and_lattice
     lattice.set_family_values('family', 'x', [1])
-    lattice._cs.put.assert_called_with(['readback_pv'], [1])
+    lattice._cs.put.assert_called_with([RB_PV], [1])
 
 
 def test_set_family_values_raise_exception(simple_element_and_lattice):
@@ -98,7 +99,7 @@ def test_s_position(simple_element_and_lattice):
     assert lattice.get_s(element3) == 1.0
 
 def test_get_s_throws_exception_if_element_not_in_lattice():
-    l = pytac.lattice.Lattice(DUMMY_NAME, mock.MagicMock(), 1)
+    l = pytac.lattice.Lattice(LATTICE, mock.MagicMock(), 1)
     element = pytac.element.Element(1, 1.0, 'Quad')
     with pytest.raises(ElementNotFoundException):
         l.get_s(element)
@@ -123,5 +124,5 @@ def test_get_family_s(simple_element_and_lattice):
     assert lattice.get_family_s('family') == [0, 0, 1.0, 2.5]
 
 def test_lattice_initial_energy():
-    lattice = pytac.lattice.Lattice(DUMMY_NAME, mock.MagicMock(), 1)
+    lattice = pytac.lattice.Lattice(LATTICE, mock.MagicMock(), 1)
     assert lattice.get_energy() == 1

utils/load_mml.m

@@ -22,7 +22,7 @@ function load_mml(ringmode)
     fprintf(f_elements, 'id,name,type,length,cell\n');
     devices_file = fullfile(dir, '..', 'data', ringmode, 'devices.csv');
     f_devices = fopen(devices_file, 'w');
-    fprintf(f_devices, 'id,field,get_pv,set_pv,enable_pv,enable_value\n');
+    fprintf(f_devices, 'id,name,field,get_pv,set_pv,enable_pv,enable_value\n');
     families_file = fullfile(dir, '..', 'data', ringmode, 'families.csv');
     f_families = fopen(families_file, 'w');
     fprintf(f_families, 'id,family\n');
@@ -106,9 +106,13 @@ function insertpvs(index, pvs)
         if size(pvs) == 0
             return;
         end
+        parts = strsplit(pvs{1}.get_pv,':');
+        prefix = parts{1};
         for i = 1:size(pvs, 2)
-            %fprintf('%s: %d\n', deblank(pvs{i}.pv), size(deblank(pvs{i}.pv), 2));
-            fprintf(f_devices, '%d,%s,%s,%s,%s,%s\n', index, pvs{i}.field, deblank(pvs{i}.get_pv), deblank(pvs{i}.set_pv), deblank(pvs{i}.enable_pv), pvs{i}.enable_value);
+            get_suffix = pvs{i}.get_pv(length(prefix) + 1:end);
+            set_suffix = pvs{i}.set_pv(length(prefix) + 1:end);
+            enable_suffix = pvs{i}.enable_pv(length(prefix) + 1:end);
+            fprintf(f_devices, '%d,%s,%s,%s,%s,%s,%s\n', index, prefix, pvs{i}.field, deblank(get_suffix), deblank(set_suffix), enable_suffix, pvs{i}.enable_value);
         end
     end