def InterpolTECTime(self, iTime):
GOut = NpShared.GiveArray("%sGOut" % IdSharedMem)
nt, nf, na, nd, _, _ = GOut.shape
TECArray = NpShared.GiveArray("%sTECArray" % IdSharedMem)
CPhaseArray = NpShared.GiveArray("%sCPhaseArray" % IdSharedMem)
for iDir in range(nd):
for iAnt in range(na):
GThis = TECToZ(TECArray[iTime, iDir, iAnt],
CPhaseArray[iTime, iDir, iAnt],
self.CentralFreqs.reshape((1, -1)))
self.GOut[iTime, :, iAnt, iDir, 0, 0] = GThis
self.GOut[iTime, :, iAnt, iDir, 1, 1] = GThis
def run(self):
while not self.kill_received:
try:
Job = self.work_queue.get()
except:
break
# ModelFacet=NpShared.GiveArray("%sModelFacet.%3.3i"%(self.IdSharedMem,iFacet))
# Grid=self.ClassImToGrid.setModelIm(ModelFacet)
# _=NpShared.ToShared("%sModelGrid.%3.3i"%(self.IdSharedMem,iFacet),Grid)
# self.result_queue.put({"Success":True})
iFacet = Job["iFacet"]
FacetDataCache = Job["FacetDataCache"]
Image = NpShared.GiveArray("%sModelImage" % (self.IdSharedMem))
#Grid,SumFlux=self.ClassImToGrid.GiveGridFader(Image,self.DicoImager,iFacet,NormImage)
#SharedMemName="%sSpheroidal.Facet_%3.3i"%(self.IdSharedMem,iFacet)
SPhe = NpShared.GiveArray(Job["SharedMemNameSphe"])
#print SharedMemName
SpacialWeight = NpShared.GiveArray("%sSpacialWeight.Facet_%3.3i" %
(FacetDataCache, iFacet))
NormImage = NpShared.GiveArray("%sNormImage" % self.IdSharedMem)
Im2Grid = ClassImToGrid(OverS=self.GD["ImagerCF"]["OverS"],
GD=self.GD)
Grid, SumFlux = Im2Grid.GiveModelTessel(Image,
self.DicoImager,
iFacet,
NormImage,
SPhe,
SpacialWeight,
ToGrid=True)
#ModelSharedMemName="%sModelImage.Facet_%3.3i"%(self.IdSharedMem,iFacet)
#NpShared.ToShared(ModelSharedMemName,ModelFacet)
_ = NpShared.ToShared(
"%sModelGrid.%3.3i" % (self.IdSharedMem, iFacet), Grid)
self.result_queue.put({
"Success": True,
"iFacet": iFacet,
"SumFlux": SumFlux
})
def EstimateThisTECTime(self, it, iAnt, iDir):
GOut = NpShared.GiveArray("%sGOut" % IdSharedMem)
g = GOut[it, :, iAnt, iDir, 0, 0]
g0 = g / np.abs(g)
W = np.ones(g0.shape, np.float32)
W[g == 1.] = 0
Z = self.Z
for iTry in range(5):
R = (g0.reshape((1, -1)) - Z) * W.reshape((1, -1))
Chi2 = np.sum(np.abs(R)**2, axis=1)
iTec = np.argmin(Chi2)
rBest = R[iTec]
if np.max(np.abs(rBest)) == 0: break
Sig = np.sum(np.abs(rBest * W)) / np.sum(W)
ind = np.where(np.abs(rBest * W) > 5. * Sig)[0]
if ind.size == 0: break
W[ind] = 0
# gz=TECToZ(TECGrid.ravel()[iTec],CPhase.ravel()[iTec],self.CentralFreqs)
# import pylab
# pylab.clf()
# pylab.subplot(2,1,1)
# pylab.scatter(self.CentralFreqs,rBest)
# pylab.scatter(self.CentralFreqs[ind],rBest[ind],color="red")
# pylab.subplot(2,1,2)
# pylab.scatter(self.CentralFreqs,rBest)
# pylab.scatter(self.CentralFreqs[ind],rBest[ind],color="red")
# pylab.draw()
# pylab.show()
# # ###########################
# print iAnt,iDir
# if iAnt==0: return
# f=np.linspace(self.CentralFreqs.min(),self.CentralFreqs.max(),100)
# ztec=TECToZ(TECGrid.ravel()[iTec],CPhase.ravel()[iTec],f)
# import pylab
# pylab.clf()
# pylab.subplot(1,2,1)
# pylab.scatter(self.CentralFreqs,np.abs(g),color="black")
# pylab.plot(self.CentralFreqs,np.abs(gz),ls=":",color="black")
# pylab.plot(self.CentralFreqs,np.abs(gz)-np.abs(g),ls=":",color="red")
# pylab.subplot(1,2,2)
# pylab.scatter(self.CentralFreqs,np.angle(g),color="black")
# pylab.plot(self.CentralFreqs,np.angle(gz),ls=":",color="black")
# pylab.plot(self.CentralFreqs,np.angle(gz)-np.angle(g),ls=":",color="red")
# #pylab.plot(f,np.angle(ztec),ls=":",color="black")
# pylab.ylim(-np.pi,np.pi)
# pylab.draw()
# pylab.show(False)
# pylab.pause(0.1)
# # ###############################
t0 = self.TECGrid.ravel()[iTec]
c0 = self.CPhase.ravel()[iTec]
gz = np.abs(g) * TECToZ(t0, c0, self.CentralFreqs)
return gz, t0, c0
def FitThisTEC(self, it):
nt, nch, na, nd, _, _ = self.Sols.G.shape
TECArray = NpShared.GiveArray("%sTECArray" % IdSharedMem)
CPhaseArray = NpShared.GiveArray("%sCPhaseArray" % IdSharedMem)
for iDir in range(nd):
# for it in range(nt):
Est = None
if it > 0:
E_TEC = TECArray[it - 1, iDir, :]
E_CPhase = CPhaseArray[it - 1, iDir, :]
Est = (E_TEC, E_CPhase)
gz, TEC, CPhase = self.FitThisTECTime(it, iDir, Est=Est)
GOut = NpShared.GiveArray("%sGOut" % IdSharedMem)
GOut[it, :, :, iDir, 0, 0] = gz
GOut[it, :, :, iDir, 1, 1] = gz
TECArray[it, iDir, :] = TEC
CPhaseArray[it, iDir, :] = CPhase
def __init__(self,
work_queue,
result_queue,
argsImToGrid=None,
IdSharedMem=None,
DicoImager=None,
FacetMode="Fader",
GD=None):
multiprocessing.Process.__init__(self)
self.work_queue = work_queue
self.result_queue = result_queue
self.kill_received = False
self.exit = multiprocessing.Event()
self.GD = GD
self.IdSharedMem = IdSharedMem
self.DicoImager = DicoImager
self.FacetMode = FacetMode
self.SharedMemNameSphe = "%sSpheroidal" % (self.IdSharedMem)
self.ifzfCF = NpShared.GiveArray(self.SharedMemNameSphe)
self.ClassImToGrid = ClassImToGrid(*argsImToGrid, ifzfCF=self.ifzfCF)
self.Image = NpShared.GiveArray("%sModelImage" % (self.IdSharedMem))
def GaussSmoothAmp(self, iAnt, iDir):
#print iAnt,iDir
GOut = NpShared.GiveArray("%sGOut" % IdSharedMem)
g = GOut[:, :, iAnt, iDir, 0, 0]
g0 = np.abs(g)
sg0 = scipy.ndimage.filters.gaussian_filter(g0, self.Amp_GaussKernel)
gz = sg0 * g / np.abs(g)
#print iAnt,iDir,GOut.shape,gz.shape
GOut[:, :, iAnt, iDir, 0, 0] = gz[:, :]
GOut[:, :, iAnt, iDir, 1, 1] = gz[:, :]
def FitThisPolyAmp(self, iDir):
nt, nch, na, nd, _, _ = self.Sols.G.shape
GOut = NpShared.GiveArray("%sGOut" % IdSharedMem)
g = GOut[:, :, :, iDir, 0, 0]
AmpMachine = ClassFitAmp.ClassFitAmp(
self.Sols.G[:, :, :, iDir, 0, 0],
self.CentralFreqs,
RemoveMedianAmp=self.RemoveMedianAmp)
gf = AmpMachine.doSmooth()
#print "Done %i"%iDir
gf = gf * g / np.abs(g)
GOut[:, :, :, iDir, 0, 0] = gf[:, :, :]
GOut[:, :, :, iDir, 1, 1] = gf[:, :, :]
def ClipThisDir(self, iDir):
nt, nch, na, nd, _, _ = self.Sols.G.shape
GOut = NpShared.GiveArray("%sGOut" % IdSharedMem)
# g=GOut[:,:,:,iDir,0,0]
AmpMachine = ClassClip.ClassClip(self.Sols.G[:, :, :, iDir, 0, 0],
self.CentralFreqs,
RemoveMedianAmp=self.RemoveMedianAmp)
gf = AmpMachine.doClip()
GOut[:, :, :, iDir, 0, 0] = gf[:, :, :]
AmpMachine = ClassClip.ClassClip(self.Sols.G[:, :, :, iDir, 1, 1],
self.CentralFreqs,
RemoveMedianAmp=self.RemoveMedianAmp)
gf = AmpMachine.doClip()
GOut[:, :, :, iDir, 1, 1] = gf[:, :, :]
def InterpolAmpTime(self, iTime):
GOut = NpShared.GiveArray("%sGOut" % IdSharedMem)
nt, nf, na, nd, _, _ = GOut.shape
for iChan in range(nf):
D = self.DicoFreqWeights[iChan]
for iDir in range(nd):
for iAnt in range(na):
if D["Type"] == "Dual":
i0, i1 = D["Index"]
c0, c1 = D["Coefs"]
g = c0 * np.abs(self.Sols0.G[
iTime, i0, iAnt, iDir, 0, 0]) + c1 * np.abs(
self.Sols0.G[iTime, i1, iAnt, iDir, 0, 0])
else:
i0 = D["Index"]
g = np.abs(self.Sols0.G[iTime, i0, iAnt, iDir, 0, 0])
self.GOut[iTime, iChan, iAnt, iDir, 0, 0] *= g
self.GOut[iTime, iChan, iAnt, iDir, 1, 1] *= g
def FitThisAmpTimePoly(self, it, iAnt, iDir):
GOut = NpShared.GiveArray("%sGOut" % IdSharedMem)
g = GOut[it, :, iAnt, iDir, 0, 0]
g0 = np.abs(g)
W = np.ones(g0.shape, np.float32)
W[g0 == 1.] = 0
if np.count_nonzero(W) < self.Amp_PolyOrder * 3: return
for iTry in range(5):
if np.max(W) == 0: return
z = np.polyfit(self.CentralFreqs, g0, self.Amp_PolyOrder, w=W)
p = np.poly1d(z)
gz = p(self.CentralFreqs) * g / np.abs(g)
rBest = (g0 - gz)
if np.max(np.abs(rBest)) == 0: break
Sig = np.sum(np.abs(rBest * W)) / np.sum(W)
ind = np.where(np.abs(rBest * W) > 5. * Sig)[0]
if ind.size == 0: break
W[ind] = 0
GOut[it, :, iAnt, iDir, 0, 0] = gz
GOut[it, :, iAnt, iDir, 1, 1] = gz
def Evolve0(self, Gin, Pa, kapa=1.):
done = NpShared.GiveArray("%sSolsArray_done" % self.IdSharedMem)
indDone = np.where(done == 1)[0]
#print kapa
#print type(NpShared.GiveArray("%sSharedCovariance_Q"%self.IdSharedMem))
Q = kapa * NpShared.GiveArray(
"%sSharedCovariance_Q" % self.IdSharedMem)[self.iChanSol,
self.iAnt]
#print indDone.size
#print "mean",np.mean(Q)
##########
# Ptot=Pa+Q
# #nt,_,_,_=Gin.shape
# #print Gin.shape
# g=Gin
# gg=g.ravel()
# #gg+=(np.random.randn(*gg.shape)+1j*np.random.randn(*gg.shape))*np.sqrt(np.diag(Ptot))/np.sqrt(2.)
# # print Pa.shape,Q.shape
# # print np.diag(Pa)
# # print np.diag(Q)
# # print np.diag(Ptot)
# # print
# return Ptot
##############
# return Pa+Q
if indDone.size < 2: return Pa + Q
# #########################
# take scans where no solve has been done into account
G = NpShared.GiveArray("%sSolsArray_G" %
self.IdSharedMem)[indDone][:, self.iChanSol,
self.iAnt, :, 0, 0]
Gm = np.mean(G, axis=-1)
dG = Gm[:-1] - Gm[1:]
done0 = NpShared.GiveArray("%sSolsArray_done" % self.IdSharedMem)
done1 = np.zeros((done0.size, ), int)
done1[1:1 + dG.size] = (dG != 0)
done1[0] = 1
done = (done0 & done1)
indDone = np.where(done == 1)[0]
if indDone.size < 2: return Pa + Q
# #########################
t0 = NpShared.GiveArray("%sSolsArray_t0" % self.IdSharedMem)[indDone]
t1 = NpShared.GiveArray("%sSolsArray_t1" % self.IdSharedMem)[indDone]
tm = NpShared.GiveArray("%sSolsArray_tm" % self.IdSharedMem)[indDone]
G = NpShared.GiveArray("%sSolsArray_G" %
self.IdSharedMem)[indDone][:, self.iChanSol,
self.iAnt, :, :, :]
nt, nd, npolx, npoly = G.shape
#if nt<=self.StepStart: return None
if nt > self.BufferNPoints:
G = G[-self.BufferNPoints::, :, :, :]
tm = tm[-self.BufferNPoints::]
G = G.copy()
nt, _, _, _ = G.shape
NPars = nd * npolx * npoly
G = G.reshape((nt, NPars))
F = np.ones((NPars, ), G.dtype)
PaOut = np.zeros_like(Pa)
tm0 = tm.copy()
tm0 = np.abs(tm - tm[-1])
w = np.exp(-tm0 / self.WeigthScale)
w /= np.sum(w)
w = w[::-1]
for iPar in range(NPars):
#g_t=G[:,iPar][-1]
#ThisG=Gin.ravel()[iPar]
#ratio=1.+(ThisG-g_t)/g_t
g_t = G[:, iPar]
ThisG = Gin.ravel()[iPar]
#ratio=1.+np.std(g_t)
#norm=np.max([np.abs(np.mean(g_t))
#ratio=np.cov(g_t)/Pa[iPar,iPar]
#print np.cov(g_t),Pa[iPar,iPar],ratio
ratio = np.abs(ThisG - np.mean(g_t)) / np.sqrt(Pa[iPar, iPar] +
Q[iPar, iPar])
#ratio=np.abs(g_t[-1]-np.mean(g_t))/np.sqrt(Pa[iPar,iPar])#+Q[iPar,iPar]))
diff = np.sum(w * (ThisG - g_t)) / np.sum(w)
ratio = np.abs(diff) / np.sqrt(Pa[iPar, iPar] + Q[iPar, iPar])
F[iPar] = 1. #ratio#/np.sqrt(2.)
diff = ThisG - g_t[-1] #np.sum(w*(ThisG-g_t))/np.sum(w)
#PaOut[iPar,iPar]=np.abs(diff)**2+Pa[iPar,iPar]+Q[iPar,iPar]
PaOut[iPar,
iPar] = np.abs(diff)**2 + Pa[iPar, iPar] + Q[iPar, iPar]
# Q=np.diag(np.ones((PaOut.shape[0],)))*(self.sigQ**2)
PaOut = F.reshape((NPars, 1)) * Pa * F.reshape((1, NPars)).conj() + Q
#print(F)
#print(Q)
# stop
return PaOut
def Evolve(self, xEst, Pa, CurrentTime):
done = NpShared.GiveArray("%sSolsArray_done" % self.IdSharedMem)
indDone = np.where(done == 1)[0]
Q = NpShared.GiveArray("%sSharedCovariance_Q" %
self.IdSharedMem)[self.iAnt]
t0 = NpShared.GiveArray("%sSolsArray_t0" % self.IdSharedMem)[indDone]
t1 = NpShared.GiveArray("%sSolsArray_t1" % self.IdSharedMem)[indDone]
tm = NpShared.GiveArray("%sSolsArray_tm" % self.IdSharedMem)[indDone]
G = NpShared.GiveArray(
"%sSolsArray_G" % self.IdSharedMem)[indDone][:, self.iAnt, :, :, :]
nt, nd, npol, _ = G.shape
if nt <= self.StepStart: return None, None
if nt > self.BufferNPoints:
G = G[-nt::, :, :, :]
tm = tm[-nt::]
G = G.copy()
tm0 = tm.copy()
tm0 = tm - tm[-1]
ThisTime = CurrentTime - tm[-1]
nt, _, _, _ = G.shape
NPars = nd * npol * npol
G = G.reshape((nt, NPars))
Gout = np.zeros((nd * npol * npol), dtype=G.dtype)
Gout[:] = G[-1]
F = np.ones((NPars, ), G.dtype)
if self.DoEvolve:
if self.WeightType == "exp":
w = np.exp(-tm0 / self.WeigthScale)
w /= np.sum(w)
w = w[::-1]
dx = 1e-6
for iPar in range(NPars):
g_t = G[:, iPar]
g_r = g_t.real.copy()
g_i = g_t.imag.copy()
####
z_r0 = np.polyfit(tm0, g_r, self.order, w=w)
z_i0 = np.polyfit(tm0, g_i, self.order, w=w)
poly_r = np.poly1d(z_r0)
poly_i = np.poly1d(z_i0)
x0_r = poly_r(ThisTime)
x0_i = poly_i(ThisTime)
Gout[iPar] = x0_r + 1j * x0_i
####
g_r[-1] += dx
g_i[-1] += dx
z_r1 = np.polyfit(tm0, g_r, self.order, w=w)
z_i1 = np.polyfit(tm0, g_i, self.order, w=w)
poly_r = np.poly1d(z_r1)
poly_i = np.poly1d(z_i1)
x1_r = poly_r(ThisTime)
x1_i = poly_i(ThisTime)
# dz=((x0_r-x1_r)+1j*(x0_i-x1_i))/dx
xlast = G[-1][iPar]
dz = ((x0_r - xlast.real) + 1j *
(x0_i - xlast.imag)) / np.sqrt(
(Pa[iPar, iPar] + Q[iPar, iPar]))
F[iPar] = dz / np.sqrt(2.)
# if self.iAnt==0:
# xx=np.linspace(tm0.min(),tm0.max(),100)
# pylab.clf()
# pylab.plot(tm0, g_r)
# pylab.plot(xx, poly_r(xx))
# pylab.scatter([ThisTime],[x1_r])
# pylab.draw()
# pylab.show(False)
# pylab.pause(0.1)
# print F
# if self.iAnt==0:
# pylab.clf()
# pylab.imshow(np.diag(F).real,interpolation="nearest")
# pylab.draw()
# pylab.show(False)
# pylab.pause(0.1)
#Pa=P[self.iAnt]
PaOut = np.zeros_like(Pa)
#Q=np.diag(np.ones((PaOut.shape[0],)))*(self.sigQ**2)
PaOut = F.reshape((NPars, 1)) * Pa * F.reshape((1, NPars)).conj() + Q
Gout = Gout.reshape((nd, npol, npol))
print(np.diag(PaOut))
return Gout, PaOut
def run(self):
while not self.kill_received:
try:
Row0, Row1 = self.work_queue.get()
except:
break
D = NpShared.SharedToDico("%sDicoMemChunk" % self.IdSharedMem)
DicoData = {}
DicoData["data"] = D["data"][Row0:Row1]
DicoData["flags"] = D["flags"][Row0:Row1]
DicoData["A0"] = D["A0"][Row0:Row1]
DicoData["A1"] = D["A1"][Row0:Row1]
DicoData["times"] = D["times"][Row0:Row1]
DicoData["uvw"] = D["uvw"][Row0:Row1]
DicoData["freqs"] = D["freqs"]
DicoData["dfreqs"] = D["dfreqs"]
DicoData["freqs_full"] = D["freqs_full"]
DicoData["dfreqs_full"] = D["dfreqs_full"]
# DicoData["UVW_dt"]=D["UVW_dt"]
DicoData["infos"] = D["infos"]
#DicoData["IndRows_All_UVW_dt"]=D["IndRows_All_UVW_dt"]
#DicoData["All_UVW_dt"]=D["All_UVW_dt"]
if self.DoSmearing and "T" in self.DoSmearing:
DicoData["UVW_dt"] = D["UVW_dt"][Row0:Row1]
# DicoData["IndexTimesThisChunk"]=D["IndexTimesThisChunk"][Row0:Row1]
# it0=np.min(DicoData["IndexTimesThisChunk"])
# it1=np.max(DicoData["IndexTimesThisChunk"])+1
# DicoData["UVW_RefAnt"]=D["UVW_RefAnt"][it0:it1,:,:]
if "W" in D.keys():
DicoData["W"] = D["W"][Row0:Row1]
if "resid" in D.keys():
DicoData["resid"] = D["resid"][Row0:Row1]
ApplyTimeJones = NpShared.SharedToDico("%sApplyTimeJones" %
self.IdSharedMem)
#JonesMatrices=ApplyTimeJones["Beam"]
#print ApplyTimeJones["Beam"].flags
ApplyTimeJones["Map_VisToJones_Time"] = ApplyTimeJones[
"Map_VisToJones_Time"][Row0:Row1]
PM = ClassPredict(NCPU=1,
DoSmearing=self.DoSmearing,
BeamAtFacet=self._BeamAtFacet)
#print DicoData.keys()
if self.Mode == "Predict":
PredictData = PM.predictKernelPolCluster(
DicoData, self.SM, ApplyTimeJones=ApplyTimeJones)
PredictArray = NpShared.GiveArray("%sPredictData" %
(self.IdSharedMem))
PredictArray[Row0:Row1] = PredictData[:]
elif self.Mode == "ApplyCal":
PM.ApplyCal(DicoData, ApplyTimeJones, self.iCluster)
elif self.Mode == "DDECovariance":
PM.GiveCovariance(DicoData, ApplyTimeJones, self.SM)
elif self.Mode == "ResidAntCovariance":
PM.GiveResidAntCovariance(DicoData, ApplyTimeJones, self.SM)
self.result_queue.put(True)
def FitThisTECTime(self, it, iDir, Est=None):
GOut = NpShared.GiveArray("%sGOut" % IdSharedMem)
nt, nch, na, nd, _, _ = self.Sols.G.shape
T = ClassTimeIt("CrossFit")
T.disable()
Mode = ["TEC", "CPhase"]
Mode = ["TEC"]
TEC0CPhase0 = np.zeros((len(Mode), na), np.float32)
for iAnt in range(na):
_, t0, c0 = self.EstimateThisTECTime(it, iAnt, iDir)
TEC0CPhase0[0, iAnt] = t0
if "CPhase" in Mode:
TEC0CPhase0[1, iAnt] = c0
T.timeit("init")
# ######################################
# Changing method
#print "!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
#print it,iDir
TECMachine = ClassFitTEC.ClassFitTEC(self.Sols.G[it, :, :, iDir, 0, 0],
self.CentralFreqs,
Tol=5.e-2,
Mode=Mode)
TECMachine.setX0(TEC0CPhase0.ravel())
X = TECMachine.doFit()
if "CPhase" in Mode:
TEC, CPhase = X.reshape((len(Mode), na))
else:
TEC, = X.reshape((len(Mode), na))
CPhase = np.zeros((1, na), np.float32)
TEC -= TEC[0]
CPhase -= CPhase[0]
GThis = np.abs(GOut[it, :, :, iDir, 0, 0]).T * TECToZ(
TEC.reshape((-1, 1)), CPhase.reshape(
(-1, 1)), self.CentralFreqs.reshape((1, -1)))
T.timeit("done %i %i %i" % (it, iDir, TECMachine.Current_iIter))
return GThis.T, TEC, CPhase
# ######################################
G = GOut[it, :, :, iDir, 0, 0].T.copy()
if self.CrossMode:
A0, A1 = np.mgrid[0:na, 0:na]
gg_meas = G[A0.ravel(), :] * G[A1.ravel(), :].conj()
gg_meas_reim = np.array([gg_meas.real,
gg_meas.imag]).ravel()[::self.incrCross]
else:
self.incrCross = 1
A0, A1 = np.mgrid[0:na], None
gg_meas = G[A0.ravel(), :]
gg_meas_reim = np.array([gg_meas.real,
gg_meas.imag]).ravel()[::self.incrCross]
# for ibl in range(gg_meas.shape[0])[::-1]:
# import pylab
# pylab.clf()
# pylab.subplot(2,1,1)
# pylab.scatter(self.CentralFreqs,np.abs(gg_meas[ibl]))
# pylab.ylim(0,5)
# pylab.subplot(2,1,2)
# pylab.scatter(self.CentralFreqs,np.angle(gg_meas[ibl]))
# pylab.ylim(-np.pi,np.pi)
# pylab.draw()
# pylab.show(False)
# pylab.pause(0.1)
iIter = np.array([0])
tIter = np.array([0], np.float64)
def _f_resid(TecConst, A0, A1, ggmeas, iIter, tIter):
T2 = ClassTimeIt("resid")
T2.disable()
TEC, CPhase = TecConst.reshape((2, na))
GThis = TECToZ(TEC.reshape((-1, 1)), CPhase.reshape((-1, 1)),
self.CentralFreqs.reshape((1, -1)))
#T2.timeit("1")
if self.CrossMode:
gg_pred = GThis[A0.ravel(), :] * GThis[A1.ravel(), :].conj()
else:
gg_pred = GThis[A0.ravel(), :]
#T2.timeit("2")
gg_pred_reim = np.array([gg_pred.real,
gg_pred.imag]).ravel()[::self.incrCross]
#T2.timeit("3")
r = (ggmeas - gg_pred_reim).ravel()
#print r.shape
#T2.timeit("4")
#return np.angle((ggmeas-gg_pred).ravel())
#print np.mean(np.abs(r))
iIter += 1
#tIter+=T2.timeit("all")
#print iIter[0]
return r
#print _f_resid(TEC0CPhase0,A0,A1,ggmeas)
Sol = least_squares(
_f_resid,
TEC0CPhase0.ravel(),
#method="trf",
method="lm",
args=(A0, A1, gg_meas_reim, iIter, tIter),
ftol=1e-2,
gtol=1e-2,
xtol=1e-2) #,ftol=1,gtol=1,xtol=1,max_nfev=1)
#Sol=leastsq(_f_resid, TEC0CPhase0.ravel(), args=(A0,A1,gg_meas_reim,iIter),ftol=1e-2,gtol=1e-2,xtol=1e-2)
#T.timeit("Done %3i %3i %5i"%(it,iDir,iIter[0]))
#print "total time f=%f"%tIter[0]
TEC, CPhase = Sol.x.reshape((2, na))
TEC -= TEC[0]
CPhase -= CPhase[0]
GThis = np.abs(GOut[it, :, :, iDir, 0, 0]).T * TECToZ(
TEC.reshape((-1, 1)), CPhase.reshape(
(-1, 1)), self.CentralFreqs.reshape((1, -1)))
T.timeit("done")
return GThis.T, TEC, CPhase
