def get_2x2_gains (self,datashape,expanded_dataslice,tiler=None):
tiler = tiler or self;
gainsdict = {};
gx = tiler.expand_subshape(self.gain[0],datashape,expanded_dataslice)
gy = tiler.expand_subshape(self.gain[1],datashape,expanded_dataslice)
for p in self._antennas:
gainsdict[p] = [ gx,meq.sca_vells(0),meq.sca_vells(0),gy ];
return gainsdict;
def get_2x2_gains (self,datashape,expanded_dataslice,tiler=None):
tiler = tiler or self;
gainsdict = {};
gx = tiler.expand_subshape(self.gain[0],datashape,expanded_dataslice)
gy = tiler.expand_subshape(self.gain[1],datashape,expanded_dataslice)
for p in self._antennas:
gainsdict[p] = [ gx,meq.sca_vells(0),meq.sca_vells(0),gy ];
return gainsdict;
def get_2x2_gains(self, datashape, expanded_dataslice, tiler=None):
tiler = tiler or self
gainsdict = {}
for p in self._antennas:
gx = self.gain.get((p, 0), self._unity)
gy = self.gain.get((p, 1), self._unity)
gainsdict[p] = [
tiler.expand_subshape(gx, datashape, expanded_dataslice),
meq.sca_vells(0),
meq.sca_vells(0),
tiler.expand_subshape(gy, datashape, expanded_dataslice)
]
return gainsdict
def get_2x2_gains (self,datashape,expanded_dataslice,tiler=None):
tiler = tiler or self;
gainsdict = {};
for p in self._antennas:
gx = self.gain.get((p,0),self._unity);
gy = self.gain.get((p,1),self._unity);
gainsdict[p] = [ tiler.expand_subshape(gx,datashape,expanded_dataslice),meq.sca_vells(0),meq.sca_vells(0),
tiler.expand_subshape(gy,datashape,expanded_dataslice) ];
return gainsdict;
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):
# 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):
# 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;
