def GiveMM(self,Mode=None):
if Mode == "SSD":
if self.SSDMM is None:
print("Initialising SSD model machine", file=log)
from DDFacet.Imager.SSD import ClassModelMachineSSD
self.SSDMM = ClassModelMachineSSD.ClassModelMachine(self.GD,GainMachine=ClassGainMachine.get_instance())
else:
print("SSD model machine already initialised", file=log)
return self.SSDMM
elif Mode == "HMP":
if self.MSMFMM is None:
print("Initialising HMP model machine", file=log)
from DDFacet.Imager.MSMF import ClassModelMachineMSMF
self.MSMFMM = ClassModelMachineMSMF.ClassModelMachine(
self.GD,
GainMachine= ClassGainMachine.get_instance())
else:
print("HMP model machine already initialised", file=log)
return self.MSMFMM
elif Mode == "MORESANE":
if self.MORSANEMM is None:
print("Initialising MORESANE model machine", file=log)
from DDFacet.Imager.MORESANE import ClassModelMachineMORESANE
self.MORESANEMM = ClassModelMachineMORESANE.ClassModelMachine(
self.GD,
GainMachine= ClassGainMachine.ClassGainMachine.get_instance())
else:
print("MORSANE model machine already initialised", file=log)
return self.MORESANEMM
elif Mode == "MUFFIN":
if self.MUFFINMM is None:
print("Initialising MUFFIN model machine", file=log)
from DDFacet.Imager.MUFFIN import ClassModelMachineMUFFIN
self.MUFFINMM = ClassModelMachineMUFFIN.ClassModelMachine(self.GD,GainMachine=ClassGainMachine.get_instance())
else:
print("MUFFIN model machine already initialised", file=log)
return self.MUFFINMM
elif Mode == "Hogbom":
if self.HOGBOMMM is None:
print("Initialising HOGBOM model machine", file=log)
from DDFacet.Imager.HOGBOM import ClassModelMachineHogbom
self.HOGBOMMM = ClassModelMachineHogbom.ClassModelMachine(self.GD,GainMachine=ClassGainMachine.get_instance())
else:
print("HOGBOM model machine already initialised", file=log)
return self.HOGBOMMM
elif Mode == "WSCMS":
if self.WSCMSMM is None:
print("Initialising WSCMS model machine", file=log)
from DDFacet.Imager.WSCMS import ClassModelMachineWSCMS
self.WSCMSMM = ClassModelMachineWSCMS.ClassModelMachine(self.GD,GainMachine=ClassGainMachine.get_instance())
else:
print("WSCMS model machine already initialised", file=log)
return self.WSCMSMM
else:
raise NotImplementedError("Unknown model type '%s'"%Mode)
def __init__(
self,
Gain=0.3,
MaxMinorIter=100,
NCPU=6,
CycleFactor=2.5,
FluxThreshold=None,
RMSFactor=3,
PeakFactor=0,
GD=None,
SearchMaxAbs=1,
CleanMaskImage=None,
ImagePolDescriptor=["I"],
ModelMachine=None,
**kw # absorb any unknown keywords arguments into this
):
self.SearchMaxAbs = SearchMaxAbs
self.ModelImage = None
self.MaxMinorIter = MaxMinorIter
self.NCPU = NCPU
self.MaskArray = None
self.GD = GD
self.MultiFreqMode = (self.GD["Freq"]["NBand"] > 1)
self.NFreqBand = self.GD["Freq"]["NBand"]
self.FluxThreshold = FluxThreshold
self.CycleFactor = CycleFactor
self.RMSFactor = RMSFactor
self.PeakFactor = PeakFactor
self.GainMachine = ClassGainMachine.ClassGainMachine(GainMin=Gain)
if ModelMachine is None:
import ClassModelMachineHogbom as ClassModelMachine
self.ModelMachine = ClassModelMachine.ClassModelMachine(
self.GD, GainMachine=self.GainMachine)
else:
self.ModelMachine = ModelMachine
self.GainMachine = self.ModelMachine.GainMachine
self.GiveEdges = GiveEdges.GiveEdges
self._niter = 0
if CleanMaskImage is not None:
print >> log, "Reading mask image: %s" % CleanMaskImage
MaskArray = image(CleanMaskImage).getdata()
nch, npol, _, _ = MaskArray.shape
self._MaskArray = np.zeros(MaskArray.shape, np.bool8)
for ch in range(nch):
for pol in range(npol):
self._MaskArray[ch, pol, :, :] = np.bool8(
1 - MaskArray[ch, pol].T[::-1].copy())[:, :]
self.MaskArray = self._MaskArray[0]
self._peakMode = "normal"
self.CurrentNegMask = None
self._NoiseMap = None
self._PNRStop = None # in _peakMode "sigma", provides addiitonal stopping criterion
def __init__(
self,
Gain=0.1,
MaxMinorIter=50000,
NCPU=0,
CycleFactor=2.5,
FluxThreshold=None,
RMSFactor=3,
PeakFactor=0,
GD=None,
SearchMaxAbs=1,
CleanMaskImage=None,
ImagePolDescriptor=["I"],
ModelMachine=None,
MainCache=None,
CacheFileName='WSCMS',
**kw # absorb any unknown keywords arguments here
):
self.SearchMaxAbs = SearchMaxAbs
self.ModelImage = None
self.MaxMinorIter = MaxMinorIter
self.NCPU = NCPU
self.MaskArray = None
self.GD = GD
self.MultiFreqMode = (self.GD["Freq"]["NBand"] > 1)
self.NFreqBand = self.GD["Freq"]["NBand"]
self.FluxThreshold = FluxThreshold
self.CycleFactor = CycleFactor
self.RMSFactor = RMSFactor
self.PeakFactor = PeakFactor
if ModelMachine is None:
# raise RuntimeError("You need to supply ImageDeconvMachine with a instantiated ModelMachine")
from DDFacet.Imager.WSCMS import ClassModelMachineWSCMS as ClassModelMachine
self.ModelMachine = ClassModelMachine.ClassModelMachine(
self.GD, GainMachine=ClassGainMachine.get_instance())
else:
self.ModelMachine = ModelMachine
self.GainMachine = self.ModelMachine.GainMachine
self._niter = 0
# cache options
self.maincache = MainCache
self.CacheFileName = CacheFileName
self.PSFHasChanged = False
self.LastScale = 99999
self._peakMode = "normal"
self.CacheFileName = CacheFileName
self.CurrentNegMask = None
self._NoiseMap = None
self._PNRStop = None # in _peakMode "sigma", provides addiitonal stopping criterion
def __init__(
self,
Gain=0.3,
MaxMinorIter=100,
NCPU=6,
CycleFactor=2.5,
FluxThreshold=None,
RMSFactor=3,
PeakFactor=0,
GD=None,
SearchMaxAbs=1,
CleanMaskImage=None,
ImagePolDescriptor=["I"],
ModelMachine=None,
**kw # absorb any unknown keywords arguments into this
):
self.SearchMaxAbs = SearchMaxAbs
self.ModelImage = None
self.MaxMinorIter = MaxMinorIter
self.NCPU = NCPU
self.MaskArray = None
self.GD = GD
self.MultiFreqMode = (self.GD["Freq"]["NBand"] > 1)
self.NFreqBand = self.GD["Freq"]["NBand"]
self.FluxThreshold = FluxThreshold
self.CycleFactor = CycleFactor
self.RMSFactor = RMSFactor
self.PeakFactor = PeakFactor
self.GainMachine = ClassGainMachine.get_instance()
if ModelMachine is None:
from DDFacet.Imager.HOGBOM import ClassModelMachineHogbom as ClassModelMachine
self.ModelMachine = ClassModelMachine.ClassModelMachine(
self.GD, GainMachine=self.GainMachine)
else:
self.ModelMachine = ModelMachine
self.GiveEdges = GiveEdges.GiveEdges
self._niter = 0
self._peakMode = "normal"
self.CurrentNegMask = None
self._NoiseMap = None
self._PNRStop = None # in _peakMode "sigma", provides addiitonal stopping criterion
numexpr.set_num_threads(self.NCPU)
def __init__(
self,
Gain=0.3,
MaxMinorIter=100,
NCPU=6,
CycleFactor=2.5,
FluxThreshold=None,
RMSFactor=3,
PeakFactor=0,
GD=None,
SearchMaxAbs=1,
IdSharedMem=None,
ModelMachine=None,
NFreqBands=1,
RefFreq=None,
MainCache=None,
**kw # absorb any unknown keywords arguments into this
):
#self.im=CasaImage
self.maincache = MainCache
self.SearchMaxAbs = SearchMaxAbs
self.ModelImage = None
self.MaxMinorIter = MaxMinorIter
self.NCPU = NCPU
self.Chi2Thr = 10000
self.GD = GD
if IdSharedMem is None:
self.IdSharedMem = str(os.getpid())
else:
self.IdSharedMem = IdSharedMem
self.SubPSF = None
self.MultiFreqMode = (self.GD["Freq"]["NBand"] > 1)
self.FluxThreshold = FluxThreshold
self.CycleFactor = CycleFactor
self.RMSFactor = RMSFactor
self.PeakFactor = PeakFactor
self.GainMachine = ClassGainMachine.ClassGainMachine(GainMin=Gain)
# if ModelMachine is None:
# from DDFacet.Imager.SSD import ClassModelMachineSSD
# self.ModelMachine=ClassModelMachineSSD.ClassModelMachine(self.GD,GainMachine=self.GainMachine)
# else:
self.ModelMachine = ModelMachine
if self.ModelMachine.DicoSMStacked["Type"] != "SSD":
raise ValueError("ModelMachine Type should be SSD")
## If the Model machine was already initialised, it will ignore it in the setRefFreq method
## and we need to set the reference freq in PSFServer
#self.ModelMachine.setRefFreq(self.RefFreq)#,self.PSFServer.AllFreqs)
# reset overall iteration counter
self._niter = 0
self.NChains = self.NCPU
self.DeconvMode = "GAClean"
if self.GD["GAClean"]["InitType"] == "HMP":
import ClassInitSSDModelHMP
self.InitMachine = ClassInitSSDModelHMP.ClassInitSSDModelParallel(
self.GD,
NFreqBands,
RefFreq,
MainCache=self.maincache,
IdSharedMem=self.IdSharedMem)
elif self.GD["GAClean"]["InitType"] == "MORESANE":
import ClassInitSSDModelMoresane
self.InitMachine = ClassInitSSDModelMoresane.ClassInitSSDModelParallel(
self.GD,
NFreqBands,
RefFreq,
NCPU=self.NCPU,
MainCache=self.maincache,
IdSharedMem=self.IdSharedMem)
else:
raise ValueError("InitType should be HMP or MORESANE")
def __init__(
self,
Gain=0.1,
MaxMinorIter=50000,
NCPU=0,
CycleFactor=2.5,
FluxThreshold=None,
RMSFactor=3,
PeakFactor=0,
GD=None,
SearchMaxAbs=1,
CleanMaskImage=None,
ImagePolDescriptor=["I"],
ModelMachine=None,
MainCache=None,
CacheFileName='WSCMS',
**kw # absorb any unknown keywords arguments here
):
self.SearchMaxAbs = SearchMaxAbs
self.ModelImage = None
self.MaxMinorIter = MaxMinorIter
self.NCPU = NCPU
self.MaskArray = None
self.GD = GD
self.MultiFreqMode = (self.GD["Freq"]["NBand"] > 1)
self.NFreqBand = self.GD["Freq"]["NBand"]
self.FluxThreshold = FluxThreshold
self.CycleFactor = CycleFactor
self.RMSFactor = RMSFactor
self.PeakFactor = PeakFactor
if ModelMachine is None:
# raise RuntimeError("You need to supply ImageDeconvMachine with a instantiated ModelMachine")
import ClassModelMachineWSCMS as ClassModelMachine
self.ModelMachine = ClassModelMachine.ClassModelMachine(
self.GD, GainMachine=ClassGainMachine.get_instance())
else:
self.ModelMachine = ModelMachine
self.GainMachine = self.ModelMachine.GainMachine
self._niter = 0
# cache options
self.maincache = MainCache
self.CacheFileName = CacheFileName
self.PSFHasChanged = False
self.LastScale = 99999
# TODO - use MaskMachine for this
CleanMaskImage = self.GD["Mask"]["External"]
if CleanMaskImage is not None:
print >> log, "Reading mask image: %s" % CleanMaskImage
MaskArray = image(CleanMaskImage).getdata()
nch, npol, nxmask, nymask = MaskArray.shape
# if (nch > 1) or (npol > 1):
# print>>log, "Warning - only single channel and pol mask supported. Will use mask for ch 0 pol 0"
# MaskArray = MaskArray[0,0]
# _, _, nxmod, nymod = self.ModelMachine.ModelShape
# if (nxmod != nxmask) or (nymod !=nymask):
# print>>log, "Warning - shape of mask != shape of your model. Will pad/trncate to match model shape"
# nxdiff = nxmod - nxmask
# nydiff = nymod - nymask
# if nxdiff < 0:
# MaskArray = MaskArray
self._MaskArray = np.zeros(MaskArray.shape, np.bool8)
for ch in range(nch):
for pol in range(npol):
self._MaskArray[ch, pol, :, :] = np.bool8(
1 - MaskArray[ch, pol].T[::-1].copy())[:, :]
self.MaskArray = np.ascontiguousarray(self._MaskArray)
# import matplotlib.pyplot as plt
# plt.imshow(self.MaskArray[0,0])
# plt.colorbar()
# plt.show()
#
# import sys
# sys.exit(0)
self._peakMode = "normal"
self.CacheFileName = CacheFileName
self.CurrentNegMask = None
self._NoiseMap = None
self._PNRStop = None # in _peakMode "sigma", provides addiitonal stopping criterion
def __init__(self, Gain=0.3,
MaxMinorIter=100,
NCPU=1, #psutil.cpu_count()
CycleFactor=2.5,
FluxThreshold=None,
RMSFactor=3,
PeakFactor=0,
PrevPeakFactor=0,
GD=None,
SearchMaxAbs=1,
ModelMachine=None,
NFreqBands=1,
RefFreq=None,
MainCache=None,
IdSharedMem="",
ParallelMode=True,
CacheFileName="HMPBasis",
**kw # absorb any unknown keywords arguments into this
):
"""
ImageDeconvMachine constructor. 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.IdSharedMem=IdSharedMem
self.SearchMaxAbs=SearchMaxAbs
self._ModelImage = None
self.MaxMinorIter = MaxMinorIter
self.NCPU = NCPU
self.Chi2Thr = 10000
self._MaskArray = None
self.GD = GD
self.SubPSF = None
self.MultiFreqMode = NFreqBands > 1
self.NFreqBands = NFreqBands
self.RefFreq = RefFreq
self.FluxThreshold = FluxThreshold
self.CycleFactor = CycleFactor
self.RMSFactor = RMSFactor
self.PeakFactor = PeakFactor
self.PrevPeakFactor = PrevPeakFactor
self.CacheFileName=CacheFileName
self.GainMachine=ClassGainMachine.get_instance()
self.ModelMachine = None
self.PSFServer = None
if ModelMachine is not None:
self.updateModelMachine(ModelMachine)
self.PSFHasChanged=False
self._previous_initial_peak = None
self.maincache = MainCache
# reset overall iteration counter
self._niter = 0
self.facetcache=None
self._MaskArray=None
self.MaskMachine=None
self.ParallelMode=ParallelMode
if self.ParallelMode:
APP.registerJobHandlers(self)
# we are in a worker
if not self.ParallelMode:
numexpr.set_num_threads(NCPU)
# peak finding mode.
# "normal" searches for peak in mean dirty image
# "sigma" searches for peak in mean_dirty/noise_map (setNoiseMap will have been called)
# "weighted" searched for peak in mean_dirty*weight
self._peakMode = "normal"
self.CurrentNegMask=None
self._NoiseMap=None
self._PNRStop=None # in _peakMode "sigma", provides addiitonal stopping criterion
if self.GD["HMP"]["PeakWeightImage"]:
print>> log, " Reading peak weighting image %s" % self.GD["HMP"]["PeakWeightImage"]
img = image(self.GD["HMP"]["PeakWeightImage"]).getdata()
_, _, nx, ny = img.shape
# collapse freq and pol axes
img = img.sum(axis=1).sum(axis=0).T[::-1].copy()
self._peakWeightImage = img.reshape((1,1,ny,nx))
self._peakMode = "weighted"
self._prevPeak = None