def __init__(self):
        Backend.__init__(self)
        self.prod_pu_to_kv = None
        self.load_pu_to_kv = None
        self.lines_or_pu_to_kv = None
        self.lines_ex_pu_to_kv = None

        self.p_or = None
        self.q_or = None
        self.v_or = None
        self.a_or = None
        self.p_ex = None
        self.q_ex = None
        self.v_ex = None
        self.a_ex = None

        self._pf_init = "flat"
        self._pf_init = "results"
        self._nb_bus_before = 0

        self.thermal_limit_a = None

        self._iref_slack = -1
        self._id_bus_added = -1
        self._fact_mult_gen = -1
        self._subs_to_table = None
        self._what_object_where = None
        self._number_true_line = -1
        self._corresp_name_fun = {}
        self._get_vector_inj = {}
        self._dim_topo = -1
        self._vars_action = Action.vars_action
        self._vars_action_set = Action.vars_action_set
示例#2
0
  def __init__(self) :
    Backend.__init__(self)
    self.messages = {}
    self.contacts = {}

    # Dummy data
    self.messages = { 
      'peter' : [
          Message(datetime.datetime(2008, 01, 01), 'peter', 'Reading some XMPP specs'),
          Message(datetime.datetime(2008, 01, 03), 'peter', '@kevin Tell me about it')
        ],
      'kevin' : [
          Message(datetime.datetime(2008, 01, 02), 'kevin', 'Too little time to do all the things I want to')
        ],
      'remko' : [
          Message(datetime.datetime(2008, 01, 04), 'remko', 'Woohoow, holidays!')
        ]}
    self.contacts = { 'remko' : ['kevin', 'peter'] }
    self.subscribers = { 'kevin' : ['remko'], 'peter' : ['remko'] }
    self.jidToUser = {
        '*****@*****.**' : 'remko',
        '*****@*****.**' : 'peter',
        '*****@*****.**' : 'kevin',
      }
    self.userToJID = { 
        'remko' : '*****@*****.**',
        'peter' : '*****@*****.**',
        'kevin' : '*****@*****.**' 
      }
    self.userPresenceMonitoring = {
        'kevin' : True,
        'remko' : False,
        'peter' : True,
      }
示例#3
0
    def __init__(self,
                 theBank,
                 theMode,
                 theRoach,
                 theValon,
                 hpc_macs,
                 unit_test=False):
        """
        Creates an instance of the vegas internals.
        """

        # mode_number may be treated as a constant; the Player will
        # delete this backend object and create a new one on mode
        # change.
        Backend.__init__(self, theBank, theMode, theRoach, theValon, hpc_macs,
                         unit_test)
        # Important to do this as soon as possible, so that status application
        # can change its data buffer format
        print "VEGAS finished init for Backend"
        self.write_status(BACKEND='VEGAS')
        print "after write_status"

        # In VEGAS mode, i_am_master means this particular backend
        # controls the switching signals. (self.bank is from base class.)
        self.i_am_master = self.bank.i_am_master

        # the switching signals builder
        self.ss = SwitchingSignals()

        # Parameters:
        self.setPolarization('SELF')
        self.setNumberChannels(self.mode.nchan)
        self.requested_integration_time = 1.0

        # self.setValonFrequency(self.mode.frequency)

        # dependent values, computed from Parameters:
        self.nspectra = 1
        self.nsubbands = 1
        self.frequency_resolution = 0.0
        self.fpga_clock = None
        self.fits_writer_process = None
        self.scan_length = 30.0
        self.spec_tick = self.computeSpecTick()
        self.setHwExposr(self.mode.hwexposr)

        # setup the parameter dictionary/methods
        self.params["polarization"] = self.setPolarization
        self.params["nchan"] = self.setNumberChannels
        self.params["exposure"] = self.setIntegrationTime
        self.params["hwexposr"] = self.setHwExposr
        self.params["num_spectra"] = self.setNumberSpectra

        # the status memory key/value pair dictionary
        self.sskeys = {}
        self.ss.set_spec_tick(self.spec_tick)
        self.ss.set_hwexposr(self.hwexposr)

        self.fits_writer_program = "vegasFitsWriter"
示例#4
0
    def __init__(self,host,user=None,password=None,https=False,auth=None):
        """Initialises the backend

        host: the hostname to the Exchange server
        auth: is the authorisation string for basic authorisation (may
              be specified instead of user/pass)
        """
        Backend.__init__(self)
        self.conn = SoapConn(host,https=https,user=user,password=password,
                             auth=auth)
        self.query = SoapQuery(self.conn)
示例#5
0
    def __init__(self, root, *args, **kwargs):
        tk.Canvas.__init__(self, *args, width=600, height=600, bg = "white",
                            bd=1, relief='raised')
        Backend.__init__(self)
        self.root = root

        self.tag_bind("Draggable","<ButtonPress-1>",self.onClickPress)

        self.tag_bind("Draggable","<ButtonPress-2>",self.onRightClick)

        self.tag_bind("Draggable",
                                "<ButtonRelease-1>",self.onClickRelease)
        self.tag_bind("Draggable","<B1-Motion>",self.handleMotion)

        self.tag_bind("Draggable","<Double-Button-1>",self.onDoubleClick)

        self.textSize = 36

        self.equivalenceLines = []

        self.guiExpressions = {}

        self.numbers = {}

        # currentAction can be None, "Drag", "DragFromEquationVar", "DragFromExp"
        self.currentAction = None

        self.currentDragLine = None
        # self.clickData["variable"] = None
        # self.dragStartExpressionVar = None
        # self.clickData["coords"] = None

        self.clickData = {"clickedObject" : None, # Expression, Equation, etc
                            "variable" : None, # or "EK" or whatever
                            "coords" : None
                            }

        # This is the menu when you click on a variable in an equation
        self.eqVarPopup = tk.Menu(root, tearoff=0)
        self.eqVarPopup.add_command(label="Find expression",
                command = self.findGUIExpressionRightClick)
        self.eqVarPopup.add_separator()
        self.eqVarPopup.add_command(label="Delete equation",
                    command= self.deleteEquation)

        # This is the menu when you click on something else in an equation
        self.eqOtherPopup = tk.Menu(root, tearoff=0)
        self.eqOtherPopup.add_command(label="Delete equation",
                    command= self.deleteEquation)

        self.font = "Courier New"
    def __init__(self, theBank, theMode, theRoach, theValon, hpc_macs, unit_test = False):
        """
        Creates an instance of the vegas internals.
        """

        # mode_number may be treated as a constant; the Player will
        # delete this backend object and create a new one on mode
        # change.
        Backend.__init__(self, theBank, theMode, theRoach , theValon, hpc_macs, unit_test)
        # Important to do this as soon as possible, so that status application
        # can change its data buffer format
        self.write_status(BACKEND='VEGAS')

        # In VEGAS mode, i_am_master means this particular backend
        # controls the switching signals. (self.bank is from base class.)
        self.i_am_master = self.bank.i_am_master

        # the switching signals builder
        self.ss = SwitchingSignals()

        # Parameters:
        self.setPolarization('SELF')
        self.setNumberChannels(self.mode.nchan)
        self.requested_integration_time = 1.0

        # self.setValonFrequency(self.mode.frequency)

        # dependent values, computed from Parameters:
        self.nspectra = 1
        self.nsubbands = 1
        self.frequency_resolution = 0.0
        self.fpga_clock = None
        self.fits_writer_process = None
        self.scan_length = 30.0
        self.spec_tick = self.computeSpecTick()
        self.setHwExposr(self.mode.hwexposr)

        # setup the parameter dictionary/methods
        self.params["polarization" ] = self.setPolarization
        self.params["nchan"        ] = self.setNumberChannels
        self.params["exposure"     ] = self.setIntegrationTime
        self.params["hwexposr"     ] = self.setHwExposr
        self.params["num_spectra"  ] = self.setNumberSpectra

        # the status memory key/value pair dictionary
        self.sskeys = {}
        self.ss.set_spec_tick(self.spec_tick)
        self.ss.set_hwexposr(self.hwexposr)

        self.fits_writer_program = "vegasFitsWriter"
示例#7
0
    def __init__(self, detailed_infos_for_cascading_failures=False):
        Backend.__init__(self,
                         detailed_infos_for_cascading_failures=
                         detailed_infos_for_cascading_failures)
        self.prod_pu_to_kv = None
        self.load_pu_to_kv = None
        self.lines_or_pu_to_kv = None
        self.lines_ex_pu_to_kv = None

        self.p_or = None
        self.q_or = None
        self.v_or = None
        self.a_or = None
        self.p_ex = None
        self.q_ex = None
        self.v_ex = None
        self.a_ex = None

        self.load_p = None
        self.load_q = None
        self.load_v = None

        self.prod_p = None
        self.prod_q = None
        self.prod_v = None

        self._pf_init = "flat"
        self._pf_init = "results"
        self._nb_bus_before = 0

        self.thermal_limit_a = None

        self._iref_slack = None
        self._id_bus_added = None
        self._fact_mult_gen = -1
        self._what_object_where = None
        self._number_true_line = -1
        self._corresp_name_fun = {}
        self._get_vector_inj = {}
        self.dim_topo = -1
        self._vars_action = Action.vars_action
        self._vars_action_set = Action.vars_action_set
示例#8
0
    def __init__(self):
        Backend.__init__(self)
        self.messages = {}
        self.contacts = {}

        # Dummy data
        self.messages = {
            'peter': [
                Message(datetime.datetime(2008, 01, 01), 'peter',
                        'Reading some XMPP specs'),
                Message(datetime.datetime(2008, 01, 03), 'peter',
                        '@kevin Tell me about it')
            ],
            'kevin': [
                Message(datetime.datetime(2008, 01, 02), 'kevin',
                        'Too little time to do all the things I want to')
            ],
            'remko': [
                Message(datetime.datetime(2008, 01, 04), 'remko',
                        'Woohoow, holidays!')
            ]
        }
        self.contacts = {'remko': ['kevin', 'peter']}
        self.subscribers = {'kevin': ['remko'], 'peter': ['remko']}
        self.jidToUser = {
            '*****@*****.**': 'remko',
            '*****@*****.**': 'peter',
            '*****@*****.**': 'kevin',
        }
        self.userToJID = {
            'remko': '*****@*****.**',
            'peter': '*****@*****.**',
            'kevin': '*****@*****.**'
        }
        self.userPresenceMonitoring = {
            'kevin': True,
            'remko': False,
            'peter': True,
        }
示例#9
0
    def __init__(self,
                 theBank,
                 theMode,
                 theRoach,
                 theValon,
                 hpc_macs,
                 unit_test=False,
                 instance_id=None):
        """
        Creates an instance of BeamformerBackend
        """
        self.roach_simulator = True
        print "BFBE: ROACH SIMULATOR MODE"
        self.name = theMode.backend_name.lower()
        self.current_mode = theMode.name
        self.bank_name = theBank.name.upper()

        # Read in the additional parameters from the configuration file
        #config_file = './dibas.conf'
        config_file = os.getenv("DIBAS_DIR") + '/etc/config/dibas.conf'
        dibas_parser = DibasParser(dibas_conf_file=config_file)
        dibas_info = dibas_parser.get_dibas_info()

        self.roaches = []
        self.configures_roaches = False
        self.RD = None

        self.pkt_gen = dibas_info['pkt_gen']

        roach_names = dibas_info['roaches']
        if theBank.name == dibas_info['isDoctor']:
            self.RD = RoachDoctor(roach_host_list=roach_names,
                                  dibas_info=dibas_info)
            self.configures_roaches = True
            self.roaches = self.RD.get_roaches()
            #self.RD.configure(fft_shift=0xffffffff, quan_gain=0x00000014)
            self.RD.configure(simulator=self.roach_simulator)

        self.read_parameters(theBank, theMode)

        # init the super, clear shmem and init shmem
        Backend.__init__(self, theBank, theMode, theRoach, theValon, hpc_macs,
                         unit_test)
        self.clear_shared_memory()
        self.status = FlagPole(instance_id=self.instance)

        # Set some default parameter values
        self.requested_weight_file = ''
        self.weifile_new = ''
        self.requested_channel = 0
        self.requested_integration_time = 1.0

        self.fits_writer_process = None

        # Add additional dealer-controlled parameters
        self.params["int_length"] = self.setIntegrationTime
        self.params["weight_file"] = self.setNewWeightFilename
        self.params["channel_select"] = self.setChannel

        # TODO: will we need use roach_kvpairs
        if self.mode.roach_kvpairs:
            self.write_registers(**self.mode.roach_kvpairs)

        # TODO: will we need to use reset_roach - this is defined in diabs.conf, a sequence of commands to execute
        #self.reset_roach()

        self.prepare()

        # super class backend says this is backend dependent and I dont think our backend needs this
        #self.clear_switching_states()
        #self.add_switching_state(1.0, blank = False, cal = False, sig_ref_1 = False)
        self.start_hpc()

        self.fits_writer_program = self.fits_writer_program_bf
        self.start_fits_writer()
    def __init__(self, theBank, theMode, theRoach, theValon, hpc_macs, unit_test=False):
        """
        Creates an instance of the class.
        """

        # Only one HPC Player will be controlling a roach in the CODD
        # mode family. Therefore figure out if we are the one; if not,
        # set the parameters 'theRoach' and 'theValon' to None, even if
        # this HPC does control a roach in other modes.

        if theMode.cdd_master_hpc == theBank.name:
            Backend.__init__(self, theBank, theMode, theRoach, theValon, hpc_macs, unit_test)
            self.progdev()
            self.net_config()

            if self.mode.roach_kvpairs:
                self.write_registers(**self.mode.roach_kvpairs)

            self.reset_roach()
        else:
            Backend.__init__(self, theBank, theMode, None, None, None, unit_test)

        # This needs to happen on construction so that status monitors can
        # change their data buffer format.
        self.set_status(BACKEND="GUPPI")
        # The default switching in the Backend ctor is a static SIG, NOCAL, and no blanking

        self.max_databuf_size = 128  # in MBytes
        self.scale_p0 = 1.0
        self.scale_p1 = 1.0
        self.only_i = 0
        self.bandwidth = self.frequency
        self.dm = 0.0
        self.rf_frequency = 1430.0
        self.overlap = 0
        self.tfold = 1.0
        self.nbin = 256
        # Most all receivers are dual polarization
        self.nrcvr = 2
        self.nchan = self.mode.nchan  # total number of channels in the design, not per node
        self.num_nodes = 8
        self.feed_polarization = "LIN"
        self.obs_mode = "COHERENT_SEARCH"
        bank_names = {"A": 0, "B": 1, "C": 2, "D": 3, "E": 4, "F": 5, "G": 6, "H": 7}
        self.node_number = bank_names[self.bank.name[-1]]
        self.integration_time = 40.96e-6
        self.scan_length = 30.0
        if self.dibas_dir is not None:
            self.pardir = self.dibas_dir + "/etc/config"
        else:
            self.pardir = "/tmp"
        self.parfile = "example.par"
        self.datadir = "/lustre/gbtdata/JUNK"  # Needs integration with projectid
        # register set methods
        #        self.params["bandwidth"         ] = self.set_bandwidth
        self.params["dm"] = self.set_dm
        self.params["integration_time"] = self.set_integration_time
        self.params["nbin"] = self.set_nbin
        self.params["num_channels"] = self.set_nchannels
        self.params["obs_frequency"] = self.set_obs_frequency
        self.params["obs_mode"] = self.set_obs_mode
        self.params["par_file"] = self.set_par_file
        self.params["scale_p0"] = self.set_scale_P0
        self.params["scale_p1"] = self.set_scale_P1
        self.params["tfold"] = self.set_tfold
        self.params["only_i"] = self.set_only_i
        self.params["feed_polarization"] = self.setFeedPolarization
        self.params["_node_number"] = self.setNodeNumber

        # Fill-in defaults if they exist
        if "OBS_MODE" in self.mode.shmkvpairs.keys():
            self.set_param("obs_mode", self.mode.shmkvpairs["OBS_MODE"])
        if "ONLY_I" in self.mode.shmkvpairs.keys():
            self.set_param("only_i", int(self.mode.shmkvpairs["ONLY_I"]))

        if "SCALE_P0" in self.mode.roach_kvpairs.keys():
            self.set_param("scale_p0", float(self.mode.roach_kvpairs["SCALE_P0"]))
        if "SCALE_P1" in self.mode.roach_kvpairs.keys():
            self.set_param("scale_p1", float(self.mode.roach_kvpairs["SCALE_P1"]))

        if self.hpc_process is None:
            self.start_hpc()

        if self.cdd_master():
            self.arm_roach()
    def __init__(self, theBank, theMode, theRoach, theValon, hpc_macs, unit_test = False):
        """
        Creates an instance of the vegas internals.
        GuppiBackend( bank )
        Where bank is the instance of the player's Bank.
        """
        Backend.__init__(self, theBank, theMode, theRoach, theValon, hpc_macs, unit_test)
        # This needs to happen on construct so that status monitors can
        # switch their data buffer format
        self.progdev()
        self.net_config()

        if self.mode.roach_kvpairs:
            self.write_registers(**self.mode.roach_kvpairs)

        self.reset_roach()
        self.write_status(BACKEND="GUPPI")
        # The default switching in the Backend ctor is a static SIG, NOCAL, and no blanking

        # defaults
        self.max_databuf_size = 128 # in MBytes [Not sure where this ties in. Value from the manager]

        self.obs_mode = 'SEARCH'
        """Parameter 'obs_mode': GUPPI observation mode"""
        self.nchan = self.mode.nchan
        """Parameter 'nchan': Number of channels"""
        self.integration_time = 40.96E-6
        """Parameter 'integration_time': Lenght of integration, in seconds."""
        self.overlap = 0
        self.scale_i = 1
        self.scale_q = 1
        self.scale_u = 1
        self.scale_v = 1
        self.offset_i = 0
        self.offset_q = 0
        self.offset_u = 0
        self.offset_v = 0
        self.only_i = 0
        self.chan_dm = 0.0
        self.rf_frequency = 2000.0
        self.nbin = 256
        self.tfold = 1.0
        self.dm = 0.0
        # Almost all receivers are dual polarization
        self.nrcvr = 2
        self.feed_polarization = 'LIN'
        self.bandwidth = self.frequency

        if self.dibas_dir is not None:
           self.pardir = self.dibas_dir + '/etc/config'
        else:
            self.pardir = '/tmp'
        self.parfile = 'example.par'

#        self.params["bandwidth"         ] = self.set_bandwidth
        self.params["integration_time"  ] = self.set_integration_time
        self.params["nbin"              ] = self.set_nbin
        self.params["obs_frequency"     ] = self.set_obs_frequency
        self.params["obs_mode"          ] = self.set_obs_mode
        self.params["only_i"            ] = self.set_only_i
        self.params["scale"             ] = self.set_scale
        self.params["scale_i"           ] = self.set_scale_I
        self.params["scale_q"           ] = self.set_scale_Q
        self.params["scale_u"           ] = self.set_scale_U
        self.params["scale_v"           ] = self.set_scale_V
        self.params["tfold"             ] = self.set_tfold
        self.params["feed_polarization" ] = self.setFeedPolarization
        self.params["par_file"          ] = self.set_par_file
        self._fft_params_dep()

        if self.hpc_process is None:
            self.start_hpc()

        self.arm_roach()
示例#12
0
    def __init__(self,
                 theBank,
                 theMode,
                 theRoach,
                 theValon,
                 hpc_macs,
                 unit_test=False):
        """
        Creates an instance of the vegas internals.
        GuppiBackend( bank )
        Where bank is the instance of the player's Bank.
        """
        Backend.__init__(self, theBank, theMode, theRoach, theValon, hpc_macs,
                         unit_test)
        # This needs to happen on construct so that status monitors can
        # switch their data buffer format
        self.progdev()
        self.net_config()

        if self.mode.roach_kvpairs:
            self.write_registers(**self.mode.roach_kvpairs)

        self.reset_roach()
        self.write_status(BACKEND="GUPPI")
        # The default switching in the Backend ctor is a static SIG, NOCAL, and no blanking

        # defaults
        self.max_databuf_size = 128  # in MBytes [Not sure where this ties in. Value from the manager]

        self.obs_mode = 'SEARCH'
        """Parameter 'obs_mode': GUPPI observation mode"""
        self.nchan = self.mode.nchan
        """Parameter 'nchan': Number of channels"""
        self.integration_time = 40.96E-6
        """Parameter 'integration_time': Lenght of integration, in seconds."""
        self.overlap = 0
        self.scale_i = 1
        self.scale_q = 1
        self.scale_u = 1
        self.scale_v = 1
        self.offset_i = 0
        self.offset_q = 0
        self.offset_u = 0
        self.offset_v = 0
        self.only_i = 0
        self.chan_dm = 0.0
        self.rf_frequency = 2000.0
        self.nbin = 256
        self.tfold = 1.0
        self.dm = 0.0
        # Almost all receivers are dual polarization
        self.nrcvr = 2
        self.feed_polarization = 'LIN'
        self.bandwidth = self.frequency

        if self.dibas_dir is not None:
            self.pardir = self.dibas_dir + '/etc/config'
        else:
            self.pardir = '/tmp'
        self.parfile = 'example.par'

        #        self.params["bandwidth"         ] = self.set_bandwidth
        self.params["integration_time"] = self.set_integration_time
        self.params["nbin"] = self.set_nbin
        self.params["obs_frequency"] = self.set_obs_frequency
        self.params["obs_mode"] = self.set_obs_mode
        self.params["only_i"] = self.set_only_i
        self.params["scale"] = self.set_scale
        self.params["scale_i"] = self.set_scale_I
        self.params["scale_q"] = self.set_scale_Q
        self.params["scale_u"] = self.set_scale_U
        self.params["scale_v"] = self.set_scale_V
        self.params["tfold"] = self.set_tfold
        self.params["feed_polarization"] = self.setFeedPolarization
        self.params["par_file"] = self.set_par_file
        self._fft_params_dep()

        if self.hpc_process is None:
            self.start_hpc()

        self.arm_roach()
示例#13
0
    def __init__(self,
                 theBank,
                 theMode,
                 theRoach,
                 theValon,
                 hpc_macs,
                 unit_test=False):
        """
        Creates an instance of the class.
        """

        # Only one HPC Player will be controlling a roach in the CODD
        # mode family. Therefore figure out if we are the one; if not,
        # set the parameters 'theRoach' and 'theValon' to None, even if
        # this HPC does control a roach in other modes.

        if theMode.cdd_master_hpc == theBank.name:
            Backend.__init__(self, theBank, theMode, theRoach, theValon,
                             hpc_macs, unit_test)
            self.progdev()
            self.net_config()

            if self.mode.roach_kvpairs:
                self.write_registers(**self.mode.roach_kvpairs)

            self.reset_roach()
        else:
            Backend.__init__(self, theBank, theMode, None, None, None,
                             unit_test)

        # This needs to happen on construction so that status monitors can
        # change their data buffer format.
        self.set_status(BACKEND="GUPPI")
        # The default switching in the Backend ctor is a static SIG, NOCAL, and no blanking

        self.max_databuf_size = 128  # in MBytes
        self.scale_p0 = 1.0
        self.scale_p1 = 1.0
        self.only_i = 0
        self.bandwidth = self.frequency
        self.dm = 0.0
        self.rf_frequency = 1430.0
        self.overlap = 0
        self.tfold = 1.0
        self.nbin = 256
        # Most all receivers are dual polarization
        self.nrcvr = 2
        self.nchan = self.mode.nchan  # total number of channels in the design, not per node
        self.num_nodes = 8
        self.feed_polarization = 'LIN'
        self.obs_mode = 'COHERENT_SEARCH'
        bank_names = {
            'A': 0,
            'B': 1,
            'C': 2,
            'D': 3,
            'E': 4,
            'F': 5,
            'G': 6,
            'H': 7
        }
        self.node_number = bank_names[self.bank.name[-1]]
        self.integration_time = 40.96E-6
        self.scan_length = 30.0
        if self.dibas_dir is not None:
            self.pardir = self.dibas_dir + '/etc/config'
        else:
            self.pardir = '/tmp'
        self.parfile = 'example.par'
        self.datadir = '/lustre/gbtdata/JUNK'  # Needs integration with projectid
        # register set methods
        #        self.params["bandwidth"         ] = self.set_bandwidth
        self.params["dm"] = self.set_dm
        self.params["integration_time"] = self.set_integration_time
        self.params["nbin"] = self.set_nbin
        self.params["num_channels"] = self.set_nchannels
        self.params["obs_frequency"] = self.set_obs_frequency
        self.params["obs_mode"] = self.set_obs_mode
        self.params["par_file"] = self.set_par_file
        self.params["scale_p0"] = self.set_scale_P0
        self.params["scale_p1"] = self.set_scale_P1
        self.params["tfold"] = self.set_tfold
        self.params["only_i"] = self.set_only_i
        self.params["feed_polarization"] = self.setFeedPolarization
        self.params["_node_number"] = self.setNodeNumber

        # Fill-in defaults if they exist
        if 'OBS_MODE' in self.mode.shmkvpairs.keys():
            self.set_param('obs_mode', self.mode.shmkvpairs['OBS_MODE'])
        if 'ONLY_I' in self.mode.shmkvpairs.keys():
            self.set_param('only_i', int(self.mode.shmkvpairs['ONLY_I']))

        if 'SCALE_P0' in self.mode.roach_kvpairs.keys():
            self.set_param('scale_p0',
                           float(self.mode.roach_kvpairs['SCALE_P0']))
        if 'SCALE_P1' in self.mode.roach_kvpairs.keys():
            self.set_param('scale_p1',
                           float(self.mode.roach_kvpairs['SCALE_P1']))

        if self.hpc_process is None:
            self.start_hpc()

        if self.cdd_master():
            self.arm_roach()