def exec_cells (mqs,node,cells):
if tile_size:
time_grid = Timba.array.array(cells.grid.time);
time_size = Timba.array.array(cells.cell_size.time);
domid = 0;
for i0 in range(0,len(time_grid),tile_size):
i1 = min(len(time_grid),i0+tile_size);
meq.add_cells_axis(cells,hiid('time'),grid=time_grid[i0:i1],cell_size=time_size[i0:i1]);
req = meq.request(cells,rqid=meq.requestid(domain_id=domid));
domid += 1;
mqs.execute(node,req,wait=False);
else:
req = meq.request(cells);
mqs.execute(node,req,wait=False);
def updateValues(self,pname):
if (self.lsm!=None) and (self.lsm.cells!=None) and\
(self.lsm.mqs!=None):
# create request object
my_request = meq.request(cells=self.lsm.cells, rqtype='ev')
# get the correct name from the sixpack object
punit=self.lsm.getPUnit(pname)
psixpack=punit.getSP()
my_name=''
if psixpack!=None and psixpack.ispoint():
my_name=psixpack.sixpack().name
elif psixpack!=None: # patch
my_name=psixpack.root().name
elif punit.sp!=None:
my_name='sixpack:q='+pname
my_args=meq.record(name=my_name, request=my_request)
my_result=self.lsm.mqs.meq('Node.execute', my_args,wait=True)
# update values only if no 'Fail has happened'
# if you try to create patches with 1 source, it will fail
self.setRA(my_result.result.vellsets[0])
self.setDec(my_result.result.vellsets[1])
self.setI(my_result.result.vellsets[2])
self.setQ(my_result.result.vellsets[3])
self.setU(my_result.result.vellsets[4])
self.setV(my_result.result.vellsets[5])
else:
print "Cannot update values: (cell,mqs)",self.lsm.cells,self.lsm.mqs
def _tdl_job_gain_solution_with_given_fluxes(mqs, parent):
msname = '3C343.MS'
inputrec = create_inputrec(msname, tile_size=100)
outputrec = create_outputrec()
source_list = create_initial_source_model()
station_list = list(range(1, 15))
patch_list = ['centre', 'edge']
print(inputrec)
print(outputrec)
solvables = []
for station in station_list:
for patch_name in patch_list:
solvables.append('JA:' + str(station) + ':' + patch_name + ':11')
solvables.append('JA:' + str(station) + ':' + patch_name + ':22')
pass
pass
print(solvables)
publish_node_state(mqs, 'JA:9:centre:11')
publish_node_state(mqs, 'solver')
solver_defaults = create_solver_defaults(solvable=solvables)
print(solver_defaults)
set_MAB_node_state(mqs, 'solver', solver_defaults)
req = meq.request()
req.input = record(ms=inputrec, python_init='MAB_read_msvis_header.py')
req.output = record(ms=outputrec)
mqs.execute('VisDataMux', req, wait=False)
pass
def _tdl_job_phase_solution_with_given_fluxes_centre(mqs, parent):
msname = '3C343.MS'
inputrec = create_inputrec(msname, tile_size=10)
outputrec = create_outputrec()
source_list = create_initial_source_model()
station_list = range(1,15)
patch_list = ['centre', 'edge']
print inputrec
print outputrec
solvables = []
for station in station_list[1:]:
solvables.append('JP:'+str(station)+':'+patch_list[0]+':11')
solvables.append('JP:'+str(station)+':'+patch_list[0]+':22')
pass
print solvables
publish_node_state(mqs, 'JP:9:centre:11')
publish_node_state(mqs, 'solver')
solver_defaults = create_solver_defaults(solvable=solvables)
print solver_defaults
set_MAB_node_state(mqs, 'solver', solver_defaults)
req = meq.request();
req.input = record(ms=inputrec,python_init='MAB_read_msvis_header.py');
req.output = record(ms=outputrec);
mqs.execute('VisDataMux',req,wait=False);
pass
def _test_forest (mqs,parent,**kwargs):
from Timba.Meq import meq
# run tests on the forest
cells = meq.cells(meq.domain(0,10,0,10),
num_freq=2000,num_time=2000);
mqs.execute('root',meq.request(cells));
def _test_forest (mqs,parent,**kwargs):
from Timba.Meq import meq
# run tests on the forest
cells = meq.cells(meq.domain(0,1,0,1),num_freq=20,num_time=10);
request = meq.request(cells,rqtype='ev');
mqs.execute('inj',request);
def exec_cells(mqs, node, cells):
if tile_size:
time_grid = Timba.array.array(cells.grid.time)
time_size = Timba.array.array(cells.cell_size.time)
domid = 0
for i0 in range(0, len(time_grid), tile_size):
i1 = min(len(time_grid), i0 + tile_size)
meq.add_cells_axis(cells,
hiid('time'),
grid=time_grid[i0:i1],
cell_size=time_size[i0:i1])
req = meq.request(cells, rqid=meq.requestid(domain_id=domid))
domid += 1
mqs.execute(node, req, wait=False)
else:
req = meq.request(cells)
mqs.execute(node, req, wait=False)
def _test_forest (mqs,parent,**kwargs):
"""test_forest() is a standard TDL name. When a forest script is
loaded by, e.g., the browser, and the "test" option is set to true,
this method is automatically called after define_forest() to run a
test on the forest. The 'mqs' argument is a meqserver proxy object.
""";
from Timba.Meq import meq
# run tests on the forest
cells = meq.cells(meq.domain(0,1,0,1),num_freq=6,num_time=4);
request = meq.request(cells,rqtype='ev');
mqs.meq('Node.Execute',record(name='x',request=request));
mqs.meq('Save.Forest',record(file_name='tile_test.forest.save'));
# execute request on solver
request = meq.request(cells,rqtype='ev');
# mqs.meq('Node.Set.Breakpoint',record(name='solver'));
# mqs.meq('Debug.Set.Level',record(debug_level=100));
a = mqs.meq('Node.Execute',record(name='reqseq',request=request),wait=False);
def _test_forest (mqs,parent):
from Timba.Meq import meq
# run tests on the forest
domain = meq.gen_domain(time=[0,7200],l=[0,math.pi/2],m=[0,2*math.pi],freq=[100,200]);
cells = meq.gen_cells(domain,num_time=10,num_l=100,num_m=100,num_freq=10);
request = meq.request(cells, rqtype='ev')
mqs.execute('emf1',request);
mqs.execute('emf2',request);
mqs.execute('cube',request);
def _tdl_job_8_evaluate_parms_over_reference_domain (mqs,parent):
"""Executes the 'verifier' node over the saved reference domain.
Assuming this is successful, you may examine the children of the verifier
node to compare past and current solutions.""";
if _reference_cells is None:
raise RuntimeError,"""Reference domain not loaded, please run a source
flux fit and save the domain.""";
req = meq.request(_reference_cells,rqtype='ev');
mqs.clearcache('solver');
mqs.execute('verifier',req,wait=False);
def _test_forest(mqs, parent, **kwargs):
"""test_forest() is a standard TDL name. When a forest script is
loaded by, e.g., the browser, and the "test" option is set to true,
this method is automatically called after define_forest() to run a
test on the forest. The 'mqs' argument is a meqserver proxy object.
"""
from Timba.Meq import meq
# run tests on the forest
cells = meq.cells(meq.domain(0, 1, 0, 1), num_freq=6, num_time=4)
request = meq.request(cells, rqtype='ev')
mqs.meq('Node.Execute', record(name='x', request=request))
mqs.meq('Save.Forest', record(file_name='tile_test.forest.save'))
# execute request on solver
request = meq.request(cells, rqtype='ev')
# mqs.meq('Node.Set.Breakpoint',record(name='solver'));
# mqs.meq('Debug.Set.Level',record(debug_level=100));
a = mqs.meq('Node.Execute',
record(name='reqseq', request=request),
wait=False)
def _test_forest (mqs,parent,wait=False,**kw):
print "=== Evaluating %g*t%+g for t=[%g,%g]"%(a,b,t0,t1);
print "=== Dummy values: %g %g"%(pipeline_test_constants.c0,pipeline_test_constants.c1);
from Timba.Meq import meq
# run tests on the forest
domain = meq.gen_domain(time=[t0,t1]);
cells = meq.gen_cells(domain,num_time=10);
request = meq.request(cells,rqtype='ev',new_domain=True);
res = mqs.execute('root',request,wait=wait);
if wait:
print res.result.vellsets[0].value;
def _test_forest (mqs,parent,wait=False,**kw):
print("=== Evaluating %g*t%+g for t=[%g,%g]"%(a,b,t0,t1));
print("=== Dummy values: %g %g"%(pipeline_test_constants.c0,pipeline_test_constants.c1));
from Timba.Meq import meq
# run tests on the forest
domain = meq.gen_domain(time=[t0,t1]);
cells = meq.gen_cells(domain,num_time=10);
request = meq.request(cells,rqtype='ev',new_domain=True);
res = mqs.execute('root',request,wait=wait);
if wait:
print(res.result.vellsets[0].value);
def _test_forest (mqs,parent,**kwargs):
"""test_forest() is a standard TDL name. When a forest script is
loaded by, e.g., the browser, and the "test" option is set to true,
this method is automatically called after define_forest() to run a
test on the forest. The 'mqs' argument is a meqserver proxy object.
""";
from Timba.Meq import meq
# run tests on the forest
dom = meq.gen_domain(time=(0,6),freq=(0,6),l=(0,6),m=(0,6));
cells = meq.gen_cells(dom,num_freq=20,num_time=20,num_l=20,num_m=20);
request = meq.request(cells,rqtype='ev');
mqs.meq('Node.Execute',record(name='mux',request=request),wait=False);
def _test_forest(mqs, parent, **kwargs):
"""test_forest() is a standard TDL name. When a forest script is
loaded by, e.g., the browser, and the "test" option is set to true,
this method is automatically called after define_forest() to run a
test on the forest. The 'mqs' argument is a meqserver proxy object.
"""
from Timba.Meq import meq
# run tests on the forest
dom = meq.gen_domain(time=(0, 6), freq=(0, 6), l=(0, 6), m=(0, 6))
cells = meq.gen_cells(dom, num_freq=20, num_time=20, num_l=20, num_m=20)
request = meq.request(cells, rqtype='ev')
mqs.meq('Node.Execute', record(name='mux', request=request), wait=False)
def doNewRequest(self):
newd = meq.domain(self.f0, self.f1, self.t0, self.t1);
newc = meq.cells(domain=newd, num_freq=self.fn, num_time=self.tn);
self._request = meq.request(cells=newc);
self.rid1 = self.rid1 + 1
self.rid2 = self.rid2 + 1
self.rid3 = self.rid3 + 1
self.rid4 = self.rid4 + 1
self._request.request_id = hiid(self.rid1, self.rid2, self.rid3, self.rid4);
if self._node:
cmd = record(nodeindex=self._node,request=self._request,get_state=True);
elif self._name:
cmd = record(name=self._name,request=self._request,get_state=True);
mqs().meq('Node.Execute',cmd,wait=False);
self._refresh();
def _test_forest (mqs, parent):
global my_sp
# create cells
f0 = 1200e6
f1 = 1600e6
t0 = 0.0
t1 = 1.0
nfreq = 3
ntime = 2
freqtime_domain = meq.domain(startfreq=f0, endfreq=f1, starttime=t0, endtime=t1);
my_cells =meq.cells(domain=freqtime_domain, num_freq=nfreq, num_time=ntime);
my_sp.display()
# send to kernel
request = meq.request(my_cells,eval_mode=1);
mqs.meq('Node.Execute',record(name='sixpack:q='+my_sp.label(),request=request));
def _test_forest(mqs, parent):
from Timba.Meq import meq
# run tests on the forest
domain = meq.gen_domain(time=[0, 7200],
l=[0, math.pi / 2],
m=[0, 2 * math.pi],
freq=[100, 200])
cells = meq.gen_cells(domain,
num_time=10,
num_l=100,
num_m=100,
num_freq=10)
request = meq.request(cells, rqtype='ev')
mqs.execute('emf1', request)
mqs.execute('emf2', request)
mqs.execute('cube', request)
def _tdl_job_1_source_flux_fit_no_calibration(mqs, parent, write=True):
"""This solves for the I and Q fluxes of the two sources,
over the entire MS.
"""
msname = '3C343.MS'
inputrec = create_inputrec(msname, tile_size=1500)
outputrec = create_outputrec()
source_list, extra_sources = create_initial_source_model(
extra_sources_filename='extra_sources.txt')
print(inputrec)
print(outputrec)
solvables = []
for source in source_list + extra_sources:
solvables.append('stokes:I:' + source.name)
solvables.append('stokes:Q:' + source.name)
pass
print(solvables)
for s in solvables:
publish_node_state(mqs, s)
pass
publish_node_state(mqs, 'solver')
solver_defaults = create_solver_defaults(solvable=solvables)
print(solver_defaults)
set_MAB_node_state(mqs, 'solver', solver_defaults)
# number of cells to resample to
# nc = 16
# set_MAB_node_state(mqs,'modres',record(num_cells=[nc,0]))
# for st in range(1,15):
# for src in ("3C343","3C343_1"):
# set_MAB_node_state(mqs,':'.join(('dft_modres',str(st),src)),record(num_cells=[1437,0]))
req = meq.request()
req.input = inputrec
if write:
req.output = outputrec
# parent=None means no GUI, so wait for request to complete
mqs.clearcache('verifier')
mqs.clearcache('VisDataMux')
mqs.execute('VisDataMux', req, wait=(parent is None))
pass
def _tdl_job_8_evaluate_parms_over_reference_domain (mqs,parent):
"""Executes the 'verifier' node over the saved reference domain.
Assuming this is successful, you may examine the children of the verifier
node to compare past and current solutions.""";
#if _reference_cells is None:
# raise RuntimeError,"""Reference domain not loaded, please run a source
#flux fit and save the domain.""";
#req = meq.request(_reference_cells,rqtype='ev');
#mqs.clearcache('solver');
#mqs.execute('verifier',req,wait=False);
msname = '3C343.MS'
inputrec = create_inputrec(msname,tile_size=1500)
req = meq.request();
req.input = inputrec;
mqs.clearcache('verifier');
mqs.clearcache('VisDataMux');
mqs.execute('verifier',req,wait=(parent is None));
pass
def _tdl_job_1_source_flux_fit_no_calibration(mqs,parent,write=True):
"""This solves for the I and Q fluxes of the two sources,
over the entire MS.
""";
msname = '3C343.MS'
inputrec = create_inputrec(msname,tile_size=1500)
outputrec = create_outputrec()
source_list,extra_sources = create_initial_source_model(extra_sources_filename='extra_sources.txt')
print inputrec
print outputrec
solvables = []
for source in source_list+extra_sources:
solvables.append('stokes:I:'+source.name)
solvables.append('stokes:Q:'+source.name)
pass
print solvables
for s in solvables:
publish_node_state(mqs, s)
pass
publish_node_state(mqs, 'solver')
solver_defaults = create_solver_defaults(solvable=solvables)
print solver_defaults
set_MAB_node_state(mqs, 'solver', solver_defaults)
# number of cells to resample to
# nc = 16
# set_MAB_node_state(mqs,'modres',record(num_cells=[nc,0]))
# for st in range(1,15):
# for src in ("3C343","3C343_1"):
# set_MAB_node_state(mqs,':'.join(('dft_modres',str(st),src)),record(num_cells=[1437,0]))
req = meq.request();
req.input = inputrec;
if write:
req.output = outputrec;
# parent=None means no GUI, so wait for request to complete
mqs.clearcache('verifier');
mqs.clearcache('VisDataMux');
mqs.execute('VisDataMux',req,wait=(parent is None));
pass
def _tdl_job_2_phase_solution_with_given_fluxes_all(mqs, parent, write=True):
msname = '3C343.MS'
inputrec = create_inputrec(msname, tile_size=100)
outputrec = create_outputrec()
station_list = list(range(1, 15))
patch_list = ['centre', 'edge']
print(inputrec)
print(outputrec)
solvables = []
for station in station_list:
for patch in patch_list:
solvables.append('JP:' + str(station) + ':' + patch + ':11')
solvables.append('JP:' + str(station) + ':' + patch + ':22')
pass
pass
print(solvables)
publish_node_state(mqs, 'JP:2:centre:11')
publish_node_state(mqs, 'JP:2:edge:11')
publish_node_state(mqs, 'solver')
publish_node_state(mqs, 'corrected:2:11')
solver_defaults = create_solver_defaults(solvable=solvables)
print(solver_defaults)
set_MAB_node_state(mqs, 'solver', solver_defaults)
set_MAB_node_state(mqs, 'modres', record(num_cells=[0, 1]))
for st in range(1, 15):
for src in ("3C343", "3C343_1"):
set_MAB_node_state(mqs, ':'.join(('dft_modres', str(st), src)),
record(num_cells=[0, 16]))
req = meq.request()
req.input = inputrec
# req.input.max_tiles = 3; # this can be used to shorten the processing, for testing
if write:
req.output = outputrec
mqs.clearcache('verifier')
mqs.clearcache('VisDataMux')
mqs.execute('VisDataMux', req, wait=(parent is None))
pass
def doNewRequest(self):
newd = meq.domain(self.f0, self.f1, self.t0, self.t1)
newc = meq.cells(domain=newd, num_freq=self.fn, num_time=self.tn)
self._request = meq.request(cells=newc)
self.rid1 = self.rid1 + 1
self.rid2 = self.rid2 + 1
self.rid3 = self.rid3 + 1
self.rid4 = self.rid4 + 1
self._request.request_id = hiid(self.rid1, self.rid2, self.rid3,
self.rid4)
if self._node:
cmd = record(nodeindex=self._node,
request=self._request,
get_state=True)
elif self._name:
cmd = record(name=self._name,
request=self._request,
get_state=True)
mqs().meq('Node.Execute', cmd, wait=False)
self._refresh()
def _tdl_job_2_phase_solution_with_given_fluxes_all(mqs,parent,write=True):
msname = '3C343.MS'
inputrec = create_inputrec(msname, tile_size=100)
outputrec = create_outputrec()
station_list = range(1,15)
patch_list = ['centre', 'edge']
print inputrec
print outputrec
solvables = []
for station in station_list:
for patch in patch_list:
solvables.append('JP:'+str(station)+':'+patch+':11')
solvables.append('JP:'+str(station)+':'+patch+':22')
pass
pass
print solvables
publish_node_state(mqs, 'JP:2:centre:11')
publish_node_state(mqs, 'JP:2:edge:11')
publish_node_state(mqs, 'solver')
publish_node_state(mqs, 'corrected:2:11')
solver_defaults = create_solver_defaults(solvable=solvables)
print solver_defaults
set_MAB_node_state(mqs, 'solver', solver_defaults)
set_MAB_node_state(mqs,'modres',record(num_cells=[0,1]))
for st in range(1,15):
for src in ("3C343","3C343_1"):
set_MAB_node_state(mqs,':'.join(('dft_modres',str(st),src)),record(num_cells=[0,16]))
req = meq.request();
req.input = inputrec;
# req.input.max_tiles = 3; # this can be used to shorten the processing, for testing
if write:
req.output = outputrec;
mqs.clearcache('verifier');
mqs.clearcache('VisDataMux');
mqs.execute('VisDataMux',req,wait=(parent is None));
pass
def _test_forest(mqs, parent):
global my_sp
# create cells
f0 = 1200e6
f1 = 1600e6
t0 = 0.0
t1 = 1.0
nfreq = 3
ntime = 2
freqtime_domain = meq.domain(startfreq=f0,
endfreq=f1,
starttime=t0,
endtime=t1)
my_cells = meq.cells(domain=freqtime_domain,
num_freq=nfreq,
num_time=ntime)
my_sp.display()
# send to kernel
request = meq.request(my_cells, eval_mode=1)
mqs.meq('Node.Execute',
record(name='sixpack:q=' + my_sp.label(), request=request))
def _tdl_job_1_source_flux_fit_no_calibration(mqs, parent, write=True):
"""This solves for the I and Q fluxes of the two sources,
over the entire MS.
"""
msname = '3C343.MS'
inputrec = create_inputrec(msname, tile_size=1500)
outputrec = create_outputrec()
source_list, extra_sources = create_initial_source_model(
extra_sources_filename='extra_sources.txt')
print(inputrec)
print(outputrec)
solvables = []
for source in source_list + extra_sources:
solvables.append('stokes:I:' + source.name)
solvables.append('stokes:Q:' + source.name)
pass
print(solvables)
for s in solvables:
publish_node_state(mqs, s)
pass
publish_node_state(mqs, 'solver')
solver_defaults = create_solver_defaults(solvable=solvables)
print(solver_defaults)
set_MAB_node_state(mqs, 'solver', solver_defaults)
req = meq.request()
req.input = inputrec
if write:
req.output = outputrec
# parent=None means no GUI, so wait for request to complete
mqs.clearcache('verifier')
mqs.clearcache('VisDataMux')
mqs.execute('VisDataMux', req, wait=(parent is None))
pass
def _tdl_job_3_gain_solution_with_given_fluxes(mqs, parent,write=True):
msname = '3C343.MS'
inputrec = create_inputrec(msname, tile_size=100)
outputrec = create_outputrec()
source_list = create_initial_source_model()
station_list = range(1,15)
patch_list = ['centre', 'edge']
print inputrec
print outputrec
solvables = []
for station in station_list:
for patch_name in patch_list:
solvables.append('JA:'+str(station)+':'+patch_name+':11')
solvables.append('JA:'+str(station)+':'+patch_name+':22')
pass
pass
print solvables
publish_node_state(mqs, 'JA:2:centre:11')
publish_node_state(mqs, 'JA:2:edge:11')
publish_node_state(mqs, 'solver')
publish_node_state(mqs, 'corrected:2:11')
solver_defaults = create_solver_defaults(solvable=solvables)
print solver_defaults
set_MAB_node_state(mqs, 'solver', solver_defaults)
req = meq.request();
req.input = inputrec;
# req.input.max_tiles = 1; # this can be used to shorten the processing, for testing
if write:
req.output = outputrec;
mqs.clearcache('verifier');
mqs.clearcache('VisDataMux');
mqs.execute('VisDataMux',req,wait=(parent is None));
pass
def _tdl_job_1_source_flux_fit_no_calibration(mqs,parent,write=True):
"""This solves for the I and Q fluxes of the two sources,
over the entire MS.
""";
msname = '3C343.MS'
inputrec = create_inputrec(msname,tile_size=1500)
outputrec = create_outputrec()
source_list,extra_sources = create_initial_source_model(extra_sources_filename='extra_sources.txt')
print inputrec
print outputrec
solvables = []
for source in source_list+extra_sources:
solvables.append('stokes:I:'+source.name)
solvables.append('stokes:Q:'+source.name)
pass
print solvables
for s in solvables:
publish_node_state(mqs, s)
pass
publish_node_state(mqs, 'solver')
solver_defaults = create_solver_defaults(solvable=solvables)
print solver_defaults
set_MAB_node_state(mqs, 'solver', solver_defaults)
req = meq.request();
req.input = inputrec;
if write:
req.output = outputrec;
# parent=None means no GUI, so wait for request to complete
mqs.clearcache('verifier');
mqs.clearcache('VisDataMux');
mqs.execute('VisDataMux',req,wait=(parent is None));
pass
def create_io_request(tiling=None):
req = meq.request()
req.input = create_inputrec(tiling)
if ms_write_flags or output_column is not None:
req.output = create_outputrec()
return req
def create_io_request(tiling=None):
req = meq.request()
req.input = create_inputrec(tiling)
if ms_write_flags or output_column is not None:
req.output = create_outputrec()
return req
def _test_forest(mqs, parent, **kwargs):
from Timba.Meq import meq
# run tests on the forest
cells = meq.cells(meq.domain(0, 10, 0, 10), num_freq=2000, num_time=2000)
mqs.execute('root', meq.request(cells))
def _test_forest (mqs,parent,**kwargs):
from Timba.Meq import meq
# run tests on the forest
cells = meq.cells(meq.domain(0,1,0,1),num_freq=20,num_time=10);
request = meq.request(cells,rqtype='ev');
mqs.execute('c',request);
