def main(options=None):
if options == None:
f = open(SaveName, 'rb')
options = pickle.load(f)
if options.OutDicoModel is None:
raise ValueError("--OutDicoModel should be specified")
ModConstructor = ClassModModelMachine()
MM = ModConstructor.GiveInitialisedMMFromFile(options.InDicoModel)
if options.MaskName:
MM.CleanMaskedComponants(options.MaskName)
if options.FilterNegComp:
MM.RemoveNegComponants()
MM.ToFile(options.OutDicoModel)
def __init__(self,BaseImageName,BeamPix=5,ResidualImName="",DoAlpha=1,
MaskName="",CleanNegComp=False,
NBands=1,
SmoothMode=0,MakeCorrected=1,options=None):
self.DoAlpha=DoAlpha
self.BaseImageName=BaseImageName
self.BeamPix=BeamPix
self.NBands=NBands
self.OutName=options.OutName
self.options=options
self.SmoothMode=SmoothMode
self.MakeCorrected=MakeCorrected
self.header_dict={}
FileDicoModel="%s.DicoModel"%BaseImageName
# ClassModelMachine,DicoModel=GiveModelMachine(FileDicoModel)
# self.ModelMachine=ClassModelMachine(Gain=0.1)
# self.ModelMachine.FromDico(DicoModel)
print("Building model machine", file=log)
ModConstructor = ClassModModelMachine()
self.ModelMachine=ModConstructor.GiveInitialisedMMFromFile(FileDicoModel)
if MaskName!="":
self.ModelMachine.CleanMaskedComponants(MaskName)
if CleanNegComp:
self.ModelMachine.CleanNegComponants(box=10,sig=2)
if ResidualImName=="":
#if "App" in self.ModeNorm:
# FitsFile="%s.app.residual.fits"%BaseImageName
#else:
# FitsFile="%s.int.residual.fits"%BaseImageName
ResidualImName=FitsFile="%s.app.residual.fits"%BaseImageName
else:
ResidualImName=FitsFile=ResidualImName
if self.MakeCorrected:
if self.SmoothMode:
NormImageName="%s.MeanSmoothNorm.fits"%BaseImageName
else:
NormImageName="%s.Norm.fits"%BaseImageName
print("Reading residual image", file=log)
self.FitsFile=FitsFile
im=image(FitsFile)
c=im.coordinates()
self.radec=c.dict()["direction0"]["crval"]
CellSizeRad,_=c.dict()["direction0"]["cdelt"]
self.CellSizeRad=np.abs(CellSizeRad)
self.Cell=(self.CellSizeRad*180/np.pi)*3600
self.CellArcSec=self.Cell
self.ResidualData=im.getdata()
nchan,npol,_,_=self.ResidualData.shape
testImage=np.zeros_like(self.ResidualData)
print("Transposing residual...", file=log)
if ResidualImName!="":
for ch in range(nchan):
for pol in range(npol):
testImage[ch,pol,:,:]=self.ResidualData[ch,pol,:,:].T[::-1,:]#*1.0003900000000001
if self.MakeCorrected:
print("Reading beam...", file=log)
SqrtNormImage=np.zeros_like(self.ResidualData)
imNorm=image(NormImageName).getdata()
print("Transposing beam...", file=log)
for ch in range(nchan):
for pol in range(npol):
SqrtNormImage[ch,pol,:,:]=np.sqrt(imNorm[ch,pol,:,:].T[::-1,:])
else:
SqrtNormImage=np.ones_like(self.ResidualData)
_,_,nx,_=testImage.shape
Nr=10000
indx,indy=np.int64(np.random.rand(Nr)*nx),np.int64(np.random.rand(Nr)*nx)
self.StdResidual=np.std(testImage[0,0,indx,indy])
self.Residual=testImage
self.SqrtNormImage=SqrtNormImage
def main(options=None):
if options==None:
f = open(SaveName,'rb')
options = pickle.load(f)
SkyModel=options.SkyModel
if "," in SkyModel:
SMList=SkyModel.split(",")
print>>log, "Concatenating SkyModels %s"%(str(SMList))
ThisCat=np.load(SMList[0])
ThisCat=ThisCat.view(np.recarray)
ThisNDir=len(list(set(ThisCat.Cluster.tolist())))
CurrentMaxCluster=ThisNDir
CatList=[ThisCat]
for SM in SMList[1::]:
ThisCat=np.load(SM)
ThisCat=ThisCat.view(np.recarray)
ThisNDir=len(list(set(ThisCat.Cluster.tolist())))
ThisCat.Cluster+=CurrentMaxCluster
CurrentMaxCluster+=ThisNDir
CatList.append(ThisCat)
cat=np.concatenate(CatList)
cat=cat.view(np.recarray)
OutSkyModel=options.OutSkyModel
print>>log, "Saving in %s"%(OutSkyModel)
np.save(OutSkyModel,cat)
SM=ClassSM.ClassSM(OutSkyModel+".npy",
ReName=True,
DoREG=True,
SaveNp=True)
SM.Rename()
SM.Save()
return
if options.BaseImageName!="":
#from DDFacet.Imager.ClassModelMachine import ClassModelMachine
FileDicoModel="%s.DicoModel"%options.BaseImageName
# ClassModelMachine,DicoModel=GiveModelMachine(FileDicoModel)
# MM=ClassModelMachine(Gain=0.1)
# MM.FromDico(DicoModel)
ModConstructor = ClassModModelMachine()
MM=ModConstructor.GiveInitialisedMMFromFile(FileDicoModel)
SqrtNormImage=None
if options.ApparantFlux:
FileSqrtNormImage="%s.Norm.fits"%options.BaseImageName
imSqrtNormImage=image(FileSqrtNormImage)
SqrtNormImage=imSqrtNormImage.getdata()
nchan,npol,_,_=SqrtNormImage.shape
for ch in range(nchan):
for pol in range(npol):
SqrtNormImage[ch,pol,:,:]=(SqrtNormImage[ch,pol,:,:].T[::-1,:])
#FitsFile="%s.model.fits"%options.BaseImageName
FitsFile="%s.dirty.fits"%options.BaseImageName
#MM.FromFile(DicoModel)
if options.MaskName!="":
MM.CleanMaskedComponants(options.MaskName)
if options.CleanNegComp:
MM.CleanNegComponants(box=10,sig=2)
SkyModel=options.BaseImageName+".npy"
# reproduce code from old ClassModelMachine
RefFreq=MM.DicoSMStacked["RefFreq"]
f0=RefFreq/1.5
f1=RefFreq*1.5
try:
MM.setFreqMachine([f0,f1],[MM.RefFreq])
except:
pass # this is an old version of DDF which doesn't need this
MM.ToNPYModel(FitsFile,SkyModel,BeamImage=SqrtNormImage)
# SkyModel="tmpSourceCat.npy"
# ModelImage=MM.GiveModelImage()
# im=image(FitsFile)
# ModelOrig=im.getdata()
# indx,indy=np.where(ModelImage[0,0]!=ModelImage[0,0])
# print ModelImage[0,0,indx,indy],ModelImage[0,0,indx,indy]
# cell=abs(im.coordinates().dict()["direction0"]["cdelt"][0])*180/np.pi*3600
# ra,dec=im.coordinates().dict()["direction0"]["crval"]
# CasaImage=ClassCasaImage.ClassCasaimage("Model",ModelImage.shape,cell,(ra,dec))
# CasaImage.setdata(ModelImage,CorrT=True)
# CasaImage.ToFits()
# CasaImage.close()
if options.RemoveNegComp==1:
print "Removing negative component"
Cat=np.load(SkyModel)
print Cat.shape
Cat=Cat.view(np.recarray)
Cat=Cat[Cat.I>0]
print Cat.shape
np.save(SkyModel,Cat)
NCluster=int(options.NCluster)
DoPlot=(int(options.DoPlot)==1)
DoSelect=(int(options.DoSelect)==1)
CMethod=int(options.CMethod)
if DoPlot==0:
import matplotlib
matplotlib.use('agg')
SM=ClassSM.ClassSM(SkyModel,ReName=True,
DoREG=True,SaveNp=True,
SelSource=DoSelect,ClusterMethod=CMethod)
if True:
print>>log, "Removing fake gaussians"
Cat=SM.SourceCat
indG=np.where(Cat["Gmaj"]>0)[0]
CatSel=Cat[indG]
Gmaj=CatSel["Gmaj"]*180/np.pi*3600
I=CatSel["I"]
ind=np.where((I/Gmaj)>3)[0]
CatSel[ind]["Gmaj"]=0.
CatSel[ind]["Gmin"]=0.
CatSel[ind]["Gangle"]=0.
CatSel[ind]["Type"]=0.
#SM.SourceCat[indG][ind]=CatSel
indN=np.arange(SM.SourceCat.shape[0])[indG][ind]
SM.SourceCat["Gmaj"][indN]=0.
SM.SourceCat["Gmin"][indN]=0.
SM.SourceCat["Gangle"][indN]=0.
SM.SourceCat["Type"][indN]=0.
#print SM.SourceCat[indG][ind]
#np.save(SkyModel,Cat)
print>>log, " done"
PreCluster=options.ds9PreClusterFile
SM.Cluster(NCluster=NCluster,DoPlot=DoPlot,PreCluster=PreCluster,FromClusterCat=options.FromClusterCat)
SM.MakeREG()
SM.Save()
if options.DoPrint=="1":
SM.print_sm2()
def giveModel(self, ListPixParms):
T = ClassTimeIt.ClassTimeIt("giveModel")
T.disable()
self.setSubDirty(ListPixParms)
T.timeit("setsub")
ModConstructor = ClassModModelMachine(self.GD)
ModelMachine = ModConstructor.GiveMM(Mode=self.GD["Deconv"]["Mode"])
#print "ModelMachine"
#time.sleep(30)
T.timeit("giveMM")
self.ModelMachine = ModelMachine
#self.ModelMachine.DicoSMStacked=self.DicoBasicModelMachine
self.ModelMachine.setRefFreq(self.RefFreq, Force=True)
self.ModelMachine.setFreqMachine(self.GridFreqs, self.DegridFreqs)
self.MinorCycleConfig["ModelMachine"] = ModelMachine
self.ModelMachine.setModelShape(self.SubDirty.shape)
#self.ModelMachine.setListComponants(self.DeconvMachine.ModelMachine.ListScales)
T.timeit("setlistcomp")
self.DeconvMachine.Update(self.DicoSubDirty, DoSetMask=False)
#self.DeconvMachine.updateMask(np.logical_not(self.SubMask))
self.DeconvMachine.updateModelMachine(ModelMachine)
#self.DeconvMachine.resetCounter()
T.timeit("update")
#print "update"
#time.sleep(30)
self.DeconvMachine.Deconvolve()
T.timeit("deconv %s" % str(self.DicoSubDirty["ImageCube"].shape))
#print "deconv"
#time.sleep(30)
ModelImage = self.ModelMachine.GiveModelImage()
T.timeit("getmodel")
# import pylab
# pylab.clf()
# pylab.subplot(2,2,1)
# pylab.imshow(self.DicoDirty["MeanImage"][0,0,:,:],interpolation="nearest")
# pylab.colorbar()
# pylab.subplot(2,2,2)
# pylab.imshow(self.DicoSubDirty["MeanImage"][0,0,:,:],interpolation="nearest")
# pylab.colorbar()
# pylab.subplot(2,2,3)
# pylab.imshow(self.SubMask,interpolation="nearest")
# pylab.colorbar()
# pylab.subplot(2,2,4)
# pylab.imshow(ModelImage[0,0],interpolation="nearest")
# pylab.colorbar()
# pylab.draw()
# pylab.show(False)
# pylab.pause(0.1)
x, y = self.ArrayPixParms.T
# PSF,MeanPSF=self.DeconvMachine.PSFServer.GivePSF()
# ConvModel=ClassConvMachineImages(PSF).giveConvModel(ModelImage*np.ones((self.NFreqBands,1,1,1)))
# #T.timeit("Conv1")
# #print "done1"
# #ConvModel=self.giveConvModel(ModelImage*np.ones((self.NFreqBands,1,1,1)))
# # print "done2"
# # T.timeit("Conv2")
# # import pylab
# # pylab.clf()
# # pylab.subplot(1,3,1)
# # pylab.imshow(ConvModel[0,0],interpolation="nearest")
# # pylab.subplot(1,3,2)
# # pylab.imshow(ConvModel1[0,0],interpolation="nearest")
# # pylab.subplot(1,3,3)
# # pylab.imshow((ConvModel-ConvModel1)[0,0],interpolation="nearest")
# # pylab.colorbar()
# # pylab.draw()
# # pylab.show(False)
# # stop
# ModelOnes=np.zeros_like(ModelImage)
# ModelOnes[:,:,x,y]=1
# ConvModelOnes=ClassConvMachineImages(PSF).giveConvModel(ModelOnes*np.ones((self.NFreqBands,1,1,1)))
# SumConvModel=np.sum(ConvModel[:,:,x,y])
# SumConvModelOnes=np.sum(ConvModelOnes[:,:,x,y])
# SumResid=np.sum(self.DeconvMachine._CubeDirty[:,:,x,y])
# SumConvModel=np.max([SumConvModel,1e-6])
# factor=(SumResid+SumConvModel)/SumConvModel
# ###############
#fMult=1.
#if 1.<factor<2.:
# fMult=factor
fMult = 1.
SModel = ModelImage[0, 0, x, y] * fMult
# ###########"
# fMult=(np.mean(SumResid))/(np.mean(SumConvModelOnes))
# SModel=ModelImage[0,0,x,y]+ModelOnes[0,0,x,y]*fMult
# print fMult
# print fMult
# print fMult
# print fMult
# print fMult
# print fMult
# print fMult
# ############
AModel = self.ModelMachine.GiveSpectralIndexMap()[0, 0, x, y]
T.timeit("spec index")
return SModel, AModel
def __init__(self,
GD,
DicoVariablePSF,
RefFreq,
GridFreqs,
DegridFreqs,
MainCache=None,
IdSharedMem="",
DoWait=False):
self.DicoVariablePSF = DicoVariablePSF
GD = copy.deepcopy(GD)
self.RefFreq = RefFreq
self.GridFreqs = GridFreqs
self.DegridFreqs = DegridFreqs
self.GD = GD
self.GD["Parallel"]["NCPU"] = 1
#self.GD["HMP"]["Alpha"]=[0,0,1]#-1.,1.,5]
self.GD["HMP"]["Alpha"] = [-1., 1., 5]
self.GD["Deconv"]["Mode"] = "MORESANE"
self.GD["Deconv"]["CycleFactor"] = 0
self.GD["Deconv"]["PeakFactor"] = 0.0
self.GD["Deconv"]["RMSFactor"] = self.GD["GAClean"]["RMSFactorInitHMP"]
self.GD["Deconv"]["Gain"] = self.GD["GAClean"]["GainInitHMP"]
self.GD["Deconv"]["AllowNegative"] = self.GD["GAClean"][
"AllowNegativeInitHMP"]
self.GD["Deconv"]["MaxMinorIter"] = self.GD["GAClean"][
"MaxMinorIterInitHMP"]
logger.setSilent(SilentModules)
self.GD["HMP"]["Scales"] = self.GD["GAClean"]["ScalesInitHMP"]
self.GD["HMP"]["Ratios"] = []
#self.GD["MultiScale"]["Ratios"]=[]
self.GD["HMP"]["NTheta"] = 4
self.GD["HMP"]["SolverMode"] = "NNLS"
#self.GD["MultiScale"]["SolverMode"]="PI"
self.NFreqBands = len(DicoVariablePSF["freqs"])
MinorCycleConfig = dict(self.GD["Deconv"])
MinorCycleConfig["NCPU"] = self.GD["Parallel"]["NCPU"]
MinorCycleConfig["NFreqBands"] = self.NFreqBands
MinorCycleConfig["GD"] = self.GD
MinorCycleConfig["GridFreqs"] = self.GridFreqs
MinorCycleConfig["DegridFreqs"] = self.DegridFreqs
#MinorCycleConfig["RefFreq"] = self.RefFreq
ModConstructor = ClassModModelMachine(self.GD)
ModelMachine = ModConstructor.GiveMM(Mode="MORESANE")
ModelMachine.setRefFreq(self.RefFreq)
MinorCycleConfig["ModelMachine"] = ModelMachine
#MinorCycleConfig["CleanMaskImage"]=None
self.MinorCycleConfig = MinorCycleConfig
self.DeconvMachine = ClassImageDeconvMachineMoresane.ClassImageDeconvMachine(
MainCache=MainCache,
ParallelMode=False,
RefFreq=self.RefFreq,
CacheFileName="HMP_Init",
IdSharedMem=IdSharedMem,
**self.MinorCycleConfig)
self.GD["Mask"]["Auto"] = False
self.GD["Mask"]["External"] = None
self.MaskMachine = ClassMaskMachine.ClassMaskMachine(self.GD)
self.DeconvMachine.setMaskMachine(self.MaskMachine)
self.Margin = 50
#print "Start 3"
self.DeconvMachine.Init(PSFVar=self.DicoVariablePSF,
PSFAve=self.DicoVariablePSF["PSFSideLobes"],
GridFreqs=self.GridFreqs,
DegridFreqs=self.DegridFreqs,
DoWait=DoWait,
RefFreq=self.RefFreq)
if DoWait:
print "IINit3"
time.sleep(10)
print "Start 4"
self.DeconvMachine.Update(self.DicoDirty, DoSetMask=False)
if DoWait:
print "IINit4"
time.sleep(10)
def __init__(self,
GD,
ExternalModelMachine=None,
DegridFreqs=None,
GridFreqs=None,
MainCache=None):
self.GD = copy.deepcopy(GD)
self.MainCache = MainCache
self.NoiseMap = None
self.NoiseMapRestored = None
self.NoiseMapReShape = None
self._id_InputMap = None
self.ExternalModelMachine = ExternalModelMachine
self.DegridFreqs = DegridFreqs
self.GridFreqs = GridFreqs
self.NFreqBands = len(GridFreqs)
# MyLogger.setSilent(ListSilentModules)
self.RefFreq = ExternalModelMachine.RefFreq
# self.GD["Parallel"]["NCPU"]=1
# self.GD["HMP"]["Alpha"]=[0,0,1]#-1.,1.,5]
self.GD["HMP"]["Alpha"] = [0, 0, 1]
# self.GD["Deconv"]["Mode"]="HMP"
# self.GD["Deconv"]["CycleFactor"]=0
# self.GD["Deconv"]["PeakFactor"]=0.0
self.GD["Deconv"]["PSFBox"] = "full"
self.GD["Deconv"]["MaxMinorIter"] = 10000
self.GD["Deconv"]["RMSFactor"] = 3.
# self.GD["HMP"]["Scales"]=[0]
self.GD["HMP"]["Ratios"] = []
# self.GD["MultiScale"]["Ratios"]=[]
self.GD["HMP"]["NTheta"] = 4
# self.GD["Deconv"]["AllowNegative"]=False
# self.GD["HMP"]["Scales"]=[0,1,2,4,8,16,32,48,64,96,128]
# self.GD["HMP"]["SolverMode"]="NNLS"
# self.GD["HMP"]["Support"]=91
# self.GD["HMP"]["Taper"]=31
# self.GD["Deconv"]["Gain"]=.3
self.GD["HMP"]["SolverMode"] = "PI"
self.GD["HMP"]["Scales"] = [0]
self.GD["Deconv"]["Gain"] = .1
if self.NoiseMapReShape is not None:
print >> log, "Deconvolving on SNR map"
self.GD["Deconv"]["RMSFactor"] = 0.
self.GD["HMP"]["AllowResidIncrease"] = 0.1
# self.GD["HMP"]["SolverMode"]="PI"
MinorCycleConfig = dict(self.GD["Deconv"])
MinorCycleConfig["NCPU"] = self.GD["Parallel"]["NCPU"]
MinorCycleConfig["NFreqBands"] = self.NFreqBands
MinorCycleConfig["RefFreq"] = self.RefFreq
MinorCycleConfig["GD"] = self.GD
# MinorCycleConfig["RefFreq"] = self.RefFreq
# MinorCycleConfig["CleanMaskImage"]=None
self.MinorCycleConfig = MinorCycleConfig
if self.GD["Deconv"]["Mode"] in ["HMP", "SSD"]:
# for SSD we need to set up the HMP ModelMachine.
self.GD["Deconv"]["Mode"] = "HMP"
ModConstructor = ClassModModelMachine(self.GD)
self.ModelMachine = ModConstructor.GiveMM(
Mode=self.GD["Deconv"]["Mode"])
self.ModelMachine.setRefFreq(self.RefFreq)
MinorCycleConfig["ModelMachine"] = self.ModelMachine
self.MinorCycleConfig = MinorCycleConfig
from DDFacet.Imager.MSMF import ClassImageDeconvMachineMSMF
self.DeconvMachine = ClassImageDeconvMachineMSMF.ClassImageDeconvMachine(
MainCache=self.MainCache,
ParallelMode=True,
CacheFileName="HMP_Masking",
**self.MinorCycleConfig)
elif self.GD["Deconv"]["Mode"] == "Hogbom":
from DDFacet.Imager.HOGBOM import ClassImageDeconvMachineHogbom
self.DeconvMachine = ClassImageDeconvMachineHogbom.ClassImageDeconvMachine(
MainCache=self.MainCache,
ParallelMode=True,
CacheFileName="HMP_Masking",
**self.MinorCycleConfig)
else:
raise NotImplementedError(
"Mode %s not compatible with automasking" %
self.GD["Deconv"]["Mode"])
def __init__(self,
GD,
NFreqBands,
RefFreq,
MainCache=None,
IdSharedMem=""):
"""Constructs initializer.
Note that this should be called pretty much when setting up the imager,
before APP workers are started, because the object registers APP handlers.
"""
self.GD = copy.deepcopy(GD)
self.GD["Parallel"]["NCPU"] = 1
# self.GD["HMP"]["Alpha"]=[0,0,1]#-1.,1.,5]
self.GD["HMP"]["Alpha"] = self.GD["GAClean"]["AlphaInitHMP"]
self.GD["Deconv"]["Mode"] = "HMP"
self.GD["Deconv"]["CycleFactor"] = 0
self.GD["Deconv"]["PeakFactor"] = 0.0
self.GD["Deconv"]["RMSFactor"] = self.GD["GAClean"]["RMSFactorInitHMP"]
self.GD["Deconv"]["Gain"] = self.GD["GAClean"]["GainInitHMP"]
self.GD["Deconv"]["AllowNegative"] = self.GD["GAClean"][
"AllowNegativeInitHMP"]
self.GD["Deconv"]["MaxMinorIter"] = int(
self.GD["GAClean"]["MaxMinorIterInitHMP"])
self.GD["HMP"]["Scales"] = self.GD["GAClean"]["ScalesInitHMP"]
self.GD["HMP"]["Ratios"] = self.GD["GAClean"]["RatiosInitHMP"]
# self.GD["MultiScale"]["Ratios"]=[]
self.GD["HMP"]["NTheta"] = self.GD["GAClean"]["NThetaInitHMP"]
# print "!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
# # self.GD["HMP"]["Scales"] = [0,1,2,4,8,16,24,32,48,64]
# # self.GD["HMP"]["Taper"] = 32
# # self.GD["HMP"]["Support"] = 32#self.GD["HMP"]["Scales"][-1]
# self.GD["Deconv"]["RMSFactor"] = 1.
# self.GD["Deconv"]["AllowNegative"] = True
self.GD["HMP"]["SolverMode"] = "NNLS"
# self.GD["MultiScale"]["SolverMode"]="PI"
self.NFreqBands = NFreqBands
self.RefFreq = RefFreq
MinorCycleConfig = dict(self.GD["Deconv"])
MinorCycleConfig["NCPU"] = self.GD["Parallel"]["NCPU"]
MinorCycleConfig["NFreqBands"] = self.NFreqBands
MinorCycleConfig["RefFreq"] = RefFreq
ModConstructor = ClassModModelMachine(self.GD)
ModelMachine = ModConstructor.GiveMM(Mode=self.GD["Deconv"]["Mode"])
ModelMachine.setRefFreq(self.RefFreq)
MinorCycleConfig["ModelMachine"] = ModelMachine
self.MinorCycleConfig = MinorCycleConfig
self.DeconvMachine = ClassImageDeconvMachineMSMF.ClassImageDeconvMachine(
MainCache=MainCache,
ParallelMode=True,
CacheFileName="HMP_Init",
IdSharedMem=IdSharedMem,
GD=self.GD,
**MinorCycleConfig)
self.GD["Mask"]["Auto"] = False
self.GD["Mask"]["External"] = None
self.MaskMachine = ClassMaskMachine.ClassMaskMachine(self.GD)
def LoadModel(self):
# ClassModelMachine,DicoModel=GiveModelMachine(self.FileDicoModel)
# try:
# self.GD["GAClean"]["GASolvePars"]=DicoModel["SolveParam"]
# except:
# self.GD["GAClean"]["GASolvePars"]=["S","Alpha"]
# DicoModel["SolveParam"]=self.GD["GAClean"]["GASolvePars"]
# self.MM=ClassModelMachine(self.GD)
# self.MM.FromDico(DicoModel)
# From DicoModel
ModConstructor = ClassModModelMachine(self.GD)
self.MM = ModConstructor.GiveInitialisedMMFromFile(self.FileDicoModel)
#ModelImage0=self.MM.GiveModelImage(np.mean(self.VS.MS.ChanFreq))
if self.GD["GDkMS"]["ImageSkyModel"]["FilterNegComp"]:
self.MM.FilterNegComponants(box=15, sig=1)
if self.GD["GDkMS"]["ImageSkyModel"]["MaskImage"] != None:
self.MM.CleanMaskedComponants(
self.GD["GDkMS"]["ImageSkyModel"]["MaskImage"])
#self.ModelImage=self.MM.GiveModelImage(np.mean(self.VS.MS.ChanFreq))
model_freqs = self.VS.FreqBandChannelsDegrid[0]
# original_freqs=self.VS.FreqBandChannels[0]
# self.MM.setFreqMachine(original_freqs, model_freqs)
ModelImage = self.MM.GiveModelImage(model_freqs)
log.print("model image @%s MHz (min,max) = (%f, %f)" %
(str(model_freqs / 1e6), ModelImage.min(), ModelImage.max()))
# # From ModelImage
# print "im!!!!!!!!!!!!!!!!!!!!!!!"
# im=image("Model.fits")
# data=im.getdata()
# nch,npol,nx,_=data.shape
# for ch in range(nch):
# for pol in range(npol):
# data[ch,pol]=data[ch,pol].T[::-1]
# self.ModelImage=ModelImage=data
# # ###############################
self.FacetMachine.ToCasaImage(ModelImage,
ImageName="%s.Model_kMS" %
self.BaseImageName,
Fits=True)
# #stop
#del(data)
self.DicoImager = self.FacetMachine.DicoImager
NFacets = len(self.FacetMachine.DicoImager)
self.NFacets = NFacets
#self.NDirs=NFacets
#self.Dirs=range(self.NDirs)
# SolsFile=self.GD["DDESolutions"]["DDSols"]
# if not(".npz" in SolsFile):
# ThisMSName=reformat.reformat(os.path.abspath(self.VS.MSName),LastSlash=False)
# SolsFile="%s/killMS.%s.sols.npz"%(self.VS.MSName,SolsFile)
# #SolsFile="BOOTES24_SB100-109.2ch8s.ms/killMS.KAFCA.Scalar.50Dir.0.1P.BriggsSq.PreCuster4.sols.npz"
# DicoSolsFile=np.load(SolsFile)
# ClusterCat=DicoSolsFile["ClusterCat"]
# ClusterCat=ClusterCat.view(np.recarray)
#DicoFacetName="%s.DicoFacet"%self.BaseImageName
#DicoFacet=DDFacet.Other.MyPickle.Load(DicoFacetName)
NodeFile = "%s.NodesCat.npy" % self.GD["Output"][
"Name"] #BaseImageName
NodesCat = np.load(NodeFile)
NodesCat = NodesCat.view(np.recarray)
self.NDir = NodesCat.shape[0]
ClusterCat = np.zeros((self.NDir, ),
dtype=[('Name', '|S200'), ('ra', np.float),
('dec', np.float), ('l', np.float),
('m', np.float), ('SumI', np.float),
("Cluster", int)])
ClusterCat = ClusterCat.view(np.recarray)
ClusterCat.l = NodesCat.l
ClusterCat.m = NodesCat.m
ClusterCat.ra = NodesCat.ra
ClusterCat.dec = NodesCat.dec
NN = ClusterCat.shape[0]
Cat=np.zeros((NN,),dtype=[('Name','|S200'),('ra',np.float),('dec',np.float),('Sref',np.float),('I',np.float),('Q',np.float),\
('U',np.float),('V',np.float),('RefFreq',np.float),('alpha',np.float),('ESref',np.float),\
('Ealpha',np.float),('kill',np.int),('Cluster',np.int),('Type',np.int),('Gmin',np.float),\
('Gmaj',np.float),('Gangle',np.float),("Select",np.int),('l',np.float),('m',np.float),
("Exclude",bool)])
Cat = Cat.view(np.recarray)
Cat.RefFreq = 1.
Cat.ra[:] = ClusterCat.ra
Cat.dec[:] = ClusterCat.dec
Cat.I[:] = ClusterCat.SumI[:]
Cat.Cluster = np.arange(NN)
Cat.Sref[:] = ClusterCat.SumI[:]
self.SourceCat = Cat
self.DicoImager = self.FacetMachine.DicoImager
self.ClusterCat = ClusterCat
self.ClusterCat.SumI = 0.
# ind=np.where(self.ClusterCat.SumI!=0)[0]
# self.ClusterCat=self.ClusterCat[ind].copy()
# NFacets=self.ClusterCat.shape[0]
# log.print( " There are %i non-zero facets"%NFacets)
NFacets = len(self.FacetMachine.DicoImager)
lFacet = np.zeros((NFacets, ), np.float32)
mFacet = np.zeros_like(lFacet)
for iFacet in range(NFacets):
l, m = self.FacetMachine.DicoImager[iFacet]["lmShift"]
lFacet[iFacet] = l
mFacet[iFacet] = m
NDir = ClusterCat.l.size
d = np.sqrt((ClusterCat.l.reshape((NDir, 1)) -
lFacet.reshape((1, NFacets)))**2 +
(ClusterCat.m.reshape((NDir, 1)) -
mFacet.reshape((1, NFacets)))**2)
idDir = np.argmin(d, axis=0)
for iFacet in range(NFacets):
self.FacetMachine.DicoImager[iFacet]["iDirJones"] = idDir[iFacet]
# print(iFacet,idDir[iFacet])
self.SM.ClusterCat = self.ClusterCat
self.SM.SourceCat = self.SourceCat
from DDFacet.Other.AsyncProcessPool import APP
APP.startWorkers()
#self.VS.CalcWeightsBackground()
self.FacetMachine.initCFInBackground()
self.FacetMachine.awaitInitCompletion()
# for iFacet in range(NFacets):
# #self.FacetMachine.SpacialWeigth[iFacet]=NpShared.ToShared("%sSpacialWeight_%3.3i"%(self.IdSharedMem,iFacet),self.FacetMachine.SpacialWeigth[iFacet])
# self.FacetMachine.SpacialWeigth[iFacet]=self.FacetMachine._CF[iFacet]["SW"]
# log.print( " Splitting model image")
# self.BuildGridsParallel()
self.FacetMachine.BuildFacetNormImage()
self.FacetMachine.setModelImage(ModelImage)
self.FacetMachine.set_model_grid()
self.PrepareGridMachinesMapping()
#self.BuildGridsSerial()
#self.BuildGridsParallel()
NFacets = self.ClusterCat.shape[0]
self.SM.NDir = self.NDirs
self.SM.Dirs = self.Dirs
log.print(" There are %i non-zero directions" % self.SM.NDir)
self.SM.ClusterCat = self.ClusterCat
self.SM.SourceCat = self.SourceCat
# self.SM.SourceCat.I[:]=self.ClusterCat.SumI[:]
self.SM.DicoJonesDirToFacet = self.DicoJonesDirToFacet
self.SM.GD = self.FacetMachine.GD
self.SM.DicoImager = self.FacetMachine.DicoImager
#self.SM.GD["Comp"]["CompDeGridMode"]=0
CurrentMS = self.VS.ListMS[self.VS.iCurrentMS]
self.SM.rac = CurrentMS.rac
self.SM.decc = CurrentMS.decc
self.SM.AvailableCorrelationProductsIds = self.VS.StokesConverter.AvailableCorrelationProductsIds(
)
self.SM.RequiredStokesProductsIds = self.VS.StokesConverter.RequiredStokesProductsIds(
)
self.SM.NFreqBands = self.VS.NFreqBands
self.SM.Path = {"cf_dict_path": self.FacetMachine._CF.path}
#self.SM.ChanMappingDegrid=self.VS.FreqBandChannelsDegrid[0]
self.SM.ChanMappingDegrid = self.VS.DicoMSChanMappingDegridding[0]
self.SM._model_dict = self.FacetMachine._model_dict
self.SM.MapClusterCatOrigToCut = self.MapClusterCatOrigToCut