Devices

pytac/device.py

@@ -3,7 +3,7 @@
 
 
 class Device(object):
-    def __init__(self, cs, rb_pv=None, sp_pv=None):
+    def __init__(self, cs, enabled=True, rb_pv=None, sp_pv=None):
         """A device attached on an element.
 
         Contains a control system, readback and setpoint pvs. A readback
@@ -13,14 +13,16 @@ def __init__(self, cs, rb_pv=None, sp_pv=None):
         Args:
             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.
         """
         self.rb_pv = rb_pv
         self.sp_pv = sp_pv
         self._cs = cs
-        self._enabled = True
+        self._enabled = enabled
         if rb_pv is not None:
             self.name = rb_pv.split(':')[0]
         elif sp_pv is not None:
@@ -36,14 +38,6 @@ def is_enabled(self):
         """
         return self._enabled
 
-    def set_enabled(self, enabled=True):
-        """Enable or disable an device.
-
-        Args:
-            enabled (boolean): Set whether an device is disabled or enabled.
-        """
-        self._enabled = enabled
-
     def put_value(self, value):
         """Set the value of a pv.
 
@@ -110,7 +104,9 @@ def get_cs(self):
 
 class PvEnabler(object):
     def __init__(self, pv, enabled_value, cs):
-        """A PvEnabler class to check whether a pv is enabled.
+        """A PvEnabler class to check whether a device is enabled.
+
+        This object doesn't allow disabling the device.
 
         Args:
             pv(string): The string representation of the pv.
@@ -119,7 +115,7 @@ def __init__(self, pv, enabled_value, cs):
             cs: Control system object used to determine if a pv is enabled.
         """
         self._pv = pv
-        self._enabled_value = enabled_value
+        self._enabled_value = str(int(float(enabled_value)))
         self._cs = cs
 
     def __nonzero__(self):
@@ -131,7 +127,7 @@ def __nonzero__(self):
             boolean: Determining whether a device is enabled or not.
         """
         pv_value = self._cs.get(self._pv)
-        return self._enabled_value == pv_value
+        return self._enabled_value == str(int(float(pv_value)))
 
     def __bool__(self):
         """Used to override the 'if object' clause.

pytac/load_csv.py

@@ -21,7 +21,7 @@ def mult_rigidity(input):
 def load_unitconv(directory, mode, lattice):
     """Load the unit conversion objects from a file.
 
-     Args:
+    Args:
         directory(string): The directory where the data is stored.
         mode(string): The name of the mode that is used.
         lattice(Lattice): The lattice object that will be used.
@@ -84,8 +84,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:
-            d = device.Device(control_system, item['get_pv'], item['set_pv'])
-            lat[int(item['id']) - 1].add_device(item['field'], d, None)
+            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)
+            lat[int(item['id']) - 1].add_device(item['field'], d, control_system)
 
     with open(os.path.join(directory, mode, 'families.csv')) as families:
         csv_reader = csv.DictReader(families)

test/data/dummy/devices.csv

@@ -1,4 +1,3 @@
-id,field,get_pv,set_pv
-2,b1,Q1:RB,Q1:SP
-4,b2,S1:RB,S1:SP
-
+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

test/test_device.py

@@ -6,12 +6,20 @@
 
 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):
+def create_device(readback=RB_PV, setpoint=SP_PV, _enable_pv=ENABLE_PV, _enabled_value=ENABLED_VALUE):
     _rb = readback
     _sp = setpoint
-    device = pytac.device.Device(rb_pv=_rb, sp_pv=_sp, cs=mock.MagicMock())
+    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)
     return device
 
 
@@ -33,19 +41,23 @@ def test_get_device_value(create_device):
         create_device.get_value('non_existent')
 
 
+def test_is_enabled_empty_string():
+    device = create_device(_enabled_value='')
+    assert device.is_enabled()
+
 def test_is_enabled(create_device):
-    assert create_device.is_enabled() == True
+    assert create_device.is_enabled()
 
 
-def test_set_enabled(create_device):
-    create_device.set_enabled(False)
-    assert create_device.is_enabled() == False
+def test_is_disabled():
+    device = create_device(_enabled_value='3')
+    assert not device.is_enabled()
 
 
 def test_PvEnabler():
     mock_cs = mock.MagicMock()
-    mock_cs.get.return_value = 40
-    pve = pytac.device.PvEnabler('enable-pv', 40, mock_cs)
+    mock_cs.get.return_value = '40'
+    pve = pytac.device.PvEnabler('enable-pv', '40', mock_cs)
     assert pve
 
     mock_cs.get.return_value = 50

test/test_element.py

@@ -16,8 +16,8 @@ def test_element(length=0.0, uc=PolyUnitConv([1, 0])):
     element = pytac.element.Element('dummy', 1.0, 'Quad')
     rb_pv = 'SR22C-DI-EBPM-04:SA:X'
     sp_pv = 'SR22C-DI-EBPM-04:SA:Y'
-    device1 = pytac.device.Device(mock_cs, rb_pv, sp_pv)
-    device2 = pytac.device.Device(mock_cs, sp_pv, rb_pv)
+    device1 = pytac.device.Device(mock_cs, True, rb_pv, sp_pv)
+    device2 = pytac.device.Device(mock_cs, True, sp_pv, rb_pv)
 
     element.add_device('x', device1, uc)
     element.add_device('y', device2, uc)

test/test_lattice.py

@@ -17,8 +17,8 @@ def simple_element(identity=1):
     element = pytac.element.Element(identity, 0, 'BPM')
     rb_pv = 'readback_pv'
     sp_pv = 'setpoint_pv'
-    device1 = pytac.device.Device(mock.MagicMock(), sp_pv, rb_pv)
-    device2 = pytac.device.Device(mock.MagicMock(), sp_pv, rb_pv)
+    device1 = pytac.device.Device(mock.MagicMock(), True, sp_pv, rb_pv)
+    device2 = pytac.device.Device(mock.MagicMock(), True, sp_pv, rb_pv)
     element.add_to_family('family')
 
     element.add_device('x', device1, uc)

test/test_machine.py

@@ -89,6 +89,7 @@ def test_quad_unitconv(lattice):
         numpy.testing.assert_allclose(uc.eng_to_phys(70), -6.918132432432433)
         numpy.testing.assert_allclose(uc.phys_to_eng(-6.918132432432433), 70)
 
+
 def test_quad_unitconv_raise_exception(lattice):
     LAT_ENERGY = 3000
 
@@ -97,6 +98,7 @@ def test_quad_unitconv_raise_exception(lattice):
     with pytest.raises(UniqueSolutionException):
         numpy.testing.assert_allclose(uc.phys_to_eng(-0.7), 70.8834284954)
 
+
 def test_quad_unitconv_known_failing_test(lattice):
     LAT_ENERGY = 3000
 

utils/load_mml.m

@@ -22,7 +22,7 @@ function load_mml(ringmode)
     fprintf(f_elements, 'id,name,type,length\n');
     devices_file = fullfile(dir, '..', 'data', ringmode, 'devices.csv');
     f_devices = fopen(devices_file, 'w');
-    fprintf(f_devices, 'id,field,get_pv,set_pv\n');
+    fprintf(f_devices, 'id,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');
@@ -78,7 +78,7 @@ function load_mml(ringmode)
     new_index = new_index + 1;
     old_index = old_index + 1;
     insertelement(new_index, dcct, 0, ringmode);
-    s = pv_struct('SR-DI-DCCT-01:SIGNAL', 'I', 'get');
+    s = pv_struct('I', 'SR-DI-DCCT-01:SIGNAL', '', '', '');
     insertpvs(new_index, {s});
 
     renamed_indexes(old_index) = new_index;
@@ -108,7 +108,7 @@ function insertpvs(index, pvs)
         end
         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\n', index, pvs{i}.field, deblank(pvs{i}.get_pv), deblank(pvs{i}.set_pv));
+            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);
         end
     end
 
@@ -153,19 +153,20 @@ function insertpvs(index, pvs)
 
             get_pv = char(ao.(family).Monitor.ChannelNames(index, :));
             set_pv = char(ao.(family).Setpoint.ChannelNames(index, :));
-            pvs = pv_struct(field, get_pv, set_pv);
+            pvs = pv_struct(field, get_pv, set_pv, '', '');
             pvs = {pvs};
         elseif strcmp(type, 'BPM')
             index = used_elements(type);
+            enable_pv = strcat(BPMS{index}, ':CF:ENABLED_S')
             get_x_pv = strcat(BPMS{index}, ':SA:X');
-            x_pv = pv_struct('x', get_x_pv, '');
+            x_pv = pv_struct('x', get_x_pv, '', enable_pv, 'BPM Enabled');
             get_y_pv = strcat(BPMS{index}, ':SA:Y');
-            y_pv = pv_struct('y', get_y_pv, '');
+            y_pv = pv_struct('y', get_y_pv, '', enable_pv, 'BPM Enabled');
             pvs = {x_pv, y_pv};
         elseif strcmp(type, 'RF')
             gfpv = ao.(type).Monitor.ChannelNames;
             sfpv = ao.(type).Setpoint.ChannelNames;
-            f_pvs = pv_struct('f', gfpv, sfpv);
+            f_pvs = pv_struct('f', gfpv, sfpv, '', '');
             % voltage?
             pvs = {f_pvs};
         else
@@ -180,14 +181,14 @@ function insertextrapvs(family, field)
             for i = 1:length(elms.AT.ATIndex)
                 get_pv = elms.Monitor.ChannelNames(i,:);
                 set_pv = elms.Setpoint.ChannelNames(i,:);
-                pvs = pv_struct(field, set_pv, get_pv);
+                pvs = pv_struct(field, set_pv, get_pv, '', '');
                 insertpvs(renamed_indexes(elms.AT.ATIndex(i)), {pvs});
             end
         end
     end
 
-    function s = pv_struct(field, get_pv, set_pv)
-        s = struct('field', field, 'get_pv', get_pv, 'set_pv', set_pv);
+    function s = pv_struct(field, get_pv, set_pv, enable_pv, enable_value)
+        s = struct('field', field, 'get_pv', get_pv, 'set_pv', set_pv, 'enable_pv', enable_pv, 'enable_value', enable_value);
     end
 
     function insertelement(i, elm, s, ringmode)