def __init__(self, VS):
MyLogger.setSilent(["ClassJones", "ClassLOFARBeam"])
self.VS = VS
self.GD = copy.deepcopy(self.VS.GD)
self.DoCentralNorm = self.GD["Beam"]["CenterNorm"]
self.SmoothBeam = None
self.CheckCache()
if self.CacheValid:
MyLogger.setLoud(["ClassJones", "ClassLOFARBeam"])
return
#self.GD["Beam"]["CenterNorm"]=0
self.ListMS = self.VS.ListMS
self.MS = self.ListMS[0]
rac, decc = self.MS.radec
self.CoordMachine = ModCoord.ClassCoordConv(rac, decc)
self.CalcGrid()
#self.Padding=Padding
#self.SumJJsq=np.zeros((self.npix,self.npix,self.MS.Nchan),np.float64)
#self.SumWsq=np.zeros((1,self.MS.Nchan),np.float64)
self.StackedBeamDict = shared_dict.create("StackedBeamDict")
for iDir in range(self.NDir):
sd = self.StackedBeamDict.addSubdict(iDir)
sd.addSharedArray("SumJJsq", (self.VS.NFreqBands, ), np.float64)
sd.addSharedArray("SumWsq", (self.VS.NFreqBands, ), np.float64)
self.DicoJonesMachine = {}
for iMS, MS in enumerate(self.ListMS):
JonesMachine = ClassJones.ClassJones(self.GD, MS,
self.VS.FacetMachine)
JonesMachine.InitBeamMachine()
self.DicoJonesMachine[iMS] = JonesMachine
MyLogger.setLoud(["ClassJones", "ClassLOFARBeam"])
def StackBeam(self, ThisMSData, iDir):
self.StackedBeamDict.reload()
MyLogger.setSilent("ClassJones")
Dt = self.GD["Beam"]["DtBeamMin"] * 60.
JonesMachine = self.DicoJonesMachine[ThisMSData["iMS"]]
RAs, DECs = self.radec
times = ThisMSData["times"]
A0 = ThisMSData["A0"]
A1 = ThisMSData["A1"]
flags = ThisMSData["flags"]
W = ThisMSData["Weights"]
ChanToFreqBand = ThisMSData["ChanMapping"]
beam_times = np.array(
JonesMachine.BeamMachine.getBeamSampleTimes(times, quiet=True))
T2 = ClassTimeIt.ClassTimeIt()
T2.disable()
CurrentBeamITime = -1
# #print " Estimate beam in %i directions"%(RAs.size)
# MS=self.ListMS[ThisMSData["iMS"]]
# JonesMachine=ClassJones.ClassJones(self.GD,MS,self.VS.FacetMachine)
# JonesMachine.InitBeamMachine()
DicoBeam = JonesMachine.EstimateBeam(beam_times,
RAs[iDir:iDir + 1],
DECs[iDir:iDir + 1],
progressBar=False,
quiet=True)
T2.timeit("GetBeam 1")
#DicoBeam=JonesMachine.EstimateBeam(beam_times, RAs[0:10], DECs[0:10],progressBar=False)
#T2.timeit("GetBeam 10")
#print DicoBeam["Jones"].shape
NTRange = DicoBeam["t0"].size
#pBAR= ProgressBar(Title=" Mean Beam")
#pBAR.render(0, '%4i/%i' % (0,NTRange))
T = ClassTimeIt.ClassTimeIt("Stacking")
T.disable()
# DicoBeam["Jones"].shape = nt, nd, na, nch, _, _
for iTRange in range(DicoBeam["t0"].size):
t0 = DicoBeam["t0"][iTRange]
t1 = DicoBeam["t1"][iTRange]
J = np.abs(DicoBeam["Jones"][iTRange])
ind = np.where((times >= t0) & (times < t1))[0]
T.timeit("0")
A0s = A0[ind]
A1s = A1[ind]
fs = flags[ind]
Ws = W[ind]
MSnchan = Ws.shape[1]
T.timeit("1")
nd, na, nch, _, _ = J.shape
# ######################
# This call is slow
J0 = J[:, A0s, :, :, :]
J1 = J[:, A1s, :, :, :]
T.timeit("2")
# ######################
# J0=np.zeros((nd,A0s.size,nch,2,2),dtype=J.dtype)
# #T.timeit("1a")
# J0List=[J[:,A0s[i],:,:,:] for i in range(A0s.size)]
# #T.timeit("1b")
# J1=np.zeros((nd,A0s.size,nch,2,2),dtype=J.dtype)
# #T.timeit("1c")
# J1List=[J[:,A1s[i],:,:,:] for i in range(A0s.size)]
# #T.timeit("1d")
# for i in range(A0s.size):
# J0[:,i,:,:,:]=J0List[i]
# J1[:,i,:,:,:]=J1List[i]
# T.timeit("2b")
JJ = (J0[:, :, :, 0, 0] * J1[:, :, :, 0, 0] +
J0[:, :, :, 1, 1] * J1[:, :, :, 1, 1]) / 2.
T.timeit("3")
WW = Ws**2
T.timeit("4")
WW = WW.reshape((1, ind.size, MSnchan))
T.timeit("5")
JJsq = WW * JJ**2
T.timeit("6")
SumWsqThisRange = np.sum(JJsq, axis=1)
T.timeit("7")
#self.SumJJsq+=SumWsqThisRange.reshape((self.npix,self.npix,self.MS.Nchan))
#T.timeit("8")
SumWsq = np.sum(WW, axis=1)
#self.SumWsq+=SumWsq
for iBand in range(self.VS.NFreqBands):
indFreqBand, = np.where(ChanToFreqBand == iBand)
if indFreqBand.size == 0: continue
self.StackedBeamDict[iDir]["SumJJsq"][iBand] += np.sum(
SumWsqThisRange.reshape((MSnchan, ))[indFreqBand])
self.StackedBeamDict[iDir]["SumWsq"][iBand] += np.sum(
SumWsq.reshape((MSnchan, ))[indFreqBand])
#print SumWsq,self.SumWsq,self.SumJJsq.shape,J0.shape
T.timeit("9")
#NDone = iTRange+1
#intPercent = int(100 * NDone / float(NTRange))
#pBAR.render(intPercent, '%4i/%i' % (NDone, NTRange))
T2.timeit("Stack")
MyLogger.setLoud("ClassJones")