def ConvolveGaussianParallel(shareddict, field_in, field_out, CellSizeRad=None, GaussPars=[(0., 0., 0.)], Normalise=False): """Convolves images held in a dict, using APP. """ Ain0 = shareddict[field_in] nch, npol, _, _ = Ain0.shape Aout = shareddict[field_out] # single channel? Handle serially if nch == 1: return ConvolveGaussian(shareddict, field_in, field_out, 0, CellSizeRad, GaussPars[0], None, Normalise) jobid = "convolve:%s:%s:" % (field_in, field_out) for ch in range(nch): sd_rw = shareddict.readwrite() APP.runJob(jobid + str(ch), _convolveSingleGaussianFFTW_noret, args=(sd_rw, field_in, field_out, ch, CellSizeRad, GaussPars[ch], None, Normalise)) APP.awaitJobResults(jobid + "*") #, progress="Convolving") return Aout
def Interpol(self): APP.startWorkers() if "TEC" in self.DicoFile0["SmoothMode"]: TECArray = NpShared.ToShared("%sTECArray" % IdSharedMem, self.DicoFile0["SolsTEC"]) CPhaseArray = NpShared.ToShared("%sCPhaseArray" % IdSharedMem, self.DicoFile0["SolsCPhase"]) nt, nd, na = TECArray.shape iJob = 0 for it in range(nt): APP.runJob("InterpolTECTime_%d" % iJob, self.InterpolTECTime, args=(it, )) #,serial=True) iJob += 1 workers_res = APP.awaitJobResults("InterpolTECTime*", progress="Interpol TEC") iJob = 0 for it in range(nt): APP.runJob("InterpolAmpTime_%d" % iJob, self.InterpolAmpTime, args=(it, )) #,serial=True) iJob += 1 workers_res = APP.awaitJobResults("InterpolAmpTime*", progress="Interpol Amp") # APP.terminate() APP.shutdown() Multiprocessing.cleanupShm()
def giveWeigthParallel(self): self.DATA = shared_dict.attach(self.DictName) self.na = self.DATA["na"] for A0 in range(0, self.na): for A1 in range(A0 + 1, self.na): APP.runJob("giveWeigthChunk:%d:%d" % (A0, A1), self.giveWeigthChunk, args=(A0, A1, self.DATA.readwrite())) #,serial=True) APP.awaitJobResults("giveWeigthChunk:*", progress="CalcWeight")
def giveWeigthParallel(self): self.DATA = shared_dict.attach(self.DictName) nrow, nch, npol = self.DATA["data"].shape self.na = self.DATA["na"] ntu = self.DATA["times_unique"].size self.DATA["Wa"] = np.zeros((self.na, ntu), np.float32) for A0 in range(self.na): APP.runJob("giveWeigthAnt:%d" % (A0), self.giveWeigthAnt, args=(A0, )) #,serial=True) APP.awaitJobResults("giveWeigthAnt:*", progress="CalcWeight")
def StackAll(self): while self.iCurrentMS<self.nMS: if self.LoadNextMS()=="NotRead": continue print("Making dynamic spectra...", file=log) # for iTime in range(self.NTimes): # APP.runJob("Stack_SingleTime:%d"%(iTime), # self.Stack_SingleTime, # args=(iTime,))#,serial=True) # APP.awaitJobResults("Stack_SingleTime:*", progress="Append MS %i"%self.DicoDATA["iMS"]) FF=self.DicoGrids["DomainEdges_Freq"] TT=self.DicoGrids["DomainEdges_Time"] for iTime in range(TT.size-1): for iFreq in range(FF.size-1): #print(iTime,iFreq) APP.runJob("Stack_SingleTime:%d:%d"%(iTime,iFreq), self.Stack_SingleTime, args=(iTime,iFreq))#,serial=True) APP.awaitJobResults("Stack_SingleTime:*", progress="Append MS %i"%self.DicoDATA["iMS"]) FOut="%s.Weights.npy"%self.DicoDATA["MSName"] self.DicoDATA.reload() # print(self.DicoDATA["WOUT"]) #self.DicoDATA["WOUT"]/=np.median(self.DicoDATA["WOUT"]) w=self.DicoDATA["WOUT"] w/=np.median(w) w[w<=0]=0 w[w>2.]=2 log.print(" saving weights as %s"%FOut) np.save(FOut,self.DicoDATA["WOUT"]) # import pylab # pylab.clf() # pylab.hist(w[:,0].ravel()) # pylab.draw() # pylab.show() #np.save(FOut,self.DicoGrids["GridSTD"]) # for iTime in range(self.NTimes): # self.Stack_SingleTime(iTime) self.Finalise()
def StackAll(self): while self.iCurrentMS < self.nMS: if self.LoadNextMS() == "NotRead": continue print("Making dynamic spectra...", file=log) for iTime in range(self.NTimes): APP.runJob("Stack_SingleTime:%d" % (iTime), self.Stack_SingleTime, args=(iTime, )) #,serial=True) APP.awaitJobResults("Stack_SingleTime:*", progress="Append MS %i" % self.DicoDATA["iMS"]) # for iTime in range(self.NTimes): # self.Stack_SingleTime(iTime) self.Finalise()
def StackAll(self): while self.iCurrentMS < self.nMS: if self.LoadNextMS() == "NotRead": continue print("Making dynamic spectra...", file=log) for iTime in range(self.NTimes): APP.runJob("Stack_SingleTime:%d" % (iTime), self.Stack_SingleTime, args=(iTime, )) #,serial=True) APP.awaitJobResults("Stack_SingleTime:*", progress="Append MS %i" % self.DicoDATA["iMS"]) FOut = "%s.Weights.npy" % self.DicoDATA["MSName"] log.print(" saving weights as %s" % FOut) self.DicoDATA.reload() # print(self.DicoDATA["WOUT"]) self.DicoDATA["WOUT"] /= np.median(self.DicoDATA["WOUT"]) np.save(FOut, self.DicoDATA["WOUT"]) # for iTime in range(self.NTimes): # self.Stack_SingleTime(iTime) self.Finalise()
def giveDicoInitIndiv(self, ListIslands, ModelImage, DicoDirty, ListDoIsland=None): DicoInitIndiv = shared_dict.create("DicoInitIsland") ParmDict = shared_dict.create("InitSSDModelHMP") ParmDict["ModelImage"] = ModelImage ParmDict["GridFreqs"] = self.GridFreqs ParmDict["DegridFreqs"] = self.DegridFreqs # ListBigIslands=[] # ListSmallIslands=[] # ListDoBigIsland=[] # ListDoSmallIsland=[] # NParallel=0 # for iIsland,Island in enumerate(ListIslands): # if len(Island)>self.GD["SSDClean"]["ConvFFTSwitch"]: # ListBigIslands.append(Island) # ListDoBigIsland.append(ListDoIsland[iIsland]) # if ListDoIsland or ListDoIsland[iIsland]: # NParallel+=1 # else: # ListSmallIslands.append(Island) # ListDoSmallIsland.append(ListDoIsland[iIsland]) # print>>log,"Initialise big islands (parallelised per island)" # pBAR= ProgressBar(Title="Init islands") # pBAR.render(0, NParallel) # nDone=0 # for iIsland,Island in enumerate(ListBigIslands): # if not ListDoIsland or ListDoBigIsland[iIsland]: # subdict = DicoInitIndiv.addSubdict(iIsland) # # APP.runJob("InitIsland:%d" % iIsland, self._initIsland_worker, # # args=(subdict.writeonly(), iIsland, Island, # # self.DicoVariablePSF.readonly(), DicoDirty.readonly(), # # ParmDict.readonly(), self.InitMachine.DeconvMachine.facetcache.readonly(),self.NCPU),serial=True) # self._initIsland_worker(subdict, iIsland, Island, # self.DicoVariablePSF, DicoDirty, # ParmDict, self.InitMachine.DeconvMachine.facetcache, # self.NCPU) # pBAR.render(nDone+1, NParallel) # nDone+=1 # # APP.awaitJobResults("InitIsland:*", progress="Init islands") # print>>log,"Initialise small islands (parallelised over islands)" # for iIsland,Island in enumerate(ListSmallIslands): # if not ListDoIsland or ListDoSmallIsland[iIsland]: # subdict = DicoInitIndiv.addSubdict(iIsland) # APP.runJob("InitIsland:%d" % iIsland, self._initIsland_worker, # args=(subdict.writeonly(), iIsland, Island, # self.DicoVariablePSF.readonly(), DicoDirty.readonly(), # ParmDict.readonly(), self.InitMachine.DeconvMachine.facetcache.readonly(),1)) # APP.awaitJobResults("InitIsland:*", progress="Init islands") # DicoInitIndiv.reload() print >> log, "Initialise islands (parallelised over islands)" if not self.GD["GAClean"]["ParallelInitHMP"]: pBAR = ProgressBar(Title=" Init islands") for iIsland, Island in enumerate(ListIslands): if not ListDoIsland or ListDoIsland[iIsland]: subdict = DicoInitIndiv.addSubdict(iIsland) self._initIsland_worker( subdict, iIsland, Island, self.DicoVariablePSF, DicoDirty, ParmDict, self.InitMachine.DeconvMachine.facetcache, 1) pBAR.render(iIsland, len(ListIslands)) else: for iIsland, Island in enumerate(ListIslands): if not ListDoIsland or ListDoIsland[iIsland]: subdict = DicoInitIndiv.addSubdict(iIsland) APP.runJob("InitIsland:%d" % iIsland, self._initIsland_worker, args=(subdict.writeonly(), iIsland, Island, self.DicoVariablePSF.readonly(), DicoDirty.readonly(), ParmDict.readonly(), self.InitMachine.DeconvMachine.facetcache. readonly(), 1)) APP.awaitJobResults("InitIsland:*", progress="Init islands") DicoInitIndiv.reload() ParmDict.delete() return DicoInitIndiv
def InitMSMF(self, approx=False, cache=True, facetcache=None): """Initializes MSMF basis functions. If approx is True, then uses the central facet's PSF for all facets. Populates the self.facetcache dict, unless facetcache is supplied """ self.DicoMSMachine = {} valid = True if facetcache is not None: print>> log, "HMP basis functions pre-initialized" self.facetcache = facetcache else: cachehash = dict( [(section, self.GD[section]) for section in ( "Data", "Beam", "Selection", "Freq", "Image", "Facets", "Weight", "RIME","DDESolutions", "Comp", "CF", "HMP")]) cachepath, valid = self.maincache.checkCache(self.CacheFileName, cachehash, reset=not cache or self.PSFHasChanged) # do not use cache in approx mode if approx or not cache: valid = False if valid: print>>log,"Initialising HMP basis functions from cache %s"%cachepath self.facetcache = shared_dict.create(self.CacheFileName) self.facetcache.restore(cachepath) else: self.facetcache = None init_cache = self.facetcache is None if init_cache: self.facetcache = shared_dict.create(self.CacheFileName) # in any mode, start by initializing a MS machine for the central facet. This will precompute the scale # functions centralFacet = self.PSFServer.DicoVariablePSF["CentralFacet"] self.DicoMSMachine[centralFacet] = MSM0 = \ self._initMSM_facet(centralFacet, self.facetcache.addSubdict(centralFacet) if init_cache else self.facetcache[centralFacet], None, self.SideLobeLevel, self.OffsetSideLobe, verbose=True) if approx: print>>log, "HMP approximation mode: using PSF of central facet (%d)" % centralFacet for iFacet in xrange(self.PSFServer.NFacets): self.DicoMSMachine[iFacet] = MSM0 elif (self.GD["Facets"]["NFacets"]==1)&(not self.GD["DDESolutions"]["DDSols"]): self.DicoMSMachine[0] = MSM0 else: # if no facet cache, init in parallel if init_cache: for iFacet in xrange(self.PSFServer.NFacets): if iFacet != centralFacet: fcdict = self.facetcache.addSubdict(iFacet) if self.ParallelMode: args=(fcdict.writeonly(), MSM0.ScaleFuncs.readonly(), self.DicoVariablePSF.readonly(), iFacet, self.SideLobeLevel, self.OffsetSideLobe, False) APP.runJob("InitHMP:%d"%iFacet, self._initMSM_handler, args=args) else: self.DicoMSMachine[iFacet] = \ self._initMSM_facet(iFacet, fcdict, None, self.SideLobeLevel, self.OffsetSideLobe, MSM0=MSM0, verbose=False) if self.ParallelMode: APP.awaitJobResults("InitHMP:*", progress="Init HMP") self.facetcache.reload() # t = ClassTimeIt.ClassTimeIt() # now reinit from cache (since cache was computed by subprocesses) for iFacet in xrange(self.PSFServer.NFacets): if iFacet not in self.DicoMSMachine: self.DicoMSMachine[iFacet] = \ self._initMSM_facet(iFacet, self.facetcache[iFacet], None, self.SideLobeLevel, self.OffsetSideLobe, MSM0=MSM0, verbose=False) # write cache to disk, unless in a mode where we explicitly don't want it if facetcache is None and not valid and cache and not approx: try: #MyPickle.DicoNPToFile(facetcache,cachepath) #cPickle.dump(facetcache, file(cachepath, 'w'), 2) print>>log," saving HMP cache to %s"%cachepath self.facetcache.save(cachepath) #self.maincache.saveCache("HMPMachine") self.maincache.saveCache(self.CacheFileName) self.PSFHasChanged=False print>>log," HMP init done" except: print>>log, traceback.format_exc() print >>log, ModColor.Str( "WARNING: HMP cache could not be written, see error report above. Proceeding anyway.")
def InitMSMF(self, approx=False, cache=True, facetcache=None): """Initializes MSMF basis functions. If approx is True, then uses the central facet's PSF for all facets. Populates the self.facetcache dict, unless facetcache is supplied """ self.DicoMSMachine = {} valid = True if facetcache is not None: print >> log, "HMP basis functions pre-initialized" self.facetcache = facetcache else: cachehash = dict([ (section, self.GD[section]) for section in ("Data", "Beam", "Selection", "Freq", "Image", "Facets", "Weight", "RIME", "Comp", "CF", "HMP") ]) cachepath, valid = self.maincache.checkCache(self.CacheFileName, cachehash, reset=not cache or self.PSFHasChanged) # do not use cache in approx mode if approx or not cache: valid = False if valid: print >> log, "Initialising HMP basis functions from cache %s" % cachepath self.facetcache = shared_dict.create(self.CacheFileName) self.facetcache.restore(cachepath) else: self.facetcache = None centralFacet = self.PSFServer.DicoVariablePSF["CentralFacet"] if approx: print >> log, "HMP approximation mode: using PSF of central facet (%d)" % centralFacet self.PSFServer.setFacet(centralFacet) MSMachine = ClassMultiScaleMachine.ClassMultiScaleMachine( self.GD, self.facetcache.addSubdict(0), self.GainMachine, NFreqBands=self.NFreqBands) MSMachine.setModelMachine(self.ModelMachine) MSMachine.setSideLobeLevel(self.SideLobeLevel, self.OffsetSideLobe) MSMachine.SetFacet(centralFacet) MSMachine.SetPSF(self.PSFServer) # ThisPSF,ThisMeanPSF) MSMachine.FindPSFExtent(verbose=True) MSMachine.MakeMultiScaleCube(verbose=True) MSMachine.MakeBasisMatrix() for iFacet in xrange(self.PSFServer.NFacets): self.DicoMSMachine[iFacet] = MSMachine else: # if no facet cache, init in parallel if self.facetcache is None: self.facetcache = shared_dict.create(self.CacheFileName) # breakout = False for iFacet in xrange(self.PSFServer.NFacets): fcdict = self.facetcache.addSubdict(iFacet) if self.ParallelMode: args = (fcdict.writeonly(), self.DicoVariablePSF.readonly(), iFacet, self.SideLobeLevel, self.OffsetSideLobe, centralFacet) APP.runJob("InitHMP:%d" % iFacet, self._initMSM_handler, args=args) else: args = (fcdict, self.DicoVariablePSF, iFacet, self.SideLobeLevel, self.OffsetSideLobe, centralFacet) self._initMSM_handler(*args) # import pdb; # pdb.set_trace() # if breakout: # raise RuntimeError("exiting") if self.ParallelMode: APP.awaitJobResults("InitHMP:*", progress="Init HMP") self.facetcache.reload() # t = ClassTimeIt.ClassTimeIt() for iFacet in xrange(self.PSFServer.NFacets): self.PSFServer.setFacet(iFacet) MSMachine = ClassMultiScaleMachine.ClassMultiScaleMachine( self.GD, self.facetcache[iFacet], self.GainMachine, NFreqBands=self.NFreqBands) MSMachine.setModelMachine(self.ModelMachine) MSMachine.setSideLobeLevel(self.SideLobeLevel, self.OffsetSideLobe) MSMachine.SetFacet(iFacet) MSMachine.SetPSF(self.PSFServer) # ThisPSF,ThisMeanPSF) MSMachine.FindPSFExtent( verbose=(iFacet == centralFacet )) # only print to log for central facet MSMachine.MakeMultiScaleCube(verbose=(iFacet == centralFacet)) MSMachine.MakeBasisMatrix() self.DicoMSMachine[iFacet] = MSMachine # write cache to disk, unless in a mode where we explicitly don't want it if facetcache is None and not valid and cache and not approx: try: #MyPickle.DicoNPToFile(facetcache,cachepath) #cPickle.dump(facetcache, file(cachepath, 'w'), 2) print >> log, " saving HMP cache to %s" % cachepath self.facetcache.save(cachepath) #self.maincache.saveCache("HMPMachine") self.maincache.saveCache(self.CacheFileName) self.PSFHasChanged = False print >> log, " HMP init done" except: print >> log, traceback.format_exc() print >> log, ModColor.Str( "WARNING: HMP cache could not be written, see error report above. Proceeding anyway." )
def InterpolParallel(self): Sols0 = self.Sols nt, nch, na, nd, _, _ = Sols0.G.shape log.print(" #Times: %i" % nt) log.print(" #Channels: %i" % nch) log.print(" #Antennas: %i" % na) log.print(" #Directions: %i" % nd) # APP.terminate() # APP.shutdown() # Multiprocessing.cleanupShm() APP.startWorkers() iJob = 0 # for iAnt in [49]:#range(na): # for iDir in [0]:#range(nd): if "TEC" in self.InterpMode: #APP.runJob("FitThisTEC_%d"%iJob, self.FitThisTEC, args=(208,)); iJob+=1 self.TECArray = NpShared.ToShared( "%sTECArray" % IdSharedMem, np.zeros((nt, nd, na), np.float32)) self.CPhaseArray = NpShared.ToShared( "%sCPhaseArray" % IdSharedMem, np.zeros((nt, nd, na), np.float32)) for it in range(nt): # for iDir in range(nd): APP.runJob("FitThisTEC_%d" % iJob, self.FitThisTEC, args=(it, )) #,serial=True) iJob += 1 workers_res = APP.awaitJobResults("FitThisTEC*", progress="Fit TEC") if "Amp" in self.InterpMode: for iAnt in range(na): for iDir in range(nd): APP.runJob("FitThisAmp_%d" % iJob, self.FitThisAmp, args=(iAnt, iDir)) #,serial=True) iJob += 1 workers_res = APP.awaitJobResults("FitThisAmp*", progress="Smooth Amp") if "PolyAmp" in self.InterpMode: for iDir in range(nd): APP.runJob("FitThisPolyAmp_%d" % iJob, self.FitThisPolyAmp, args=(iDir, )) iJob += 1 workers_res = APP.awaitJobResults("FitThisPolyAmp*", progress="Smooth Amp") if "Clip" in self.InterpMode: for iDir in range(nd): APP.runJob("ClipThisDir_%d" % iJob, self.ClipThisDir, args=(iDir, ), serial=True) iJob += 1 workers_res = APP.awaitJobResults("ClipThisDir*", progress="Clip Amp") #APP.terminate() APP.shutdown() Multiprocessing.cleanupShm()