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
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,
}
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"
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)
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"
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
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,
}
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()
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()
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()
