def get_result(self, request):
global _albus_time
global _albus_rm
# get time and frequency for the tile
cells = request.cells
cells_shape = meq.shape(cells)
time = cells.grid.time
freq = cells.grid.freq
# use scipy to interpolate and get rm for MS times
f = interp1d(_albus_time, _albus_rm)
rotation_measure = f(time)
factor = LIGHT_SPEED / freq
out_array = meq.vells(cells_shape)
metre_sq = factor * factor
for j in range(cells_shape[0]):
angle = rotation_measure[j] * metre_sq
out_array[j, :] = angle
vellsets = []
vellsets.append(meq.vellset(out_array))
res = meq.result(cells=request.cells)
res.vellsets = vellsets
return res
def get_result (self,request):
global _albus_time
global _albus_rm
# get time and frequency for the tile
cells = request.cells
cells_shape = meq.shape(cells);
time = cells.grid.time
freq = cells.grid.freq
# use scipy to interpolate and get rm for MS times
f = interp1d(_albus_time, _albus_rm)
rotation_measure = f(time)
factor = LIGHT_SPEED / freq
out_array = meq.vells(cells_shape)
metre_sq = factor * factor
for j in range(cells_shape[0]):
angle = rotation_measure[j] * metre_sq
out_array[j,:] = angle
vellsets = [];
vellsets.append(meq.vellset(out_array))
res = meq.result(cells = request.cells)
res.vellsets = vellsets
return res
def get_result(self, request, lm, dlm=None, azel=None, pa=None):
# get list of VoltageBeams
vbs = self.init_voltage_beams()
# now, figure out the lm and time/freq grid
# lm may be a 2/3-vector or an Nx2/3 tensor
dims = getattr(lm, 'dims', [len(lm.vellsets)])
if len(dims) == 2 and dims[1] in (2, 3):
lm_list = [(lm.vellsets[i].value, lm.vellsets[i + 1].value)
for i in range(0, len(lm.vellsets), dims[1])]
tensor = True
elif len(dims) == 1 and dims[0] in (2, 3):
lm_list = [(lm.vellsets[0].value, lm.vellsets[1].value)]
tensor = False
else:
raise TypeError(
"expecting a 2/3-vector or an Nx2/3 matrix for child 0 (lm)")
nsrc = len(lm_list)
dl = dm = masklist = rotate = None
# pointing offsets are optional
if dlm is not None and len(dlm.vellsets) == 2:
dl, dm = dlm.vellsets[0].value, dlm.vellsets[1].value
# az/el is optional. If specified, then horizon masking is enabled
if azel is not None and len(azel.vellsets) > 1:
if len(azel.vellsets) != nsrc * 2:
raise TypeError("expecting a Nx2 matrix for child 2 (azel)")
masklist = [
azel.vellsets[i].value < 0 for i in range(1, nsrc * 2, 2)
]
# PA is optional. If specified, then this is the rotation angle for interpolation
if pa is not None:
if len(pa.vellsets) != 1:
raise TypeError("expecting a single value for child 3 (pa)")
rotate = pa.vellsets[0].value
# setup grid dict that will be passed to VoltageBeam.interpolate
grid = dict()
for axis in 'time', 'freq':
values = _cells_grid(lm, axis)
if values is None:
values = _cells_grid(request, axis)
if values is not None:
if numpy.isscalar(values) or values.ndim == 0:
values = [float(values)]
grid[axis] = values
# accumulate per-source EJones tensor
vellsets = self.interpolate_batch(lm_list,
dl,
dm,
grid,
vbs,
rotate=rotate,
masklist=masklist)
# create result object
cells = request.cells if vbs[0][0].hasFrequencyAxis() else getattr(
lm, 'cells', request.cells)
result = meq.result(vellsets[0], cells=cells)
result.vellsets[1:] = vellsets[1:]
result.dims = (nsrc, 2, 2) if tensor else (2, 2)
return result
def get_result (self,request,*children):
if len(children):
raise TypeError("this is a leaf node, no children expected!");
# make value of same shape as cells
cells = request.cells;
shape = meq.shape(cells);
print("cells shape is",shape);
value = meq.vells(shape);
# fill in random numbers with the given distribution
flat = value.ravel(); # 'flat' reference to array data
for i in range(flat.size):
flat[i] = self._generator(*self.distribution_args);
return meq.result(meq.vellset(value),cells);
def get_result (self,request,*children):
if len(children):
raise TypeError,"this is a leaf node, no children expected!";
# make value of same shape as cells
cells = request.cells;
shape = meq.shape(cells);
print "cells shape is",shape;
value = meq.vells(shape);
# fill in random numbers with the given distribution
flat = value.ravel(); # 'flat' reference to array data
for i in range(flat.size):
flat[i] = self._generator(*self.distribution_args);
return meq.result(meq.vellset(value),cells);
def get_result (self,request,lm,dlm=None,azel=None,pa=None):
# get list of VoltageBeams
vbs = self.init_voltage_beams();
# now, figure out the lm and time/freq grid
# lm may be a 2/3-vector or an Nx2/3 tensor
dims = getattr(lm,'dims',[len(lm.vellsets)]);
if len(dims) == 2 and dims[1] in (2,3):
lm_list = [ (lm.vellsets[i].value,lm.vellsets[i+1].value) for i in range(0,len(lm.vellsets),dims[1]) ];
tensor = True;
elif len(dims) == 1 and dims[0] in (2,3):
lm_list = [ (lm.vellsets[0].value,lm.vellsets[1].value) ];
tensor = False;
else:
raise TypeError,"expecting a 2/3-vector or an Nx2/3 matrix for child 0 (lm)";
nsrc = len(lm_list);
dl = dm = masklist = rotate = None;
# pointing offsets are optional
if dlm is not None and len(dlm.vellsets) == 2:
dl,dm = dlm.vellsets[0].value,dlm.vellsets[1].value;
# az/el is optional. If specified, then horizon masking is enabled
if azel is not None and len(azel.vellsets) > 1:
if len(azel.vellsets) != nsrc*2:
raise TypeError,"expecting a Nx2 matrix for child 2 (azel)";
masklist = [ azel.vellsets[i].value<0 for i in range(1,nsrc*2,2) ];
# PA is optional. If specified, then this is the rotation angle for interpolation
if pa is not None:
if len(pa.vellsets) != 1:
raise TypeError,"expecting a single value for child 3 (pa)";
rotate = pa.vellsets[0].value;
# setup grid dict that will be passed to VoltageBeam.interpolate
grid = dict();
for axis in 'time','freq':
values = _cells_grid(lm,axis);
if values is None:
values = _cells_grid(request,axis);
if values is not None:
if numpy.isscalar(values) or values.ndim == 0:
values = [float(values)];
grid[axis] = values;
# accumulate per-source EJones tensor
vellsets = self.interpolate_batch(lm_list,dl,dm,grid,vbs,rotate=rotate,masklist=masklist);
# create result object
cells = request.cells if vbs[0][0].hasFrequencyAxis() else getattr(lm,'cells',request.cells);
result = meq.result(vellsets[0],cells=cells);
result.vellsets[1:] = vellsets[1:];
result.dims = (nsrc,2,2) if tensor else (2,2);
return result;
def get_result (self,request,*children):
try:
if len(children) != 1:
raise TypeError,"one child expected";
res0 = children[0];
vellsets = [];
cells = res0.cells;
elevation = res0.vellsets[1].value;
shape = elevation.shape
# there's probably a numpy function for this
for i in range(shape[0]):
if elevation[i,0] < 0.0:
elevation[i,0] = 0.0
vellsets.append(meq.vellset(elevation))
res = meq.result(cells = cells)
res.vellsets = vellsets
return res
except:
traceback.print_exc();
raise;
def get_result(self, request, *children):
# get list of VoltageBeams
vbs, beam_max = self.init_voltage_beams()
# now, figure out the lm and time/freq grid
lm = children[0]
l = lm.vellsets[0].value
m = lm.vellsets[1].value
# setup grid dict that will be passed to VoltageBeam.interpolate
grid = dict(l=l, m=m)
for axis in 'time', 'freq':
values = _cells_grid(lm, axis)
if values is None:
values = _cells_grid(request, axis)
if values is not None:
grid[axis] = values
# interpolate
vellsets = []
for vb in vbs:
if vb is None:
vellsets.append(meq.vellset(meq.sca_vells(0.)))
else:
beam = vb.interpolate(freqaxis=self._freqaxis, **grid)
if self.normalize and beam_max != 0:
beam /= beam_max
vells = meq.complex_vells(beam.shape)
vells[...] = beam[...]
# make vells and return result
vellsets.append(meq.vellset(vells))
# create result object
cells = request.cells if vb.hasFrequencyAxis() else getattr(
lm, 'cells', None)
result = meq.result(vellsets[0], cells=cells)
# if more than one vellset, then we have 2x2
if len(vellsets) > 1:
result.vellsets[1:] = vellsets[1:]
result.dims = (2, 2)
return result
def get_result (self,request,*children):
try:
if len(children) != 3:
raise TypeError,"two children expected";
res0 = children[0];
vellsets = [];
cells = res0.cells;
result_vector = res0.vellsets[0].value;
shape = result_vector.shape
res1 = children[1];
min_random = res1.vellsets[0].value
res2 = children[2];
max_random = res2.vellsets[0].value
noise = random.uniform(min_random, max_random)
for i in range(shape[0]):
result_vector[i,0] = noise
vellsets.append(meq.vellset(result_vector))
res = meq.result(cells = cells)
res.vellsets = vellsets
return res
except:
traceback.print_exc();
raise;
def get_result (self,request,*children):
# get list of VoltageBeams
vbs,beam_max = self.init_voltage_beams();
# now, figure out the lm and time/freq grid
lm = children[0];
l = lm.vellsets[0].value;
m = lm.vellsets[1].value;
# setup grid dict that will be passed to VoltageBeam.interpolate
grid = dict(l=l,m=m);
for axis in 'time','freq':
values = _cells_grid(lm,axis);
if values is None:
values = _cells_grid(request,axis);
if values is not None:
grid[axis] = values;
# interpolate
vellsets = [];
hasfreq = False;
for vb in vbs:
if vb is None:
vellsets.append(meq.vellset(meq.sca_vells(0.)));
else:
beam = vb.interpolate(freqaxis=self._freqaxis,**grid);
hasfreq = hasfreq or vb.hasFrequencyAxis();
if self.normalize and beam_max != 0:
beam /= beam_max;
vells = meq.complex_vells(beam.shape);
vells[...] = beam[...];
# make vells and return result
vellsets.append(meq.vellset(vells));
# create result object
cells = request.cells if hasfreq else getattr(lm,'cells',None);
result = meq.result(vellsets[0],cells=cells);
result.vellsets[1:] = vellsets[1:];
result.dims = (2,len(vellsets)/2);
return result;
def get_result(self, request, *children):
# get list of VoltageBeams
vbs, beam_max = self.init_voltage_beams()
# now, figure out the lm and time/freq grid
# lm may be a 2/3-vector or an Nx2/3 tensor
lm = children[0]
dims = getattr(lm, 'dims', [len(lm.vellsets)])
if len(dims) == 2 and dims[1] in (2, 3):
nsrc, nlm = dims
tensor = True
elif len(dims) == 1 and dims[0] in (2, 3):
nsrc, nlm = 1, dims[0]
tensor = False
else:
print "child 0: %d vellsets, shape %s" % (len(
lm.vellsets), getattr(lm, 'dims', []))
raise TypeError, "expecting a 2/3-vector or an Nx2/3 matrix for child 0 (lm)"
# pointing offsets (child 1) are optional
if len(children) > 1:
dlm = children[1]
if len(dlm.vellsets) != 2:
raise TypeError, "expecting a 2-vector for child 1 (dlm)"
dl, dm = dlm.vellsets[0].value, dlm.vellsets[1].value
else:
dl = dm = 0
# setup grid dict that will be passed to VoltageBeam.interpolate
grid = dict()
for axis in 'time', 'freq':
values = _cells_grid(lm, axis)
if values is None:
values = _cells_grid(request, axis)
if values is not None:
grid[axis] = values
vellsets = []
# now loop over sources and interpolte
for isrc in range(nsrc):
# put l,m into grid
l, m = lm.vellsets[isrc * nlm].value, lm.vellsets[isrc * nlm +
1].value
l, dl = unite_shapes(l, dl)
m, dm = unite_shapes(m, dm)
grid['l'] = l - dl
grid['m'] = m - dm
# interpolate
for vb in vbs:
if vb is None:
vellsets.append(meq.vellset(meq.sca_vells(0.)))
else:
beam = vb.interpolate(freqaxis=self._freqaxis, **grid)
if self.normalize and beam_max != 0:
beam /= beam_max
vells = meq.complex_vells(beam.shape)
vells[...] = beam[...]
# make vells and return result
vellsets.append(meq.vellset(vells))
# create result object
cells = request.cells if vb.hasFrequencyAxis() else getattr(
lm, 'cells', None)
result = meq.result(vellsets[0], cells=cells)
if len(vellsets) > 1:
result.vellsets[1:] = vellsets[1:]
# vbs is either length 4 or length 1. If length 4, then result needs to have its dimensions
if len(vbs) > 1:
result.dims = (nsrc, 2, 2) if tensor else (2, 2)
return result
def get_result (self,request,*children):
try:
if len(children) < 1:
raise TypeError,"at least one child is expected";
# now, figure out the lms
# lm may be a 2/3-vector or an Nx2/3 tensor
lm = children[0];
dims = getattr(lm,'dims',[len(lm.vellsets)]);
if len(dims) == 2 and dims[1] in (2,3):
nsrc,nlm = dims;
tensor = True;
elif len(dims) == 1 and dims[0] in (2,3):
nsrc,nlm = 1,dims[0];
tensor = False;
else:
raise TypeError,"expecting a 2/3-vector or an Nx2/3 matrix for child 0 (lm)";
# pointing offsets (child 1) are optional
if len(children) > 1:
dlm = children[1];
if len(dlm.vellsets) != 2:
raise TypeError,"expecting a 2-vector for child 1 (dlm)";
dl,dm = dlm.vellsets[0].value,dlm.vellsets[1].value;
else:
dl = dm = None;
# turn freq into an array of the proper shape
freq = request.cells.grid.freq;
freqshape = [1]*(self._freqaxis+1);
freqshape[self._freqaxis] = len(freq);
freq = freq.reshape(freqshape);
# now compute the beam per source
vellsets = [];
for isrc in range(nsrc):
# get l/m for this sources
l,m = lm.vellsets[isrc*nlm].value,lm.vellsets[isrc*nlm+1].value;
# apply pointing offset, if given
if dl is not None:
dl,l,dm,m = unite_multiple_shapes(dl,l,dm,m);
l = l - dl
m = m - dm
l,m,fq = unite_multiple_shapes(l,m,freq);
# compute distance (scaled by frequency)
dist = fq*self.scale*numpy.sqrt(l*l+m*m);
# compute sinc function
E = meq.vells(dist.shape);
E[...] = numpy.sin(dist)/dist;
E[dist==0] = 1;
E[(l<0)|(m<0)] = 0;
vellsets.append(meq.vellset(E));
# form up result and return
result = meq.result(vellsets[0],cells=request.cells);
result.vellsets[1:] = vellsets[1:];
# result.dims = (nsrc,) if tensor else (1.);
return result;
#res0 = children[0];
#res1 = children[1];
#cells = res0.cells
#l = res0.vellsets[0].value;
#m = res1.vellsets[0].value;
#shape = l.shape
#for i in range(shape[0]):
#if l[i,0] < 0.0 or m[i,0] < 0.0:
#l[i,0] = 0.0
#else:
#dist = 265.667 * math.sqrt(l[i,0]*l[i,0] + m[i,0]*m[i,0])
## 265.667 is scaling factor to get 0.707 voltage response at 18 arcmin from pointing position (nominal FWHM=36arcmin at 1.4 GHz)
#l[i,0] = math.sin(dist) / dist
#vellsets = [];
#vellsets.append(meq.vellset(l))
#res = meq.result(cells=cells)
#res.vellsets = vellsets
#return res
except:
traceback.print_exc();
raise;
def get_result (self,request,*children):
# get list of VoltageBeams
vbs,beam_max = self.init_voltage_beams();
# now, figure out the lm and time/freq grid
# lm may be a 2/3-vector or an Nx2/3 tensor
lm = children[0];
dims = getattr(lm,'dims',[len(lm.vellsets)]);
if len(dims) == 2 and dims[1] in (2,3):
nsrc,nlm = dims;
tensor = True;
elif len(dims) == 1 and dims[0] in (2,3):
nsrc,nlm = 1,dims[0];
tensor = False;
else:
print "child 0: %d vellsets, shape %s"%(len(lm.vellsets),getattr(lm,'dims',[]));
raise TypeError,"expecting a 2/3-vector or an Nx2/3 matrix for child 0 (lm)";
# pointing offsets (child 1) are optional
if len(children) > 1:
dlm = children[1];
if len(dlm.vellsets) != 2:
raise TypeError,"expecting a 2-vector for child 1 (dlm)";
dl,dm = dlm.vellsets[0].value,dlm.vellsets[1].value;
else:
dl = dm = 0;
# setup grid dict that will be passed to VoltageBeam.interpolate
grid = dict();
for axis in 'time','freq':
values = _cells_grid(lm,axis);
if values is None:
values = _cells_grid(request,axis);
if values is not None:
grid[axis] = values;
vellsets = [];
# now loop over sources and interpolte
for isrc in range(nsrc):
# put l,m into grid
l,m = lm.vellsets[isrc*nlm].value,lm.vellsets[isrc*nlm+1].value;
l,dl = unite_shapes(l,dl);
m,dm = unite_shapes(m,dm);
grid['l'] = l - dl;
grid['m'] = m - dm;
# interpolate
for vb in vbs:
if vb is None:
vellsets.append(meq.vellset(meq.sca_vells(0.)));
else:
beam = vb.interpolate(freqaxis=self._freqaxis,**grid);
if self.normalize and beam_max != 0:
beam /= beam_max;
vells = meq.complex_vells(beam.shape);
vells[...] = beam[...];
# make vells and return result
vellsets.append(meq.vellset(vells));
# create result object
cells = request.cells if vb.hasFrequencyAxis() else getattr(lm,'cells',None);
result = meq.result(vellsets[0],cells=cells);
if len(vellsets) > 1:
result.vellsets[1:] = vellsets[1:];
# vbs is either length 4 or length 1. If length 4, then result needs to have its dimensions
if len(vbs) > 1:
result.dims = (nsrc,2,2) if tensor else (2,2);
return result;
def get_result (self,request,radec,radec0,dlm=None,azel=None,pa=None):
# get list of VoltageBeams
vbs = self.init_voltage_beams();
# now, figure out the radec and time/freq grid
# radec may be a 2/3-vector or an Nx2/3 tensor
dims = getattr(radec,'dims',[len(radec.vellsets)]);
if len(dims) == 2 and dims[1] == 2:
radec_list = [ (radec.vellsets[i].value,radec.vellsets[i+1].value) for i in range(0,len(radec.vellsets),dims[1]) ];
tensor = True;
elif len(dims) == 1 and dims[0] == 2:
radec_list = [ (radec.vellsets[0].value,radec.vellsets[1].value) ];
tensor = False;
else:
raise TypeError,"expecting a 2-vector or an Nx2 matrix for child 0 (radec)";
nsrc = len(radec_list);
# radec0 is a 2-vector
if len(radec0.vellsets) != 2:
raise TypeError,"expecting a 2-vector for child 1 (radec0)";
ra0,dec0 = radec0.vellsets[0].value,radec0.vellsets[1].value;
# get offsets and rotations
masklist = rotate = None;
# pointing offsets are optional -- apply them in here
if dlm is not None and len(dlm.vellsets) == 2:
dl,dm = dlm.vellsets[0].value,dlm.vellsets[1].value;
ra0,dl,dec0,dm = unite_multiple_shapes(ra0,dl,dec0,dm);
ra0,dec0 = self.lm_to_radec(dl,dm,ra0,dec0);
# az/el is optional. If specified, then horizon masking is enabled
if azel is not None and len(azel.vellsets) > 1:
if len(azel.vellsets) != nsrc*2:
raise TypeError,"expecting a Nx2 matrix for child 3 (azel)";
masklist = [ azel.vellsets[i].value<0 for i in range(1,nsrc*2,2) ];
# PA is optional. If specified, then this is the rotation angle for interpolation
if pa is not None:
if len(pa.vellsets) != 1:
raise TypeError,"expecting a single value for child 4 (pa)";
rotate = pa.vellsets[0].value;
thetaphi_list = [];
# precompute these -- may be functions of time if time-variable pointing is in effect
sind0,cosd0 = numpy.sin(dec0),numpy.cos(dec0);
# now go over all coordinates
for ra,dec in radec_list:
# This is based on the formula in Tigger/Coordinates.py, except we flip the sign of phi (by swapping ra0 and ra around),
# since rotation is meant to go N through W here
dra = numpy.subtract(*unite_shapes(ra,ra0));
cosra,sinra = numpy.cos(dra),numpy.sin(dra);
sind0x,sind,cosd0x,cosd,cosra,sinra = unite_multiple_shapes(sind0,numpy.sin(dec),cosd0,numpy.cos(dec),cosra,sinra);
theta = numpy.arccos(sind0x*sind + cosd0x*cosd*cosra);
phi = numpy.arctan2(-cosd*sinra,-cosd*sind0x*cosra+sind*cosd0x);
thetaphi_list.append((theta,phi));
dprint(2,"theta/phi",thetaphi_list);
# setup grid dict that will be passed to VoltageBeam.interpolate
grid = dict();
for axis in 'time','freq':
values = _cells_grid(radec,axis);
if values is None:
values = _cells_grid(request,axis);
if values is not None:
if numpy.isscalar(values) or values.ndim == 0:
values = [float(values)];
grid[axis] = values;
# accumulate per-source EJones tensor
vellsets = self.interpolate_batch(thetaphi_list,None,None,grid,vbs,thetaphi=True,rotate=rotate,masklist=masklist);
# create result object
cells = request.cells;
result = meq.result(vellsets[0],cells=cells);
result.vellsets[1:] = vellsets[1:];
result.dims = (len(radec_list),2,2) if tensor else (2,2);
return result;
def get_result(self, request, *children):
if len(children) < 2:
raise TypeError, "this is NOT a leaf node, At least 2 children expected!"
cells = request.cells
res = meq.result(None, cells)
Xp_table = [0, 0, 0]
# if necessary loop over time and other axis
# First get PiercePoints
res1 = children[1]
vs1 = res1.vellsets
# num_pierce_points each containing vector of length 2 or 3 (x,y(,z))
dims = res1.dims
vector_size = dims[1]
num_pp = dims[0]
x = []
for j in range(num_pp):
x.append([])
for i in range(vector_size):
x[j].append(0)
# x=[[0,]*vector_size,]*num_pp;
Xp_table = [0, ] * num_pp
for i in range(num_pp):
for j in range(vector_size):
x[i][j] = vs1[i * vector_size + j].value
shape = meq.shape(x[0][0])
grid_size = len(x[0][0])
# print "grid_size",grid_size;
# Then the parameters
res0 = children[0]
vs0 = res0.vellsets
# should be one per parameter
num_parms = len(vs0)
val0 = [0, ] * num_parms
par = [0, ] * num_parms
solvable = False
parmidx = range(num_parms)
# initialize result vector 1 field per pp;
# ph=[[0,]*grid_size,]*num_parms;
ph = []
for j in range(num_pp):
ph.append([])
for i in range(grid_size):
ph[j].append(0)
# if solvable they should have perturbed_values;
if vs0[0].has_key('perturbed_value'):
solvable = True
pert = [0] * num_parms
pt = []
perturbations = ()
spid_index = ()
# get spidindex
for i in range(num_parms):
spid_index += vs0[i].spid_index
# sort on spidindex
for i in range(num_parms):
for j in range(i):
if spid_index[i] < spid_index[parmidx[j]]:
newidx = i
for k in range(j, i + 1):
old = parmidx[k]
parmidx[k] = newidx
newidx = old
break
spid_index = ()
# 1 perturbed value per pp per paramter
# or the other way around???
for i in range(num_parms):
pt.append([])
for i2 in range(num_pp):
pt[i].append([])
for g in range(grid_size):
pt[i][i2].append(0)
# fill values sorted
for pn in range(num_parms):
pnidx = parmidx[pn]
val0[pn] = vs0[pnidx].value
par[pn] = val0[pn][0]
# use first value (in case of constant parms)
# assume single perturbation parms for the moment
if solvable:
pert[pn] = vs0[pnidx].perturbed_value[0]
spid_index += vs0[pnidx].spid_index
perturbations += vs0[pnidx].perturbations
# get U matrix
# Only if domain changed!!
for i in range(grid_size):
for j in range(vector_size):
for k in range(num_pp):
Xp_table[k] = x[k][j][i]
U, S, Ut, B = get_U(Xp_table, order=num_parms)
for pn in range(num_parms):
if len(val0[pn]) > i:
# incorrect check for freq/time dependendies
par[pn] = (val0[pn][i])
value = dot(U, par)
for v in range(num_pp):
ph[v][i] = value[v]
for v in range(num_parms):
if solvable:
old = par[v]
if len(pert[v]) > i:
par[v] = pert[v][i]
else:
par[v] = pert[v][0]
pval = dot(U, par)
par[v] = old
for v2 in range(num_pp):
pt[v][v2][i] = pval[v2]
vellsets = []
for v in range(num_pp):
value = meq.vells(shape)
ph[v] = array(ph[v])
ph[v].shape = shape
value[:] = ph[v]
vellsets.append(meq.vellset(value))
if solvable:
vellsets[v].perturbed_value = ()
for v2 in range(num_parms):
value = meq.vells(shape)
pt[v2][v] = array(pt[v2][v])
pt[v2][v].shape = shape
value[:] = pt[v2][v]
vellsets[v].perturbed_value += (value,)
vellsets[v].spid_index = spid_index
vellsets[v].perturbations = perturbations
res.vellsets = vellsets
# res.dims = [3,1];
# return meq.result(meq.vellset(value),cells);
# print "result",res
return res
def get_result(self, request, *children):
if len(children) < 2:
raise TypeError, "this is NOT a leaf node, At least 2 children expected!"
cells = request.cells
res = meq.result(None, cells)
Xp_table = [0, 0, 0]
# if necessary loop over time and other axis
# First get PiercePoints
res1 = children[1]
vs1 = res1.vellsets
# num_pierce_points each containing vector of length 2 or 3 (x,y(,z))
dims = res1.dims
vector_size = dims[1]
num_pp = dims[0]
x = []
for j in range(num_pp):
x.append([])
for i in range(vector_size):
x[j].append(0)
# x=[[0,]*vector_size,]*num_pp;
Xp_table = [
0,
] * num_pp
for i in range(num_pp):
for j in range(vector_size):
x[i][j] = vs1[i * vector_size + j].value
shape = meq.shape(x[0][0])
grid_size = len(x[0][0])
# print "grid_size",grid_size;
# Then the parameters
res0 = children[0]
vs0 = res0.vellsets
# should be one per parameter
num_parms = len(vs0)
val0 = [
0,
] * num_parms
par = [
0,
] * num_parms
solvable = False
parmidx = range(num_parms)
# initialize result vector 1 field per pp;
# ph=[[0,]*grid_size,]*num_parms;
ph = []
for j in range(num_pp):
ph.append([])
for i in range(grid_size):
ph[j].append(0)
# if solvable they should have perturbed_values;
if vs0[0].has_key('perturbed_value'):
solvable = True
pert = [0] * num_parms
pt = []
perturbations = ()
spid_index = ()
# get spidindex
for i in range(num_parms):
spid_index += vs0[i].spid_index
# sort on spidindex
for i in range(num_parms):
for j in range(i):
if spid_index[i] < spid_index[parmidx[j]]:
newidx = i
for k in range(j, i + 1):
old = parmidx[k]
parmidx[k] = newidx
newidx = old
break
spid_index = ()
# 1 perturbed value per pp per paramter
# or the other way around???
for i in range(num_parms):
pt.append([])
for i2 in range(num_pp):
pt[i].append([])
for g in range(grid_size):
pt[i][i2].append(0)
# fill values sorted
for pn in range(num_parms):
pnidx = parmidx[pn]
val0[pn] = vs0[pnidx].value
par[pn] = val0[pn][0]
# use first value (in case of constant parms)
# assume single perturbation parms for the moment
if solvable:
pert[pn] = vs0[pnidx].perturbed_value[0]
spid_index += vs0[pnidx].spid_index
perturbations += vs0[pnidx].perturbations
# get U matrix
# Only if domain changed!!
for i in range(grid_size):
for j in range(vector_size):
for k in range(num_pp):
Xp_table[k] = x[k][j][i]
U, S, Ut, B = get_U(Xp_table, order=num_parms)
for pn in range(num_parms):
if len(val0[pn]) > i:
# incorrect check for freq/time dependendies
par[pn] = (val0[pn][i])
value = dot(U, par)
for v in range(num_pp):
ph[v][i] = value[v]
for v in range(num_parms):
if solvable:
old = par[v]
if len(pert[v]) > i:
par[v] = pert[v][i]
else:
par[v] = pert[v][0]
pval = dot(U, par)
par[v] = old
for v2 in range(num_pp):
pt[v][v2][i] = pval[v2]
vellsets = []
for v in range(num_pp):
value = meq.vells(shape)
ph[v] = array(ph[v])
ph[v].shape = shape
value[:] = ph[v]
vellsets.append(meq.vellset(value))
if solvable:
vellsets[v].perturbed_value = ()
for v2 in range(num_parms):
value = meq.vells(shape)
pt[v2][v] = array(pt[v2][v])
pt[v2][v].shape = shape
value[:] = pt[v2][v]
vellsets[v].perturbed_value += (value, )
vellsets[v].spid_index = spid_index
vellsets[v].perturbations = perturbations
res.vellsets = vellsets
# res.dims = [3,1];
# return meq.result(meq.vellset(value),cells);
# print "result",res
return res
def get_result(self, request, *children):
if len(children) < 1:
raise TypeError(
"this is NOT a leaf node, At least 1 child with piercepoints expected!"
)
res1 = children[0]
vs1 = res1.vellsets
# pierce_points, vector of length 2 or 3 (x,y(,z))
vector_size = len(vs1)
# for now use fist two:
if vector_size < 2:
raise TypeError(
"vector size of child 1 too small, at leat x/y expected")
xv = vs1[0].value[0]
yv = vs1[1].value[0]
if vs1[0].has_field('shape'):
shapex = vs1[0].shape
else:
shapex = (1, )
if vs1[1].has_field('shape'):
shapey = vs1[1].shape
else:
shapey = (1, )
cells = request.cells
seg = cells.segments.time
# print '************************************************************'
# print cells
# print '------------------------------------------------------------'
# print seg
# print '************************************************************'
# the startt and endt are the timeslots when tiling is set > 1
if type(seg.start_index) == type(1):
startt = seg.start_index
endt = seg.end_index
else:
startt = seg.start_index[0]
endt = seg.end_index[-1]
# print '************************************************************'
# print startt, endt
# print '************************************************************'
# make time a lot smaller to prevent precision errors for int
# the actual value of the constant
time = cells.grid.time - self.starttime
if startt >= endt:
time = [
time,
]
val = []
for it in range(startt, endt + 1):
if shapex[0] > 1:
xv = vs1[0].value[it]
if shapey[0] > 1:
yv = vs1[1].value[it]
xshift = (time[it]) * self.speedx
yshift = (time[it]) * self.speedy
xn = (xv + xshift) / self.scale
yn = (yv + yshift) / self.scale
xn = int(xn) % (
self.grid_size
) # zorg dat xn een integer tussen 0 en grid_size is
yn = int(yn) % (
self.grid_size
) # zorg dat xn een integer tussen 0 en grid_size is
val.append(PhaseScreen.phasescreen[xn][yn] * self.amp_scale +
self.tec0)
# fill result
res = meq.result(None, cells)
# print startt,endt,seg,val;
val2 = meq.vells(shape=meq.shape(endt + 1, ))
val2[:] = val
vs = meq.vellset(val2)
res.vellsets = [
vs,
]
return res
def get_result(self, request, radec, radec0, dlm=None, azel=None, pa=None):
# get list of VoltageBeams
vbs = self.init_voltage_beams()
# now, figure out the radec and time/freq grid
# radec may be a 2/3-vector or an Nx2/3 tensor
dims = getattr(radec, 'dims', [len(radec.vellsets)])
if len(dims) == 2 and dims[1] == 2:
radec_list = [(radec.vellsets[i].value,
radec.vellsets[i + 1].value)
for i in range(0, len(radec.vellsets), dims[1])]
tensor = True
elif len(dims) == 1 and dims[0] == 2:
radec_list = [(radec.vellsets[0].value, radec.vellsets[1].value)]
tensor = False
else:
raise TypeError, "expecting a 2-vector or an Nx2 matrix for child 0 (radec)"
nsrc = len(radec_list)
# radec0 is a 2-vector
if len(radec0.vellsets) != 2:
raise TypeError, "expecting a 2-vector for child 1 (radec0)"
ra0, dec0 = radec0.vellsets[0].value, radec0.vellsets[1].value
# get offsets and rotations
masklist = rotate = None
# pointing offsets are optional -- apply them in here
if dlm is not None and len(dlm.vellsets) == 2:
dl, dm = dlm.vellsets[0].value, dlm.vellsets[1].value
ra0, dl, dec0, dm = unite_multiple_shapes(ra0, dl, dec0, dm)
ra0, dec0 = self.lm_to_radec(dl, dm, ra0, dec0)
# az/el is optional. If specified, then horizon masking is enabled
if azel is not None and len(azel.vellsets) > 1:
if len(azel.vellsets) != nsrc * 2:
raise TypeError, "expecting a Nx2 matrix for child 3 (azel)"
masklist = [
azel.vellsets[i].value < 0 for i in range(1, nsrc * 2, 2)
]
# PA is optional. If specified, then this is the rotation angle for interpolation
if pa is not None:
if len(pa.vellsets) != 1:
raise TypeError, "expecting a single value for child 4 (pa)"
rotate = pa.vellsets[0].value
thetaphi_list = []
# precompute these -- may be functions of time if time-variable pointing is in effect
sind0, cosd0 = numpy.sin(dec0), numpy.cos(dec0)
# now go over all coordinates
for ra, dec in radec_list:
# This is based on the formula in Tigger/Coordinates.py, except we flip the sign of phi (by swapping ra0 and ra around),
# since rotation is meant to go N through W here
dra = numpy.subtract(*unite_shapes(ra, ra0))
cosra, sinra = numpy.cos(dra), numpy.sin(dra)
sind0x, sind, cosd0x, cosd, cosra, sinra = unite_multiple_shapes(
sind0, numpy.sin(dec), cosd0, numpy.cos(dec), cosra, sinra)
theta = numpy.arccos(sind0x * sind + cosd0x * cosd * cosra)
phi = numpy.arctan2(-cosd * sinra,
-cosd * sind0x * cosra + sind * cosd0x)
thetaphi_list.append((theta, phi))
dprint(2, "theta/phi", thetaphi_list)
# setup grid dict that will be passed to VoltageBeam.interpolate
grid = dict()
for axis in 'time', 'freq':
values = _cells_grid(radec, axis)
if values is None:
values = _cells_grid(request, axis)
if values is not None:
if numpy.isscalar(values) or values.ndim == 0:
values = [float(values)]
grid[axis] = values
# accumulate per-source EJones tensor
vellsets = self.interpolate_batch(thetaphi_list,
None,
None,
grid,
vbs,
thetaphi=True,
rotate=rotate,
masklist=masklist)
# create result object
cells = request.cells
result = meq.result(vellsets[0], cells=cells)
result.vellsets[1:] = vellsets[1:]
result.dims = (len(radec_list), 2, 2) if tensor else (2, 2)
return result
def get_result (self,request,*children):
if len(children)<1:
raise TypeError,"this is NOT a leaf node, At least 1 child with piercepoints expected!";
res1=children[0];
vs1=res1.vellsets; #pierce_points, vector of length 2 or 3 (x,y(,z))
vector_size=len(vs1);
#for now use fist two:
if vector_size<2:
raise TypeError,"vector size of child 1 too small, at leat x/y expected";
xv=vs1[0].value[0];
yv=vs1[1].value[0];
if vs1[0].has_field('shape'):
shapex=vs1[0].shape;
else:
shapex=(1,);
if vs1[1].has_field('shape'):
shapey=vs1[1].shape;
else:
shapey=(1,);
cells=request.cells;
seg=cells.segments.time;
# print '************************************************************'
# print cells
# print '------------------------------------------------------------'
# print seg
# print '************************************************************'
# the startt and endt are the timeslots when tiling is set > 1
if type(seg.start_index) == type(1):
startt = seg.start_index;
endt = seg.end_index;
else:
startt = seg.start_index[0];
endt = seg.end_index[-1];
# print '************************************************************'
# print startt, endt
# print '************************************************************'
# make time a lot smaller to prevent precision errors for int
# the actual value of the constant
time=cells.grid.time - self.starttime;
if startt>=endt:
time=[time,];
val=[];
for it in range(startt,endt+1):
if shapex[0]>1:
xv=vs1[0].value[it];
if shapey[0]>1:
yv=vs1[1].value[it];
xshift=(time[it])*self.speedx;
yshift=(time[it])*self.speedy;
xn=(xv+xshift)/self.scale;
yn=(yv+yshift)/self.scale;
xn=int(xn)%(self.grid_size) # zorg dat xn een integer tussen 0 en grid_size is
yn=int(yn)%(self.grid_size) # zorg dat xn een integer tussen 0 en grid_size is
val.append(PhaseScreen.phasescreen[xn][yn]*self.amp_scale + self.tec0);
#fill result
res = meq.result(0,cells);
# print startt,endt,seg,val;
val2=meq.vells(shape=meq.shape(endt+1,));
val2[:]=val;
vs=meq.vellset(val2);
res.vellsets=[vs,]
return res;
def get_result(self, request, *children):
try:
if len(children) < 1:
raise TypeError, "at least one child is expected"
# now, figure out the lms
# lm may be a 2/3-vector or an Nx2/3 tensor
lm = children[0]
dims = getattr(lm, 'dims', [len(lm.vellsets)])
if len(dims) == 2 and dims[1] in (2, 3):
nsrc, nlm = dims
tensor = True
elif len(dims) == 1 and dims[0] in (2, 3):
nsrc, nlm = 1, dims[0]
tensor = False
else:
raise TypeError, "expecting a 2/3-vector or an Nx2/3 matrix for child 0 (lm)"
# pointing offsets (child 1) are optional
if len(children) > 1:
dlm = children[1]
if len(dlm.vellsets) != 2:
raise TypeError, "expecting a 2-vector for child 1 (dlm)"
dl, dm = dlm.vellsets[0].value, dlm.vellsets[1].value
else:
dl = dm = None
# turn freq into an array of the proper shape
freq = request.cells.grid.freq
freqshape = [1] * (self._freqaxis + 1)
freqshape[self._freqaxis] = len(freq)
freq = freq.reshape(freqshape)
# now compute the beam per source
vellsets = []
for isrc in range(nsrc):
# get l/m for this sources
l, m = lm.vellsets[isrc * nlm].value, lm.vellsets[isrc * nlm +
1].value
# apply pointing offset, if given
if dl is not None:
dl, l, dm, m = unite_multiple_shapes(dl, l, dm, m)
l = l - dl
m = m - dm
l, m, fq = unite_multiple_shapes(l, m, freq)
# compute distance (scaled by frequency)
dist = fq * self.scale * numpy.sqrt(l * l + m * m)
# compute sinc function
E = meq.vells(dist.shape)
E[...] = numpy.sin(dist) / dist
E[dist == 0] = 1
E[(l < 0) | (m < 0)] = 0
vellsets.append(meq.vellset(E))
# form up result and return
result = meq.result(vellsets[0], cells=request.cells)
result.vellsets[1:] = vellsets[1:]
# result.dims = (nsrc,) if tensor else (1.);
return result
#res0 = children[0];
#res1 = children[1];
#cells = res0.cells
#l = res0.vellsets[0].value;
#m = res1.vellsets[0].value;
#shape = l.shape
#for i in range(shape[0]):
#if l[i,0] < 0.0 or m[i,0] < 0.0:
#l[i,0] = 0.0
#else:
#dist = 265.667 * math.sqrt(l[i,0]*l[i,0] + m[i,0]*m[i,0])
## 265.667 is scaling factor to get 0.707 voltage response at 18 arcmin from pointing position (nominal FWHM=36arcmin at 1.4 GHz)
#l[i,0] = math.sin(dist) / dist
#vellsets = [];
#vellsets.append(meq.vellset(l))
#res = meq.result(cells=cells)
#res.vellsets = vellsets
#return res
except:
traceback.print_exc()
raise
