def run(self): """ Method to read in a .bdp file and convert it to a BDP object. Parameters ---------- None Returns ------- None """ self._summary = {} if not self.getkey("file"): raise Exception("Input file name is empty, one must be given.") bdp = utils.getBDP(self.getkey("file")) self.addoutput(bdp) # Make a table of some basic BDP info for Summary. # Why in god's name do BDPs not store the name of the task that # created them?!?! The task ID attrbute is useless if the BDP came # from another flow -- which is why this task was created in # the first place! table = Table() if bdp.project != "": table.addRow(["Project", bdp.project]) if bdp.sous != "": table.addRow(["SOUS", bdp.sous]) if bdp.gous != "": table.addRow(["GOUS", bdp.gous]) if bdp.mous != "": table.addRow(["MOUS", bdp.mous]) table.addRow(["BDP Type", bdp._type]) table.addRow(["Base directory", bdp._baseDir]) table.addRow(["XML file", bdp.xmlFile]) if bdp._date != "": table.addRow(["Time stamp", bdp._date]) files = bdp.getfiles() for f in files: table.addRow(["Associated File", f]) table.description = "Information about the ingested BDP" taskargs = "file=%s" % self.getkey('file') self._summary["bdpingest"] = SummaryEntry(table.serialize(), "BDPIngest_AT", self.id(True), taskargs)
def run(self): """Runs the task. Parameters ---------- None Returns ------- None """ self._summary = {} pvslicesummary = [] sumslicetype = 'slice' sliceargs = [] dt = utils.Dtime("PVSlice") # import here, otherwise sphinx cannot parse from impv import impv from imsmooth import imsmooth pvslice = self.getkey('slice') # x_s,y_s,x_e,y_e (start and end of line) pvslit = self.getkey('slit') # x_c,y_c,len,pa (center, length and PA of line) # BDP's used : # b10 = input BDP # b11 = input BDP (moment) # b12 = input BDP (new style cubestats w/ maxpos) # b2 = output BDP b10 = self._bdp_in[0] # input SpwCube fin = b10.getimagefile(bt.CASA) # input name b11 = self._bdp_in[1] # b12 = self._bdp_in[2] clip = self.getkey('clip') # clipping to data for Moment-of-Inertia gamma = self.getkey('gamma') # gamma factor to data for Moment-of-Inertia if b11 != None and len(pvslice) == 0 and len(pvslit) == 0: # if a map (e.g. cubesum ) given, and no slice/slit, get a best pvslice from that (pvslice,clip) = map_to_slit(self.dir(b11.getimagefile(bt.CASA)),clip=clip,gamma=gamma) elif b12 != None and len(pvslice) == 0 and len(pvslit) == 0: # PPP doesn't seem to work too well yet logging.debug("testing new slice computation from a PPP") max = b12.table.getColumnByName("max") maxposx = b12.table.getColumnByName("maxposx") maxposy = b12.table.getColumnByName("maxposy") if maxposx == None: raise Exception,"PPP was not enabled in your CubeStats" (pvslice,clip) = tab_to_slit([maxposx,maxposy,max],clip=clip,gamma=gamma) sliceargs = deepcopy(pvslice) if len(sliceargs)==0: logging.warning("no slice for plot yet") # ugh, this puts single quotes around the numbers formattedslice = str(["%.2f" % a for a in sliceargs]) taskargs = "slice="+formattedslice dt.tag("slice") pvname = self.mkext(fin,'pv') # output image name b2 = PVSlice_BDP(pvname) self.addoutput(b2) width = self.getkey('width') # @todo also: "4arcsec" (can't work since it's a single keyword) if len(pvslice) == 4: start = pvslice[:2] # @todo also allow: ["14h20m20.5s","-30d45m25.4s"] end = pvslice[2:] impv(self.dir(fin), self.dir(pvname),"coords",start=start,end=end,width=width,overwrite=True) elif len(pvslit) == 4: sumslicetype = 'slit' sliceargs = deepcopy(pvslit) formattedslice = str(["%.2f" % a for a in sliceargs]) taskargs = "slit="+formattedslice # length="40arcsec" same as {"value": 40, "unit": "arcsec"}) center = pvslit[:2] # @todo also: ["14h20m20.5s","-30d45m25.4s"]. length = pvslit[2] # @todo also: "40arcsec", {"value": 40, "unit": "arcsec"}) if type(pvslit[3]) is float or type(pvslit[3]) is int: pa = "%gdeg" % pvslit[3] else: pa = pvslit[3] impv(self.dir(fin), self.dir(pvname),"length",center=center,length=length,pa=pa,width=width,overwrite=True) else: raise Exception,"no valid input slit= or slice= or bad Moment_BDP input" sliceargs.append(width) taskargs = taskargs + " width=%d" % width dt.tag("impv") smooth = self.getkey('pvsmooth') if len(smooth) > 0: if len(smooth) == 1: smooth.append(smooth[0]) major = '%dpix' % smooth[0] minor = '%dpix' % smooth[1] logging.info("imsmooth PV slice: %s %s" % (major,minor)) imsmooth(self.dir(pvname), outfile=self.dir(pvname)+'.smooth',kernel='boxcar',major=major,minor=minor) dt.tag("imsmooth") # utils.rename(self.dir(pvname)+'.smooth',self.dir(pvname)) # @todo we will keep the smooth PVslice for inspection, no further flow work # get some statistics data = casautil.getdata_raw(self.dir(pvname)) rpix = stats.robust(data.flatten()) r_mean = rpix.mean() r_std = rpix.std() r_max = rpix.max() logging.info("PV stats: mean/std/max %f %f %f" % (r_mean, r_std, r_max)) logging.regression("PVSLICE: %f %f %f" % (r_mean, r_std, r_max)) myplot = APlot(ptype=self._plot_type,pmode=self._plot_mode,abspath=self.dir()) # hack to get a slice on a mom0map # @todo if pmode is not png, can viewer handle this? figname = pvname + ".png" slicename = self.dir(figname) overlay = "pvoverlay" if b11 != None: f11 = b11.getimagefile(bt.CASA) taskinit.tb.open(self.dir(f11)) data = taskinit.tb.getcol('map') nx = data.shape[0] ny = data.shape[1] taskinit.tb.close() d1 = np.flipud(np.rot90 (data.reshape((nx,ny)))) if len(pvslice) == 4: segm = [[pvslice[0],pvslice[2],pvslice[1],pvslice[3]]] pa = np.arctan2(pvslice[2]-pvslice[0],pvslice[1]-pvslice[3])*180.0/np.pi title = "PV Slice location : slice PA=%.1f" % pa elif len(pvslit) == 4: # can only do this now if using pixel coordinates xcen = pvslit[0] ycen = ny-pvslit[1]-1 slen = pvslit[2] pard = pvslit[3]*np.pi/180.0 cosp = np.cos(pard) sinp = np.sin(pard) halflen = 0.5*slen segm = [[xcen-halflen*sinp,xcen+halflen*sinp,ycen-halflen*cosp,ycen+halflen*cosp]] pa = pvslit[3] title = "PV Slice location : slit PA=%g" % pa else: # bogus, some error in pvslice logging.warning("bogus segm since pvslice=%s" % str(pvslice)) segm = [[10,20,10,20]] pa = -999.999 title = "PV Slice location - bad PA" logging.info("MAP1 segm %s %s" % (str(segm),str(pvslice))) if d1.max() < clip: logging.warning("datamax=%g, clip=%g" % (d1.max(), clip)) title = title + ' (no signal over %g?)' % clip myplot.map1(d1,title,overlay,segments=segm,thumbnail=True) else: myplot.map1(d1,title,overlay,segments=segm,range=[clip],thumbnail=True) dt.tag("plot") overlayname = myplot.getFigure(figno=myplot.figno,relative=True) overlaythumbname = myplot.getThumbnail(figno=myplot.figno,relative=True) Qover = True else: Qover = False implot = ImPlot(pmode=self._plot_mode,ptype=self._plot_type,abspath=self.dir()) implot.plotter(rasterfile=pvname, figname=pvname, colorwedge=True) thumbname = implot.getThumbnail(figno=implot.figno,relative=True) figname = implot.getFigure(figno=implot.figno,relative=True) if False: # debug: # # @todo tmp1 is ok, tmp2 is not displaying the whole thing # old style: viewer() seems to plot full image, but imview() wants square pixels? casa.viewer(infile=self.dir(pvname), outfile=self.dir('tmp1.pv.png'), gui=False, outformat="png") casa.imview(raster={'file':self.dir(pvname), 'colorwedge' : True, 'scaling':-1}, axes={'y':'Declination'}, out=self.dir('tmp2.pv.png')) # # -> this one works, axes= should be correct # imview(raster={'file':'x.pv', 'colorwedge' : True, 'scaling':-1},axes={'y':'Frequency'}) # # @TODO big fixme, we're going to reuse 'tmp1.pv.png' because implot give a broken view figname = 'tmp1.pv.png' # @todo technically we don't know what map it was overlay'd on.... CubeSum/Moment0 overlaycaption = "Location of position-velocity slice overlaid on a CubeSum map" pvcaption = "Position-velocity diagram through emission centroid" pvimage = Image(images={bt.CASA : pvname, bt.PNG : figname},thumbnail=thumbname,thumbnailtype=bt.PNG, description=pvcaption) b2.setkey("image",pvimage) b2.setkey("mean",float(r_mean)) b2.setkey("sigma",float(r_std)) if Qover: thispvsummary = [sumslicetype,sliceargs,figname,thumbname,pvcaption,overlayname,overlaythumbname,overlaycaption,pvname,fin] else: thispvsummary = [sumslicetype,sliceargs,figname,thumbname,pvcaption,pvname,fin] # Yes, this is a nested list. Against the day when PVSLICE can # compute multiple slices per map. pvslicesummary.append(thispvsummary) self._summary["pvslices"] = SummaryEntry(pvslicesummary,"PVSlice_AT",self.id(True),taskargs) dt.tag("done") dt.end()
def run(self): """ The run method creates the BDP Parameters ---------- None Returns ------- None """ self._summary = {} dt = utils.Dtime("Smooth") dt.tag("start") # get the input keys bmaj = self.getkey("bmaj") bmin = self.getkey("bmin") bpa = self.getkey("bpa") velres = self.getkey("velres") # take care of potential issues in the unit strings # @todo if not provided? bmaj['unit'] = bmaj['unit'].lower() bmin['unit'] = bmin['unit'].lower() velres['unit'] = velres['unit'].lower() taskargs = "bmaj=%s bmin=%s bpa=%s velres=%s" % (bmaj, bmin, bpa, velres) bdpnames = [] for ibdp in self._bdp_in: istem = ibdp.getimagefile(bt.CASA) image_in = ibdp.baseDir() + istem bdp_name = self.mkext(istem, 'sim') image_out = self.dir(bdp_name) taskinit.ia.open(image_in) h = casa.imhead(image_in, mode='list') pix_scale = np.abs(h['cdelt1'] * 206265.0) # pix scale in asec @todo QA ? CC = 299792458.0 # speed of light @todo somewhere else [utils.c , but in km/s] rest_freq = h['crval3'] # frequency pixel scale in km/s vel_scale = np.abs(CC * h['cdelt3'] / rest_freq / 1000.0) # unit conversion to arcsec (spatial) or km/s # (velocity) or some flavor of Hz. if (bmaj['unit'] == 'pixel'): bmaj = bmaj['value'] * pix_scale else: bmaj = bmaj['value'] if (bmin['unit'] == 'pixel'): bmin = bmin['value'] * pix_scale else: bmin = bmin['value'] hertz_input = False if velres['unit'] == 'pixel': velres['value'] = velres['value'] * vel_scale velres['unit'] = 'km/s' elif velres['unit'] == 'm/s': velres['value'] = velres['value'] / 1000.0 velres['unit'] = 'km/s' elif velres['unit'][-2:] == 'hz': hertz_input = True elif velres['unit'] == 'km/s': pass else: logging.error("Unknown units in velres=%s" % velres['unit']) rdata = bmaj # we smooth in velocity first. if smoothing in velocity # the cube apparently must be closed afterwards and # then reopened if spatial smoothing is to be done. if velres['value'] > 0: # handle the different units allowed. CASA doesn't # like lowercase for hz units... if not hertz_input: freq_res = str( velres['value'] * 1000.0 / CC * rest_freq) + 'Hz' else: freq_res = str(velres['value']) # try to convert velres to km/s for debug purposes velres['value'] = velres['value'] / rest_freq * CC / 1000.0 if (velres['unit'] == 'khz'): velres['value'] = velres['value'] * 1000.0 velres['unit'] = 'kHz' elif (velres['unit'] == 'mhz'): velres['value'] = velres['value'] * 1E6 velres['unit'] = 'MHz' elif (velres['unit'] == 'ghz'): velres['value'] = velres['value'] * 1E9 velres['unit'] = 'GHz' freq_res = freq_res + velres['unit'] # NB: there is apparently a bug in CASA. only smoothing along the frequency # axis does not work. sepconvolve gives a unit error (says axis unit is radian rather # than Hz). MUST smooth in 2+ dimensions if you want this to work. if (velres['value'] < vel_scale): raise Exception, "Desired velocity resolution %g less than pixel scale %g" % ( velres['value'], vel_scale) image_tmp = self.dir('tmp.smooth') im2=taskinit.ia.sepconvolve(outfile=image_tmp,axes=[0,1,2], types=["boxcar","boxcar","gauss"],\ widths=['1pix','1pix',freq_res], overwrite=True) im2.done() logging.debug("sepconvolve to %s" % image_out) # for some reason, doing this in memory does not seem to work, so outfile must be specified. logging.info( "Smoothing cube to a velocity resolution of %s km/s" % str(velres['value'])) logging.info("Smoothing cube to a frequency resolution of %s" % freq_res) taskinit.ia.close() taskinit.ia.open(image_tmp) dt.tag("sepconvolve") else: image_tmp = image_out # now do the spatial smoothing convolve_to_min_beam = True # default is to convolve to a min enclosing beam if bmaj > 0 and bmin > 0: # form qa objects out of these so that casa can understand bmaj = taskinit.qa.quantity(bmaj, 'arcsec') bmin = taskinit.qa.quantity(bmin, 'arcsec') bpa = taskinit.qa.quantity(bpa, 'deg') target_res = {} target_res['major'] = bmaj target_res['minor'] = bmin target_res['positionangle'] = bpa # throw an exception if cannot be convolved try: # for whatever reason, if you give convolve2d a beam parameter, # it complains ... im2=taskinit.ia.convolve2d(outfile=image_out,major = bmaj,\ minor = bmin, pa = bpa,\ targetres=True,overwrite=True) im2.done() logging.info( "Smoothing cube to a resolution of %s by %s at a PA of %s" % (str(bmaj['value']), str( bmin['value']), str(bpa['value']))) convolve_to_min_beam = False achieved_res = target_res except: # @todo remind what you need ? logging.error("Warning: Could not convolve to requested resolution of "\ +str(bmaj['value']) + " by " + str(bmin['value']) + \ " at a PA of "+ str(bpa['value'])) raise Exception, "Could not convolve to beam given!" dt.tag("convolve2d-1") if convolve_to_min_beam: restoring_beams = taskinit.ia.restoringbeam() commonbeam = taskinit.ia.commonbeam() # for whatever reason, setrestoringbeam does not use the same set of hashes... commonbeam['positionangle'] = commonbeam['pa'] del commonbeam['pa'] # if there's one beam, apparently the beams keyword does not exist if 'beams' in restoring_beams: print "Smoothing cube to a resolution of "+ \ str(commonbeam['major']['value']) +" by "+ \ str(commonbeam['minor']['value'])+" at a PA of "\ +str(commonbeam['pa']['value']) target_res = commonbeam im2=taskinit.ia.convolve2d(outfile=image_out,major=commonbeam['major'],\ minor=commonbeam['minor'],\ pa=commonbeam['positionangle'],\ targetres=True,overwrite=True) im2.done() achieved_res = commonbeam dt.tag("convolve2d-2") else: print "One beam for all planes. Smoothing to common beam redundant." achieved_res = commonbeam if velres['value'] < 0: taskinit.ia.fromimage(outfile=image_out, infile=image_in) # not really doing anything # else, we've already done what we needed to taskinit.ia.setrestoringbeam(beam=achieved_res) rdata = achieved_res['major']['value'] # else do no smoothing and just close the image taskinit.ia.close() dt.tag("close") b1 = SpwCube_BDP(bdp_name) self.addoutput(b1) # need to update for multiple images. b1.setkey("image", Image(images={bt.CASA: bdp_name})) bdpnames = bdpnames.append(bdp_name) # and clean up the temp image before the next image if velres['value'] > 0: utils.remove(image_tmp) # thes are task arguments not summary entries. _bmaj = taskinit.qa.convert(achieved_res['major'], 'rad')['value'] _bmin = taskinit.qa.convert(achieved_res['minor'], 'rad')['value'] _bpa = taskinit.qa.convert(achieved_res['positionangle'], 'deg')['value'] vres = "%.2f %s" % (velres['value'], velres['unit']) logging.regression("SMOOTH: %f %f" % (rdata, velres['value'])) self._summary["smooth"] = SummaryEntry( [bdp_name, convolve_to_min_beam, _bmaj, _bmin, _bpa, vres], "Smooth_AT", self.id(True), taskargs) dt.tag("done") dt.end()
def run(self): dt = utils.Dtime("PVCorr") self._summary = {} numsigma = self.getkey("numsigma") mode = 1 # PV corr mode (1,2,3) normalize = True # normalize = False b1 = self._bdp_in[0] # PVSlice_BDP fin = b1.getimagefile(bt.CASA) # CASA image data = casautil.getdata_raw( self.dir(fin)) # grab the data as a numpy array self.myplot = APlot(ptype=self._plot_type, pmode=self._plot_mode, abspath=self.dir()) #print 'DATA[0,0]:',data[0,0] #print 'pv shape: ',data.shape npos = data.shape[0] nvel = data.shape[1] dt.tag("getdata") b2 = self._bdp_in[1] # CubeStats_BDP sigma = b2.sigma # global sigma in the cube cutoff = numsigma * sigma freq = b2.table.getColumnByName("frequency") chans = self.getkey("range") # range of channels, if used if len(chans) > 0: if len(chans) != 2: logging.fatal("range=%s" % chans) raise Exception, "range= needs two values, left and right (inclusive) channel" ch0 = chans[0] ch1 = chans[1] else: nchan = self.getkey("nchan") imstat0 = casa.imstat(self.dir(fin)) # @todo can use data[] now xmaxpos = imstat0['maxpos'][0] ymaxpos = imstat0['maxpos'][1] logging.info("MAXPOS-VEL %s %g" % (str(imstat0['maxpos']), imstat0['max'][0])) if nchan > 0: # expand around it, later ch0,ch1 will be checked for running off the edge ch0 = ymaxpos - nchan / 2 ch1 = ymaxpos + nchan / 2 else: # watershed down to find ch0 and ch1 ? # this doesn't work well in crowded areas ch0 = ymaxpos ch1 = ymaxpos spmax = data.max(axis=0) k = spmax.argmax() n = len(spmax) logging.debug('spmax %s %d %g' % (str(spmax.shape), k, spmax[k])) # find lower cutoff for i in range(n): ch0 = ymaxpos - i if ch0 < 0: break if spmax[ch0] < cutoff: break ch0 = ch0 + 1 # find higher cutoff for i in range(n): ch1 = ymaxpos + i if ch1 == n: break if spmax[ch1] < cutoff: break ch1 = ch1 - 1 dt.tag("imstat") bdp_name = self.mkext(fin, "pvc") # output PVCorr_BDP b3 = PVCorr_BDP(bdp_name) self.addoutput(b3) if ch0 < 0 or ch1 >= nvel: # this probably only happens to small cubes (problematic for PVCorr) # or when the strongest line is really close to the edge of the band # (which is probably ok) if ch0 < 0 and ch1 >= nvel: logging.warning("Serious issues with the size of this cube") if ch0 < 0: logging.warning("Resetting ch0 edge to 0") ch0 = 0 if ch1 >= nvel: ch1 = nvel - 1 logging.warning("Resetting ch1 edge to the maximum") if ch0 > ch1: logging.warning("Sanity swapping ch0,1 due to likely noisy data") ch0, ch1 = ch1, ch0 if mode == 1: out, rms = mode1(data, ch0, ch1, cutoff, normalize) corr = out elif mode == 2: out, rms = mode2(data, ch0, ch1, cutoff) # slower 2D version corr = out[ npos / 2, :] # center cut, but could also try feature detection elif mode == 3: out, rms = self.mode3(data, ch0, ch1, cutoff) # Doug's faster 2D version # get the peak of each column corr = np.amax(out, axis=0) # print "PVCORR SHAPE ",corr.shape," mode", mode if len(corr) > 0: # print "SHAPE out:",out.shape,corr.shape,npos/2 ch = range(len(corr)) if len(corr) != len(freq): logging.fatal("ch (%d) and freq (%d) do not have same size" % (len(corr), len(freq))) raise Exception, "ch and freq do not have same dimension" dt.tag("mode") labels = ["channel", "frequency", "pvcorr"] units = ["number", "GHz", "N/A"] data = (ch, freq, corr) table = Table(columns=labels, units=units, data=np.column_stack(data)) else: # still construct a table, but with no rows labels = ["channel", "frequency", "pvcorr"] units = ["number", "GHz", "N/A"] table = Table(columns=labels, units=units) b3.setkey("table", table) b3.setkey("sigma", float(rms)) dt.tag("table") if len(corr) > 0: table.exportTable(self.dir("testPVCorr.tab"), cols=['frequency', 'pvcorr']) test_single(ch, freq, corr) logging.regression("PVC: %f %f" % (corr.min(), corr.max())) title = 'PVCorr mode=%d [%d,%d] %g' % (mode, ch0, ch1, cutoff) x = ch xlab = 'Channel' y = [corr] ylab = 'PV Correlation' p1 = "%s_%d" % (bdp_name, 0) segp = [] segp.append([0, len(ch), 0.0, 0.0]) segp.append([0, len(ch), 3.0 * rms, 3.0 * rms]) # @todo: in principle we know with given noise and size of box, what the sigma in pvcorr should be self.myplot.plotter(x, y, title, figname=p1, xlab=xlab, ylab=ylab, segments=segp, thumbnail=True) #out1 = np.rot90 (data.reshape((nvel,npos)) ) if mode > 1: self.myplot.map1(data=out, title="testing PVCorr_AT: mode%d" % mode, figname='testPVCorr', thumbnail=True) taskargs = "numsigma=%.1f range=[%d,%d]" % (numsigma, ch0, ch1) caption = "Position-velocity correlation plot" thumbname = self.myplot.getThumbnail(figno=self.myplot.figno, relative=True) figname = self.myplot.getFigure(figno=self.myplot.figno, relative=True) image = Image(images={bt.PNG: figname}, thumbnail=thumbname, thumbnailtype=bt.PNG, description=caption) b3.image.addimage(image, "pvcorr") self._summary["pvcorr"] = SummaryEntry( [figname, thumbname, caption, fin], "PVCorr_AT", self.id(True), taskargs) else: self._summary["pvcorr"] = None logging.warning("No summary") logging.regression("PVC: -1") dt.tag("done") dt.end()
def run(self): """Runs the task. Parameters ---------- None Returns ------- None """ self._summary = {} dt = utils.Dtime("CubeStats") #maxvrms = 2.0 # maximum variation in rms allowed (hardcoded for now) #maxvrms = -1.0 # turn maximum variation in rms allowed off maxvrms = self.getkey("maxvrms") psample = -1 psample = self.getkey("psample") # BDP's used : # b1 = input BDP # b2 = output BDP b1 = self._bdp_in[0] fin = b1.getimagefile(bt.CASA) bdp_name = self.mkext(fin,'cst') b2 = CubeStats_BDP(bdp_name) self.addoutput(b2) # PeakPointPlot use_ppp = self.getkey("ppp") # peakstats: not enabled for mortal users yet # peakstats = (psample=1, numsigma=4, minchan=3, maxgap=2, peakfit=False) pnumsigma = 4 minchan = 3 maxgap = 2 peakfit = False # True will enable a true gaussian fit # numsigma: adding all signal > numsigma ; not user enabled; for peaksum. numsigma = -1.0 numsigma = 3.0 # grab the new robust statistics. If this is used, 'rms' will be the RMS, # else we will use RMS = 1.4826*MAD (MAD does a decent job on outliers as well) # and was the only method available before CASA 4.4 when robust was implemented robust = self.getkey("robust") rargs = casautil.parse_robust(robust) nrargs = len(rargs) if nrargs == 0: sumrargs = "medabsdevmed" # for the summary, indicate the default robust else: sumrargs = str(rargs) self._summary["rmsmethd"] = SummaryEntry([sumrargs,fin],"CubeStats_AT",self.id(True)) #@todo think about using this instead of putting 'fin' in all the SummaryEntry #self._summary["casaimage"] = SummaryEntry(fin,"CubeStats_AT",self.id(True)) # extra CASA call to get the freq's in GHz, as these are not in imstat1{} # @todo what if the coordinates are not in FREQ ? # Note: CAS-7648 bug on 3D cubes if False: # csys method ia.open(self.dir(fin)) csys = ia.coordsys() spec_axis = csys.findaxisbyname("spectral") # ieck, we need a valid position, or else it will come back and "Exception: All selected pixels are masked" #freqs = ia.getprofile(spec_axis, region=rg.box([0,0],[0,0]))['coords']/1e9 #freqs = ia.getprofile(spec_axis)['coords']/1e9 freqs = ia.getprofile(spec_axis,unit="GHz")['coords'] dt.tag("getprofile") else: # old imval method #imval0 = casa.imval(self.dir(fin),box='0,0,0,0') # this fails on 3D imval0 = casa.imval(self.dir(fin)) freqs = imval0['coords'].transpose()[2]/1e9 dt.tag("imval") nchan = len(freqs) chans = np.arange(nchan) # call CASA to get what we want # imstat0 is the whole cube, imstat1 the plane based statistics # warning: certain robust stats (**rargs) on the whole cube are going to be very slow dt.tag("start") imstat0 = casa.imstat(self.dir(fin), logfile=self.dir('imstat0.logfile'),append=False,**rargs) dt.tag("imstat0") imstat1 = casa.imstat(self.dir(fin),axes=[0,1],logfile=self.dir('imstat1.logfile'),append=False,**rargs) dt.tag("imstat1") # imm = casa.immoments(self.dir(fin),axis='spec', moments=8, outfile=self.dir('ppp.im')) if nrargs > 0: # need to get the peaks without rubust imstat10 = casa.imstat(self.dir(fin), logfile=self.dir('imstat0.logfile'),append=True) dt.tag("imstat10") imstat11 = casa.imstat(self.dir(fin),axes=[0,1],logfile=self.dir('imstat1.logfile'),append=True) dt.tag("imstat11") # grab the relevant plane-based things from imstat1 if nrargs == 0: mean = imstat1["mean"] sigma = imstat1["medabsdevmed"]*1.4826 # see also: astropy.stats.median_absolute_deviation() peakval = imstat1["max"] minval = imstat1["min"] else: mean = imstat1["mean"] sigma = imstat1["rms"] peakval = imstat11["max"] minval = imstat11["min"] if True: # work around a bug in imstat(axes=[0,1]) for last channel [CAS-7697] for i in range(len(sigma)): if sigma[i] == 0.0: minval[i] = peakval[i] = 0.0 # too many variations in the RMS ? sigma_pos = sigma[np.where(sigma>0)] smin = sigma_pos.min() smax = sigma_pos.max() logging.info("sigma varies from %f to %f; %d/%d channels ok" % (smin,smax,len(sigma_pos),len(sigma))) if maxvrms > 0: if smax/smin > maxvrms: cliprms = smin * maxvrms logging.warning("sigma varies too much, going to clip to %g (%g > %g)" % (cliprms, smax/smin, maxvrms)) sigma = np.where(sigma < cliprms, sigma, cliprms) # @todo (and check again) for foobar.fits all sigma's became 0 when robust was selected # was this with mask=True/False? # PeakPointPlot (can be expensive, hence the option) if use_ppp: logging.info("Computing MaxPos for PeakPointPlot") xpos = np.zeros(nchan) ypos = np.zeros(nchan) peaksum = np.zeros(nchan) ia.open(self.dir(fin)) for i in range(nchan): if sigma[i] > 0.0: plane = ia.getchunk(blc=[0,0,i,-1],trc=[-1,-1,i,-1],dropdeg=True) v = ma.masked_invalid(plane) v_abs = np.absolute(v) max = np.unravel_index(v_abs.argmax(), v_abs.shape) xpos[i] = max[0] ypos[i] = max[1] if numsigma > 0.0: peaksum[i] = ma.masked_less(v,numsigma * sigma[i]).sum() peaksum = np.nan_to_num(peaksum) # put 0's where nan's are found ia.close() dt.tag("ppp") nzeros = len(np.where(sigma<=0.0)) if nzeros > 0: zeroch = np.where(sigma<=0.0) logging.warning("There are %d fully masked channels (%s)" % (nzeros,str(zeroch))) # construct the admit Table for CubeStats_BDP # note data needs to be a tuple, later to be column_stack'd if use_ppp: labels = ["channel" ,"frequency" ,"mean" ,"sigma" ,"max" ,"maxposx" ,"maxposy" ,"min", "peaksum"] units = ["number" ,"GHz" ,"Jy/beam" ,"Jy/beam" ,"Jy/beam" ,"number" ,"number" ,"Jy/beam", "Jy"] data = (chans ,freqs ,mean ,sigma ,peakval ,xpos ,ypos ,minval, peaksum) else: labels = ["channel" ,"frequency" ,"mean" ,"sigma" ,"max" ,"min"] units = ["number" ,"GHz" ,"Jy/beam" ,"Jy/beam" ,"Jy/beam" ,"Jy/beam"] data = (chans ,freqs ,mean ,sigma ,peakval ,minval) table = Table(columns=labels,units=units,data=np.column_stack(data)) b2.setkey("table",table) # get the full cube statistics, it depends if robust was pre-selected if nrargs == 0: mean0 = imstat0["mean"][0] sigma0 = imstat0["medabsdevmed"][0]*1.4826 peak0 = imstat0["max"][0] b2.setkey("mean" , float(mean0)) b2.setkey("sigma", float(sigma0)) b2.setkey("minval",float(imstat0["min"][0])) b2.setkey("maxval",float(imstat0["max"][0])) b2.setkey("minpos",imstat0["minpos"][:3].tolist()) #? [] or array(..dtype=int32) ?? b2.setkey("maxpos",imstat0["maxpos"][:3].tolist()) #? [] or array(..dtype=int32) ?? logging.info("CubeMax: %f @ %s" % (imstat0["max"][0],str(imstat0["maxpos"]))) logging.info("CubeMin: %f @ %s" % (imstat0["min"][0],str(imstat0["minpos"]))) logging.info("CubeRMS: %f" % sigma0) else: mean0 = imstat0["mean"][0] sigma0 = imstat0["rms"][0] peak0 = imstat10["max"][0] b2.setkey("mean" , float(mean0)) b2.setkey("sigma", float(sigma0)) b2.setkey("minval",float(imstat10["min"][0])) b2.setkey("maxval",float(imstat10["max"][0])) b2.setkey("minpos",imstat10["minpos"][:3].tolist()) #? [] or array(..dtype=int32) ?? b2.setkey("maxpos",imstat10["maxpos"][:3].tolist()) #? [] or array(..dtype=int32) ?? logging.info("CubeMax: %f @ %s" % (imstat10["max"][0],str(imstat10["maxpos"]))) logging.info("CubeMin: %f @ %s" % (imstat10["min"][0],str(imstat10["minpos"]))) logging.info("CubeRMS: %f" % sigma0) b2.setkey("robust",robust) rms_ratio = imstat0["rms"][0]/sigma0 logging.info("RMS Sanity check %f" % rms_ratio) if rms_ratio > 1.5: logging.warning("RMS sanity check = %f. Either bad sidelobes, lotsa signal, or both" % rms_ratio) logging.regression("CST: %f %f" % (sigma0, rms_ratio)) # plots: no plots need to be made when nchan=1 for continuum # however we could make a histogram, overlaying the "best" gauss so # signal deviations are clear? logging.info('mean,rms,S/N=%f %f %f' % (mean0,sigma0,peak0/sigma0)) if nchan == 1: # for a continuum/1-channel we only need to stuff some numbers into the _summary self._summary["chanrms"] = SummaryEntry([float(sigma0), fin], "CubeStats_AT", self.id(True)) self._summary["dynrange"] = SummaryEntry([float(peak0)/float(sigma0), fin], "CubeStats_AT", self.id(True)) self._summary["datamean"] = SummaryEntry([float(mean0), fin], "CubeStats_AT", self.id(True)) else: y1 = np.log10(ma.masked_invalid(peakval)) y2 = np.log10(ma.masked_invalid(sigma)) y3 = y1-y2 y4 = np.log10(ma.masked_invalid(-minval)) y5 = y1-y4 y = [y1,y2,y3,y4] title = 'CubeStats: ' + bdp_name+'_0' xlab = 'Channel' ylab = 'log(Peak,Noise,Peak/Noise)' labels = ['log(peak)','log(rms noise)','log(peak/noise)','log(|minval|)'] myplot = APlot(ptype=self._plot_type,pmode=self._plot_mode,abspath=self.dir()) segp = [[chans[0],chans[nchan-1],math.log10(sigma0),math.log10(sigma0)]] myplot.plotter(chans,y,title,bdp_name+"_0",xlab=xlab,ylab=ylab,segments=segp,labels=labels,thumbnail=True) imfile = myplot.getFigure(figno=myplot.figno,relative=True) thumbfile = myplot.getThumbnail(figno=myplot.figno,relative=True) image0 = Image(images={bt.PNG:imfile},thumbnail=thumbfile,thumbnailtype=bt.PNG,description="CubeStats_0") b2.addimage(image0,"im0") if use_ppp: # new trial for Lee title = 'PeakSum: (numsigma=%.1f)' % (numsigma) ylab = 'Jy*N_ppb' myplot.plotter(chans,[peaksum],title,bdp_name+"_00",xlab=xlab,ylab=ylab,thumbnail=False) if True: # hack ascii table y30 = np.where(sigma > 0, np.log10(peakval/sigma), 0.0) table2 = Table(columns=["freq","log(P/N)"],data=np.column_stack((freqs,y30))) table2.exportTable(self.dir("testCubeStats.tab")) del table2 # the "box" for the "spectrum" is all pixels. Don't know how to # get this except via shape. ia.open(self.dir(fin)) s = ia.summary() ia.close() if 'shape' in s: specbox = (0,0,s['shape'][0],s['shape'][1]) else: specbox = () caption = "Emission characteristics as a function of channel, as derived by CubeStats_AT " caption += "(cyan: global rms," caption += " green: noise per channel," caption += " blue: peak value per channel," caption += " red: peak/noise per channel)." self._summary["spectra"] = SummaryEntry([0, 0, str(specbox), 'Channel', imfile, thumbfile , caption, fin], "CubeStats_AT", self.id(True)) self._summary["chanrms"] = SummaryEntry([float(sigma0), fin], "CubeStats_AT", self.id(True)) # @todo Will imstat["max"][0] always be equal to s['datamax']? If not, why not? if 'datamax' in s: self._summary["dynrange"] = SummaryEntry([float(s['datamax']/sigma0), fin], "CubeStats_AT", self.id(True)) else: self._summary["dynrange"] = SummaryEntry([float(imstat0["max"][0]/sigma0), fin], "CubeStats_AT", self.id(True)) self._summary["datamean"] = SummaryEntry([imstat0["mean"][0], fin], "CubeStats_AT", self.id(True)) title = bdp_name + "_1" xlab = 'log(Peak,Noise,P/N)' myplot.histogram([y1,y2,y3],title,bdp_name+"_1",xlab=xlab,thumbnail=True) imfile = myplot.getFigure(figno=myplot.figno,relative=True) thumbfile = myplot.getThumbnail(figno=myplot.figno,relative=True) image1 = Image(images={bt.PNG:imfile},thumbnail=thumbfile,thumbnailtype=bt.PNG,description="CubeStats_1") b2.addimage(image1,"im1") # note that the 'y2' can have been clipped, which can throw off stats.robust() # @todo should set a mask for those. title = bdp_name + "_2" xlab = 'log(Noise))' n = len(y2) ry2 = stats.robust(y2) y2_mean = ry2.mean() y2_std = ry2.std() if n>9: logging.debug("NORMALTEST2: %s" % str(scipy.stats.normaltest(ry2))) myplot.hisplot(y2,title,bdp_name+"_2",xlab=xlab,gauss=[y2_mean,y2_std],thumbnail=True) title = bdp_name + "_3" xlab = 'log(diff[Noise])' n = len(y2) # dy2 = y2[0:-2] - y2[1:-1] dy2 = ma.masked_equal(y2[0:-2] - y2[1:-1],0.0).compressed() rdy2 = stats.robust(dy2) dy2_mean = rdy2.mean() dy2_std = rdy2.std() if n>9: logging.debug("NORMALTEST3: %s" % str(scipy.stats.normaltest(rdy2))) myplot.hisplot(dy2,title,bdp_name+"_3",xlab=xlab,gauss=[dy2_mean,dy2_std],thumbnail=True) title = bdp_name + "_4" xlab = 'log(Signal/Noise))' n = len(y3) ry3 = stats.robust(y3) y3_mean = ry3.mean() y3_std = ry3.std() if n>9: logging.debug("NORMALTEST4: %s" % str(scipy.stats.normaltest(ry3))) myplot.hisplot(y3,title,bdp_name+"_4",xlab=xlab,gauss=[y3_mean,y3_std],thumbnail=True) title = bdp_name + "_5" xlab = 'log(diff[Signal/Noise)])' n = len(y3) dy3 = y3[0:-2] - y3[1:-1] rdy3 = stats.robust(dy3) dy3_mean = rdy3.mean() dy3_std = rdy3.std() if n>9: logging.debug("NORMALTEST5: %s" % str(scipy.stats.normaltest(rdy3))) myplot.hisplot(dy3,title,bdp_name+"_5",xlab=xlab,gauss=[dy3_mean,dy3_std],thumbnail=True) title = bdp_name + "_6" xlab = 'log(Peak+Min)' n = len(y1) ry5 = stats.robust(y5) y5_mean = ry5.mean() y5_std = ry5.std() if n>9: logging.debug("NORMALTEST6: %s" % str(scipy.stats.normaltest(ry5))) myplot.hisplot(y5,title,bdp_name+"_6",xlab=xlab,gauss=[y5_mean,y5_std],thumbnail=True) logging.debug("LogPeak: m,s= %f %f min/max %f %f" % (y1.mean(),y1.std(),y1.min(),y1.max())) logging.debug("LogNoise: m,s= %f %f %f %f min/max %f %f" % (y2.mean(),y2.std(),y2_mean,y2_std,y2.min(),y2.max())) logging.debug("LogDeltaNoise: RMS/sqrt(2)= %f %f " % (dy2.std()/math.sqrt(2),dy2_std/math.sqrt(2))) logging.debug("LogDeltaP/N: RMS/sqrt(2)= %f %f" % (dy3.std()/math.sqrt(2),dy3_std/math.sqrt(2))) logging.debug("LogPeak+Min: robust m,s= %f %f" % (y5_mean,y5_std)) # compute two ratios that should both be near 1.0 if noise is 'normal' ratio = y2.std()/(dy2.std()/math.sqrt(2)) ratio2 = y2_std/(dy2_std/math.sqrt(2)) logging.info("RMS BAD VARIATION RATIO: %f %f" % (ratio,ratio2)) # making PPP plot if nchan > 1 and use_ppp: smax = 10 gamma = 0.75 z0 = peakval/peakval.max() # point sizes s = np.pi * ( smax * (z0**gamma) )**2 cmds = ["grid", "axis equal"] title = "Peak Points per channel" pppimage = bdp_name + '_ppp' myplot.scatter(xpos,ypos,title=title,figname=pppimage,size=s,color=chans,cmds=cmds,thumbnail=True) pppimage = myplot.getFigure(figno=myplot.figno,relative=True) pppthumbnail = myplot.getThumbnail(figno=myplot.figno,relative=True) caption = "Peak point plot: Locations of per-channel peaks in the image cube " + fin self._summary["peakpnt"] = SummaryEntry([pppimage, pppthumbnail, caption, fin], "CubeStats_AT", self.id(True)) dt.tag("plotting") # making PeakStats plot if nchan > 1 and psample > 0: logging.info("Computing peakstats") # grab peak,mean and width values for all peaks (pval,mval,wval) = peakstats(self.dir(fin),freqs,sigma0,pnumsigma,minchan,maxgap,psample,peakfit) title = "PeakStats: cutoff = %g" % (sigma0*pnumsigma) xlab = 'Peak value' ylab = 'FWHM (channels)' pppimage = bdp_name + '_peakstats' cval = mval myplot.scatter(pval,wval,title=title,xlab=xlab,ylab=ylab,color=cval,figname=pppimage,thumbnail=False) dt.tag("peakstats") # myplot.final() # pjt debug # all done! dt.tag("done") taskargs = "robust=" + sumrargs if use_ppp: taskargs = taskargs + " ppp=True" else: taskargs = taskargs + " ppp=False" for v in self._summary: self._summary[v].setTaskArgs(taskargs) dt.tag("summary") dt.end()
def run(self): """Runs the task. Parameters ---------- None Returns ------- None """ self._summary = {} dt = utils.Dtime("CubeSpectrum") # our BDP's # b1 = input BDP # b1s = optional input CubeSpectrum # b1m = optional input Moment # b1p = optional input SourceList for positions # b2 = output BDP b1 = self._bdp_in[0] # check input SpwCube (or LineCube) fin = b1.getimagefile(bt.CASA) if self._bdp_in[0]._type == bt.LINECUBE_BDP: use_vel = True else: use_vel = False sources = self.getkey("sources") pos = [ ] # blank it first, then try and grab it from the optional bdp_in's cmean = 0.0 csigma = 0.0 smax = [] # accumulate max in each spectrum for regression self.spec_description = [] # for summary() if self._bdp_in[1] != None: # check if CubeStats_BDP #print "BDP[1] type: ",self._bdp_in[1]._type if self._bdp_in[1]._type != bt.CUBESTATS_BDP: raise Exception, "bdp_in[1] not a CubeStats_BDP, should never happen" # a table (cubestats) b1s = self._bdp_in[1] pos.append(b1s.maxpos[0]) pos.append(b1s.maxpos[1]) logging.info('CubeStats::maxpos,val=%s,%f' % (str(b1s.maxpos), b1s.maxval)) cmean = b1s.mean csigma = b1s.sigma dt.tag("CubeStats-pos") if self._bdp_in[ 2] != None: # check if Moment_BDP (probably from CubeSum) #print "BDP[2] type: ",self._bdp_in[2]._type if self._bdp_in[2]._type != bt.MOMENT_BDP: raise Exception, "bdp_in[2] not a Moment_BDP, should never happen" b1m = self._bdp_in[2] fim = b1m.getimagefile(bt.CASA) pos1, maxval = self.maxpos_im( self.dir(fim)) # compute maxpos, since it is not in bdp (yet) logging.info('CubeSum::maxpos,val=%s,%f' % (str(pos1), maxval)) pos.append(pos1[0]) pos.append(pos1[1]) dt.tag("Moment-pos") if self._bdp_in[3] != None: # check if SourceList #print "BDP[3] type: ",self._bdp_in[3]._type # a table (SourceList) b1p = self._bdp_in[3] ra = b1p.table.getFullColumnByName("RA") dec = b1p.table.getFullColumnByName("DEC") peak = b1p.table.getFullColumnByName("Peak") if sources == []: # use the whole SourceList for (r, d, p) in zip(ra, dec, peak): rdc = convert_sexa(r, d) pos.append(rdc[0]) pos.append(rdc[1]) logging.info('SourceList::maxpos,val=%s,%f' % (str(rdc), p)) else: # select specific ones from the source list for ipos in sources: if ipos < len(ra): radec = convert_sexa(ra[ipos], dec[ipos]) pos.append(radec[0]) pos.append(radec[1]) logging.info('SourceList::maxpos,val=%s,%f' % (str(radec), peak[ipos])) else: logging.warning('Skipping illegal source number %d' % ipos) dt.tag("SourceList-pos") # if pos[] still blank, use the AT keyword. if len(pos) == 0: pos = self.getkey("pos") # if still none, try the map center if len(pos) == 0: # @todo this could result in a masked pixel and cause further havoc # @todo could also take the reference pixel, but that could be outside image taskinit.ia.open(self.dir(fin)) s = taskinit.ia.summary() pos = [int(s['shape'][0]) / 2, int(s['shape'][1]) / 2] logging.warning( "No input positions supplied, map center choosen: %s" % str(pos)) dt.tag("map-center") # exhausted all sources where pos[] can be set; if still zero, bail out if len(pos) == 0: raise Exception, "No positions found from input BDP's or pos=" # convert this regular list to a list of tuples with duplicates removed # sadly the order is lost. pos = list(set(zip(pos[0::2], pos[1::2]))) npos = len(pos) dt.tag("open") bdp_name = self.mkext(fin, "csp") b2 = CubeSpectrum_BDP(bdp_name) self.addoutput(b2) imval = range(npos) # spectra, one for each pos (placeholder) planes = range(npos) # labels for the tables (placeholder) images = {} # png's accumulated for i in range(npos): # loop over pos, they can have mixed types now sd = [] caption = "Spectrum" xpos = pos[i][0] ypos = pos[i][1] if type(xpos) != type(ypos): print "POS:", xpos, ypos raise Exception, "position pair not of the same type" if type(xpos) == int: # for integers, boxes are allowed, even multiple box = '%d,%d,%d,%d' % (xpos, ypos, xpos, ypos) # convention for summary is (box) cbox = '(%d,%d,%d,%d)' % (xpos, ypos, xpos, ypos) # use extend here, not append, we want individual values in a list sd.extend([xpos, ypos, cbox]) caption = "Average Spectrum at %s" % cbox if False: # this will fail on 3D cubes (see CAS-7648) imval[i] = casa.imval(self.dir(fin), box=box) else: # work around that CAS-7648 bug # another approach is the ia.getprofile(), see CubeStats, this will # also integrate over regions, imval will not (!!!) region = 'centerbox[[%dpix,%dpix],[1pix,1pix]]' % (xpos, ypos) caption = "Average Spectrum at %s" % region imval[i] = casa.imval(self.dir(fin), region=region) elif type(xpos) == str: # this is tricky, to stay under 1 pixel , or you get a 2x2 back. region = 'centerbox[[%s,%s],[1pix,1pix]]' % (xpos, ypos) caption = "Average Spectrum at %s" % region sd.extend([xpos, ypos, region]) imval[i] = casa.imval(self.dir(fin), region=region) else: print "Data type: ", type(xpos) raise Exception, "Data type for region not handled" dt.tag("imval") flux = imval[i]['data'] if len(flux.shape ) > 1: # rare case if we step on a boundary between cells? logging.warning( "source %d has spectrum shape %s: averaging the spectra" % (i, repr(flux.shape))) flux = np.average(flux, axis=0) logging.debug('minmax: %f %f %d' % (flux.min(), flux.max(), len(flux))) smax.append(flux.max()) if i == 0: # for first point record few extra things if len(imval[i]['coords'].shape) == 2: # normal case: 1 pixel freqs = imval[i]['coords'].transpose( )[2] / 1e9 # convert to GHz @todo: input units ok? elif len(imval[i]['coords'].shape ) == 3: # rare case if > 1 point in imval() freqs = imval[i]['coords'][0].transpose( )[2] / 1e9 # convert to GHz @todo: input units ok? else: logging.fatal( "bad shape %s in freq return from imval - SHOULD NEVER HAPPEN" % imval[i]['coords'].shape) chans = np.arange(len(freqs)) # channels 0..nchans-1 unit = imval[i]['unit'] restfreq = casa.imhead( self.dir(fin), mode="get", hdkey="restfreq")['value'] / 1e9 # in GHz dt.tag("imhead") vel = ( 1 - freqs / restfreq ) * utils.c # @todo : use a function (and what about relativistic?) # construct the Table for CubeSpectrum_BDP # @todo note data needs to be a tuple, later to be column_stack'd labels = ["channel", "frequency", "flux"] units = ["number", "GHz", unit] data = (chans, freqs, flux) if i == 0: # plane 0 : we are allowing a multiplane table, so the first plane is special table = Table(columns=labels, units=units, data=np.column_stack(data), planes=["0"]) else: # planes 1,2,3.... are stacked onto the previous one table.addPlane(np.column_stack(data), "%d" % i) # example plot , one per position for now if use_vel: x = vel xlab = 'VLSR (km/s)' else: x = chans xlab = 'Channel' y = [flux] sd.append(xlab) if type(xpos) == int: # grab the RA/DEC... kludgy h = casa.imstat(self.dir(fin), box=box) ra = h['blcf'].split(',')[0] dec = h['blcf'].split(',')[1] title = '%s %d @ %d,%d = %s,%s' % (bdp_name, i, xpos, ypos, ra, dec) else: title = '%s %d @ %s,%s' % ( bdp_name, i, xpos, ypos ) # or use box, once we allow non-points myplot = APlot(ptype=self._plot_type, pmode=self._plot_mode, abspath=self.dir()) ylab = 'Flux (%s)' % unit p1 = "%s_%d" % (bdp_name, i) myplot.plotter(x, y, title, p1, xlab=xlab, ylab=ylab, thumbnail=True) # Why not use p1 as the key? ii = images["pos%d" % i] = myplot.getFigure(figno=myplot.figno, relative=True) thumbname = myplot.getThumbnail(figno=myplot.figno, relative=True) sd.extend([ii, thumbname, caption, fin]) self.spec_description.append(sd) logging.regression("CSP: %s" % str(smax)) image = Image(images=images, description="CubeSpectrum") b2.setkey("image", image) b2.setkey("table", table) b2.setkey("sigma", csigma) # TODO: not always available b2.setkey("mean", cmean) # TODO: not always available if True: # @todo only first plane due to limitation in exportTable() islash = bdp_name.find('/') if islash < 0: tabname = self.dir("testCubeSpectrum.tab") else: tabname = self.dir(bdp_name[:islash] + "/testCubeSpectrum.tab") table.exportTable(tabname, cols=["frequency", "flux"]) dt.tag("done") # For a single spectrum this is # SummaryEntry([[data for spec1]], "CubeSpectrum_AT",taskid) # For multiple spectra this is # SummaryEntry([[data for spec1],[data for spec2],...], "CubeSpectrum_AT",taskid) self._summary["spectra"] = SummaryEntry(self.spec_description, "CubeSpectrum_AT", self.id(True)) taskargs = "pos=" + str(pos) taskargs += ' <span style="background-color:white"> ' + fin.split( '/')[0] + ' </span>' for v in self._summary: self._summary[v].setTaskArgs(taskargs) dt.tag("summary") dt.end()
def run(self): """ The run method creates the BDP. Parameters ---------- None Returns ------- None """ dt = utils.Dtime("ContinuumSub") # tagging time self._summary = {} # an ADMIT summary will be created here contsub = self.getkey("contsub") pad = self.getkey("pad") fitorder = self.getkey("fitorder") # x.im -> x.cim + x.lim # b1 = input spw BDP # b1a = optional input {Segment,Line}List # b1b = optional input Cont Map (now deprecated) # b2 = output line cube # b3 = output cont map b1 = self._bdp_in[0] f1 = b1.getimagefile(bt.CASA) b1a = self._bdp_in[1] # b1b = self._bdp_in[2] b1b = None # do not allow continuum maps to be input f2 = self.mkext(f1, 'lim') f3 = self.mkext(f1, 'cim') f3a = self.mkext(f1, 'cim3d') # temporary cube name, map is needed b2 = SpwCube_BDP(f2) b3 = Image_BDP(f3) self.addoutput(b2) self.addoutput(b3) taskinit.ia.open(self.dir(f1)) s = taskinit.ia.summary() nchan = s['shape'][ 2] # ingest has guarenteed this to the spectral axis if b1a != None: # if a LineList was given, use that if len(b1a.table) > 0: # this section of code actually works for len(ch0)==0 as well # ch0 = b1a.table.getFullColumnByName("startchan") ch1 = b1a.table.getFullColumnByName("endchan") if pad != 0: # can widen or narrow the segments if pad > 0: logging.info("pad=%d to widen the segments" % pad) else: logging.info("pad=%d to narrow the segments" % pad) ch0 = np.where(ch0 - pad < 0, 0, ch0 - pad) ch1 = np.where(ch1 + pad >= nchan, nchan - 1, ch1 + pad) s = Segments(ch0, ch1, nchan=nchan) ch = s.getchannels( True) # take the complement of lines as the continuum else: ch = range( nchan ) # no lines? take everything as continuum (probably bad) logging.warning( "All channels taken as continuum. Are you sure?") elif len(contsub) > 0: # else if contsub[] was supplied manually s = Segments(contsub, nchan=nchan) ch = s.getchannels() else: raise Exception, "No contsub= or input LineList given" if len(ch) > 0: taskinit.ia.open(self.dir(f1)) taskinit.ia.continuumsub(outline=self.dir(f2), outcont=self.dir(f3a), channels=ch, fitorder=fitorder) taskinit.ia.close() dt.tag("continuumsub") casa.immoments( self.dir(f3a), -1, outfile=self.dir(f3)) # mean of the continuum cube (f3a) utils.remove(self.dir(f3a)) # is the continuum map (f3) dt.tag("immoments") if b1b != None: # this option is now deprecated (see above, by setting b1b = None), no user option allowed # there is likely a mis-match in the beam, given how they are produced. So it's safer to # remove this here, and force the flow to smooth manually print "Adding back in a continuum map" f1b = b1b.getimagefile(bt.CASA) f1c = self.mkext(f1, 'sum') # @todo notice we are not checking for conforming mapsize and WCS # and let CASA fail out if we've been bad. casa.immath([self.dir(f3), self.dir(f1b)], 'evalexpr', self.dir(f1c), 'IM0+IM1') utils.rename(self.dir(f1c), self.dir(f3)) dt.tag("immath") else: raise Exception, "No channels left to determine continuum. pad=%d too large?" % pad # regression rdata = casautil.getdata(self.dir(f3)).data logging.regression("CSUB: %f %f" % (rdata.min(), rdata.max())) # Create two output images for html and their thumbnails, too implot = ImPlot(ptype=self._plot_type, pmode=self._plot_mode, abspath=self.dir()) implot.plotter(rasterfile=f3, figname=f3, colorwedge=True) figname = implot.getFigure(figno=implot.figno, relative=True) thumbname = implot.getThumbnail(figno=implot.figno, relative=True) b2.setkey("image", Image(images={bt.CASA: f2})) b3.setkey("image", Image(images={bt.CASA: f3, bt.PNG: figname})) dt.tag("implot") if len(ch) > 0: taskargs = "pad=%d fitorder=%d contsub=%s" % (pad, fitorder, str(contsub)) imcaption = "Continuum map" self._summary["continuumsub"] = SummaryEntry( [figname, thumbname, imcaption], "ContinuumSub_AT", self.id(True), taskargs) dt.tag("done") dt.end()
def run(self): """Runs the task. Parameters ---------- None Returns ------- None """ self._summary = {} dt = utils.Dtime("CubeSpectrum") seed = self.getkey("seed") if seed <= 0: np.random.seed() else: np.random.seed(seed) #print "RANDOM.GET_STATE:",np.random.get_state() contin = self.getkey("contin") rms = 1.0 # not a user parameter, we do all spectra in S/N space f0 = self.getkey("freq") # central frequency in band df = self.getkey("delta") / 1000.0 # channel width (in GHz) nspectra = self.getkey("nspectra") taskargs = " contin=%f freq=%f delta=%f nspectra=%f " % (contin, f0, df, nspectra) spec = range(nspectra) dt.tag("start") if self.getkey("file") != "": print "READING spectrum from", self.getkey("file") (freq, spec[0]) = getspec(self.getkey("file")) nchan = len(freq) print "Spectrum %d chans from %f to %f: min/max = %f %f" % ( nchan, freq.min(), freq.max(), spec[0].min(), spec[0].max()) # @todo nspectra>1 not tested for i in range(1, nspectra): spec[i] = deepcopy(spec[0]) dt.tag("getspec") else: nchan = self.getkey("nchan") freq = np.arange(nchan, dtype=np.float64) center = int(nchan / 2) for i in range(nchan): freq[i] = f0 + (float((i - center)) * df) for i in range(nspectra): spec[i] = np.zeros(nchan) chans = np.arange(nchan) taskargs += " nchan = %d" % nchan for i in range(nspectra): if seed >= 0: spec[i] += np.random.normal(contin, rms, nchan) # print "MEAN/STD",spec[i].mean(),spec[i].std() lines = self.getkey("lines") sls = SpectralLineSearch(False) for item in self.getkey("transitions"): kw = { "include_only_nrao": True, "line_strengths": ["ls1", "ls2"], "energy_levels": ["el2", "el4"], "fel": True, "species": item[0] } results = sls.search(item[1][0], item[1][1], "off", **kw) # look at line strengths if len(results) > 0: mx = 0.0 indx = -1 for i in range(len(results)): if results[i].getkey("linestrength") > mx: indx = i mx = results[i].getkey("linestrength") for res in results: if mx > 0.0: lines.append([ item[2] * res.getkey("linestrength") / mx, res.getkey("frequency") + utils.veltofreq(item[4], res.getkey("frequency")), item[3] ]) else: lines.append([ item[2], res.getkey("frequency") + utils.veltofreq(item[4], res.getkey("frequency")), item[3] ]) for item in lines: for i in range(nspectra): spec[i] += utils.gaussian1D(freq, item[0], item[1], utils.veltofreq(item[2], item[1])) if self.getkey("hanning"): for i in range(nspectra): filter = Filter1D.Filter1D(spec[i], "hanning", **{"width": 3}) spec[i] = filter.run() dt.tag("hanning") center = int(nchan / 2) dt.tag("open") bdp_name = self.mkext("Genspec", "csp") b2 = CubeSpectrum_BDP(bdp_name) self.addoutput(b2) images = {} # png's accumulated for i in range(nspectra): sd = [] caption = "Generated Spectrum %d" % i # construct the Table for CubeSpectrum_BDP # @todo note data needs to be a tuple, later to be column_stack'd labels = ["channel", "frequency", "flux"] units = ["number", "GHz", ""] data = (chans, freq, spec[i]) # plane 0 : we are allowing a multiplane table, so the first plane is special if i == 0: table = Table(columns=labels, units=units, data=np.column_stack(data), planes=["0"]) else: table.addPlane(np.column_stack(data), "%d" % i) # example plot , one per position for now x = chans xlab = 'Channel' y = [spec[i]] sd.append(xlab) myplot = APlot(ptype=self._plot_type, pmode=self._plot_mode, abspath=self.dir()) ylab = 'Flux' p1 = "%s_%d" % (bdp_name, i) myplot.plotter(x, y, "", p1, xlab=xlab, ylab=ylab, thumbnail=True) # Why not use p1 as the key? ii = images["pos%d" % i] = myplot.getFigure(figno=myplot.figno, relative=True) thumbname = myplot.getThumbnail(figno=myplot.figno, relative=True) image = Image(images=images, description="CubeSpectrum") sd.extend([ii, thumbname, caption]) self.spec_description.append(sd) self._summary["spectra"] = SummaryEntry(self.spec_description, "GenerateSpectrum_AT", self.id(True), taskargs) dt.tag("table") b2.setkey("image", image) b2.setkey("table", table) b2.setkey("sigma", rms) b2.setkey("mean", contin) dt.tag("done") dt.end()
def run(self): """ The run method, creates the slices, regrids if requested, and creates the BDP(s) Parameters ---------- None Returns ------- None """ dt = utils.Dtime("LineCube") self._summary = {} # look for an input noise level, either through keyword or input # CubeStats BDP or calculate it if needed pad = self.getkey("pad") fpad = self.getkey("fpad") equalize = self.getkey("equalize") minchan = 0 linelist = self._bdp_in[1] if linelist == None or len(linelist) == 0: logging.info("No lines found in input LineList_BDP, exiting.") return spw = self._bdp_in[0] # get the columns from the table cols = linelist.table.getHeader() # get the casa image imagename = spw.getimagefile(bt.CASA) imh = imhead(self.dir(imagename), mode='list') # set the overall parameters for imsubimage args = {"imagename": self.dir(imagename), "overwrite": True} dt.tag("start") if pad != 0 or fpad > 0: nchan = imh['shape'][2] dt.tag("pad") # if equal size cubes are requested, this will honor the requested pad if equalize: start = linelist.table.getColumnByName("startchan") end = linelist.table.getColumnByName("endchan") # look for the widest line for i in range(len(start)): diff = end[i] - start[i] + 1 if fpad > 0: minchan = max(minchan, diff * int(1 + 2 * fpad)) else: minchan = max(minchan, diff + (2 * pad)) dt.tag("equalize") # get all of the rows in the table rows = linelist.getall() delrow = set() procblend = [0] # search through looking for blended lines, leave only the strongest from each blend # in the list for i, row in enumerate(rows): if row.blend in procblend: continue strongest = -100. index = -1 indexes = [] blend = row.blend for j in range(i, len(rows)): if rows[j].blend != blend: continue indexes.append(j) if rows[j].linestrength > strongest: strongest = rows[j].linestrength index = j indexes.remove(index) delrow = delrow | set(indexes) procblend.append(blend) dr = list(delrow) dr.sort() dr.reverse() for row in dr: del rows[row] # check on duplicate UID's, since those are the directory names here uid1 = [] for row in rows: uid1.append(row.getkey("uid")) uid2 = set(uid1) if len(uid1) != len(uid2): print "LineList:", uid1 logging.warning("There are duplicate names in the LineList") #raise Exception,"There are duplicate names in the LineList" # Create Summary table lc_description = admit.util.Table() lc_description.columns = [ "Line Name", "Start Channel", "End Channel", "Output Cube" ] lc_description.units = ["", "int", "int", ""] lc_description.description = "Parameters of Line Cubes" # loop over all entries in the line list rdata = [] for row in rows: uid = row.getkey("uid") cdir = self.mkext(imagename, uid) self.mkdir(cdir) basefl = uid lcd = [basefl] outfl = cdir + os.sep + "lc.im" args["outfile"] = self.dir(outfl) start = row.getkey("startchan") end = row.getkey("endchan") diff = end - start + 1 startch = 0 if diff < minchan: add = int(math.ceil(float(minchan - diff) / 2.0)) start -= add end += add startch += add if start < 0: logging.info( "%s is too close to the edge to encompass with the " + "requested channels, start=%d resetting to 0" % (uid, start)) startch += abs(start) start = 0 if end >= nchan: logging.info( "%s is too close to the edge to encompass with the " + "requested channels, end=%d resetting to %d" % (uid, end, nchan - 1)) end = nchan - 1 #print "\n\nDIFF ",startch,"\n\n" if not equalize: if fpad > 0: diff = end - start + 1 start -= int(fpad * diff) end += int(fpad * diff) if start < 0: logging.warning( "fpad=%d too large, start=%d resetting to 0" % (int(fpad * diff), start)) startch += abs(start) start = 0 else: startch += int(fpad * diff) if end >= nchan: logging.warning( "fpad=%d too large, end=%d resetting to %d" % (int(fpad * diff), end, nchan - 1)) end = nchan - 1 elif pad > 0: start -= pad end += pad if start < 0: logging.warning( "pad=%d too large, start=%d resetting to 0" % (pad, start)) startch += abs(start) start = 0 else: startch += pad if end >= nchan: logging.warning( "pad=%d too large, end=%d resetting to %d" % (pad, end, nchan - 1)) end = nchan - 1 elif pad < 0: mid = (start + end) / 2 start = mid + pad / 2 end = mid - pad / 2 - 1 if start < 0: logging.warning( "pad=%d too large, start=%d resetting to 0" % (pad, start)) startch += abs(start) start = 0 else: startch += abs(start) if end >= nchan: logging.warning( "pad=%d too large, end=%d resetting to %d" % (pad, end, nchan - 1)) end = nchan - 1 endch = startch + diff args["chans"] = "%i~%i" % (start, end) rdata.append(start) rdata.append(end) # for the summmary, which will be a table of # Line name, start channel, end channel, output image lc_description.addRow([basefl, start, end, outfl]) # create the slices imsubimage(**args) line = row.converttoline() # set the restfrequency ouf the output cube imhead(imagename=args["outfile"], mode="put", hdkey="restfreq", hdvalue="%fGHz" % (row.getkey("frequency"))) # set up the output BDP images = {bt.CASA: outfl} casaimage = Image(images=images) # note that Summary.getLineFluxes() implicitly relies on the BDP out order # being the same order as in the line list table. If this is ever not # true, then Summary.getLineFluxes mismatch BDPs and flux values. #self.addoutput(LineCube_BDP(xmlFile=cdir + os.sep + basefl + ".lc", self.addoutput( LineCube_BDP(xmlFile=outfl, image=casaimage, line=line, linechans="%i~%i" % (startch, endch))) dt.tag("trans-%s" % cdir) logging.regression("LC: %s" % str(rdata)) taskargs = "pad=%s fpad=%g equalize=%s" % (pad, fpad, equalize) self._summary["linecube"] = SummaryEntry(lc_description.serialize(), "LineCube_AT", self.id(True), taskargs) dt.tag("done") dt.end()
def run(self): """ The run method, locates lines, attempts to identify them, and creates the BDP Parameters ---------- None Returns ------- None """ if not self.boxcar: logging.info("Boxcar smoothing turned off.") self._summary = {} self.freq = [] self.chan = [] dt = utils.Dtime("LineSegment") # timer for debugging spec_description = [] taskargs = self._taskargs() statbdp = None # for the CubeStats BDP specbdp = None # for the CubeSpectrum BDP specs = [] # to hold the input CubeSpectrum based spectra statspec = [] # to hold the input CubeStats based spectrum statseg = [] # to hold the detected segments from statspec specseg = [] # to hold the detected segments from specs #statcutoff = [] # cutoff for statspec line finding #speccutoff = [] # cutoff for specs line finding infile = "" if self.getkey("minchan") < 1: raise Exception("minchan must eb a positive value.") elif self.getkey("minchan") == 1 and self.getkey("iterate"): logging.info( "iterate=True is not allowed for minchan=1, setting iterate to False" ) self.setkey("iterate", False) vlsr = 0.0 # get the input bdp if self._bdp_in[0] is not None: specbdp = self._bdp_in[0] infile = specbdp.xmlFile if self._bdp_in[1] is not None: statbdp = self._bdp_in[1] infile = statbdp.xmlFile # still need to do this check since all are optional inputs if specbdp == statbdp is None: raise Exception("No input BDP's found.") imbase = self.mkext(infile, 'lseg') # grab any optional references overplotted on the "ll" plots # instantiate a plotter for all plots made herein self._plot_type = admit.util.PlotControl.SVG myplot = APlot(ptype=self._plot_type, pmode=self._plot_mode, abspath=self.dir()) dt.tag("start") ############################################################################ # Smoothing and continuum (baseline) subtraction of input spectra # ############################################################################ # get and smooth all input spectra basicsegment = { "method": self.getkey("segment"), "minchan": self.getkey("minchan"), "maxgap": self.getkey("maxgap"), "numsigma": self.getkey("numsigma"), "iterate": self.getkey("iterate"), "nomean": True } segargsforcont = { "name": "Line_Segment.%i.asap" % self.id(True), "pmin": self.getkey("numsigma"), "minchan": self.getkey("minchan"), "maxgap": self.getkey("maxgap") } if specbdp is not None: # get the spectrum specs = specutil.getspectrum(specbdp, vlsr, self.getkey("smooth"), self.getkey("recalcnoise"), basicsegment) # remove the continuum, if requested if self.getkey("csub")[1] is not None: logging.info( "Attempting Continuum Subtraction for Input Spectra") order = self.getkey("csub")[1] specutil.contsub(self.id(True), specs, self.getkey("segment"), segargsforcont, algorithm="PolyFit", **{"deg": order}) else: for spec in specs: spec.set_contin(np.zeros(len(spec))) for spec in specs: self.freq, self.chan = specutil.mergefreq( self.freq, self.chan, spec.freq(False), spec.chans(False)) # get any input cubestats if statbdp is not None: statspec = specutil.getspectrum(statbdp, vlsr, self.getkey("smooth"), self.getkey("recalcnoise"), basicsegment) # remove the continuum if self.getkey("csub")[0] is not None: logging.info( "Attempting Continuum Subtraction for Input CubeStats Spectra" ) order = self.getkey("csub")[0] specutil.contsub(self.id(True), statspec, self.getkey("segment"), segargsforcont, algorithm="PolyFit", **{"deg": order}) # The 'min' spectrum is inverted for segment finding. # Doesn't this mean it will also be plotted upside down? if len(statspec) > 0: statspec[1].invert() for spec in statspec: self.freq, self.chan = specutil.mergefreq( self.freq, self.chan, spec.freq(False), spec.chans(False)) dt.tag("getspectrum") if isinstance(self.freq, np.ndarray): self.freq = self.freq.tolist() if isinstance(self.chan, np.ndarray): self.chan = self.chan.tolist() # search for segments of spectral line emission #NB: this is repetitive with basicsegment above. method = self.getkey("segment") minchan = self.getkey("minchan") maxgap = self.getkey("maxgap") numsigma = self.getkey("numsigma") iterate = self.getkey("iterate") if specbdp is not None: logging.info("Detecting segments in CubeSpectrum based data") values = specutil.findsegments(specs, method, minchan, maxgap, numsigma, iterate) for i, t in enumerate(values): specseg.append(t[0]) specs[i].set_noise(t[2]) if statbdp is not None: logging.info("Detecting segments in CubeStats based data") values = specutil.findsegments(statspec, method, minchan, maxgap, numsigma, iterate) for i, t in enumerate(values): statseg.append(t[0]) # print ("MWP LINESEGMENT %d Setting noise=%f minchan=%d",(i,t[2],minchan)) statspec[i].set_noise(t[2]) #statcutoff.append(t[1]) dt.tag("segment finder") lsbdp = LineSegment_BDP(imbase) finalsegs = utils.mergesegments([statseg, specseg], len(self.freq)) lines = specutil.linedatafromsegments(self.freq, self.chan, finalsegs, specs, statspec) llist = [] for l in lines: lsbdp.addRow(l) llist.append(l) rdata = [] # create the output label = ["Peak/Noise", "Minimum/Noise"] caption = [ "Potential lines overlaid on peak intensity plot from CubeStats_BDP.", "Potential lines overlaid on minimum intensity plot from CubeStats_BDP." ] xlabel = "Frequency (GHz)" for i, spec in enumerate(statspec): freqs = [] for ch in statseg[i]: frq = [ min(spec.freq()[ch[0]], spec.freq()[ch[1]]), max(spec.freq()[ch[0]], spec.freq()[ch[1]]) ] freqs.append(frq) rdata.append(frq) #print("Stats segment, peak, ratio, fwhm ",lname,peak,ratio,fwhm) mult = 1. if i == 1: mult = -1. # print("MWP statspec plot cutoff[%d] = %f, contin=%f" % (i, (statspec[i].contin() + mult*(statspec[i].noise() * self.getkey("numsigma")))[0], statspec[i].contin()[0] ) ) myplot.segplotter( spec.freq(), spec.spec(csub=False), title="Detected Line Segments", xlab=xlabel, ylab=label[i], figname=imbase + "_statspec%i" % i, segments=freqs, cutoff=(spec.contin() + mult * (spec.noise() * self.getkey("numsigma"))), continuum=spec.contin(), thumbnail=True) imname = myplot.getFigure(figno=myplot.figno, relative=True) thumbnailname = myplot.getThumbnail(figno=myplot.figno, relative=True) image = Image(images={bt.SVG: imname}, thumbnail=thumbnailname, thumbnailtype=bt.PNG, description=caption[i]) lsbdp.image.addimage(image, "statspec%i" % i) spec_description.append([ lsbdp.ra, lsbdp.dec, "", xlabel, imname, thumbnailname, caption[i], infile ]) for i in range(len(specs)): freqs = [] for ch in specseg[i]: frq = [ min(specs[i].freq()[ch[0]], specs[i].freq()[ch[1]]), max(specs[i].freq()[ch[0]], specs[i].freq()[ch[1]]) ] freqs.append(frq) rdata.append(frq) myplot.segplotter(specs[i].freq(), specs[i].spec(csub=False), title="Detected Line Segments", xlab=xlabel, ylab="Intensity", figname=imbase + "_spec%03d" % i, segments=freqs, cutoff=specs[i].contin() + (specs[i].noise() * self.getkey("numsigma")), continuum=specs[i].contin(), thumbnail=True) imname = myplot.getFigure(figno=myplot.figno, relative=True) thumbnailname = myplot.getThumbnail(figno=myplot.figno, relative=True) caption = "Detected line segments from input spectrum #%i." % (i) image = Image(images={bt.SVG: imname}, thumbnail=thumbnailname, thumbnailtype=bt.PNG, description=caption) lsbdp.image.addimage(image, "spec%03d" % i) spec_description.append([ lsbdp.ra, lsbdp.dec, "", xlabel, imname, thumbnailname, caption, infile ]) caption = "Merged segments overlaid on CubeStats spectrum" myplot.summaryspec(statspec, specs, None, imbase + "_summary", llist) imname = myplot.getFigure(figno=myplot.figno, relative=True) thumbnailname = myplot.getThumbnail(figno=myplot.figno, relative=True) caption = "Identified segments overlaid on Signal/Noise plot of all spectra." image = Image(images={bt.SVG: imname}, thumbnail=thumbnailname, thumbnailtype=bt.PNG, description=caption) lsbdp.image.addimage(image, "summary") spec_description.append([ lsbdp.ra, lsbdp.dec, "", "Signal/Noise", imname, thumbnailname, caption, infile ]) self._summary["segments"] = SummaryEntry(lsbdp.table.serialize(), "LineSegment_AT", self.id(True), taskargs) self._summary["spectra"] = [ SummaryEntry(spec_description, "LineSegment_AT", self.id(True), taskargs) ] self.addoutput(lsbdp) logging.regression("LINESEG: %s" % str(rdata)) dt.tag("done") dt.end()
def run(self): """ The run method creates the BDP Parameters ---------- None Returns ------- None """ dt = utils.Dtime("SFind2D") # tagging time self._summary = {} # get key words that user input nsigma = self.getkey("numsigma") sigma = self.getkey("sigma") region = self.getkey("region") robust = self.getkey("robust") snmax = self.getkey("snmax") nmax = self.getkey("nmax") ds9 = True # writes a "ds9.reg" file mpl = True # aplot.map1() plot dynlog = 20.0 # above this value of dyn range finder chart is log I-scaled bpatch = True # patch units to Jy/beam for ia.findsources() # get the input casa image from bdp[0] bdpin = self._bdp_in[0] infile = bdpin.getimagefile(bt.CASA) if mpl: data = np.flipud(np.rot90(casautil.getdata(self.dir(infile)).data)) # check if there is a 2nd image (which will be a PB) for i in range(len(self._bdp_in)): print 'BDP', i, type(self._bdp_in[i]) if self._bdp_in[2] != None: bdpin_pb = self._bdp_in[1] bdpin_cst = self._bdp_in[2] print "Need to process PB" else: bdpin_pb = None bdpin_cst = self._bdp_in[1] print "No PB given" # get the output bdp basename slbase = self.mkext(infile, 'sl') # make sure it's a 2D map if not casautil.mapdim(self.dir(infile), 2): raise Exception, "Input map dimension not 2: %s" % infile # arguments for imstat call if required args = {"imagename": self.dir(infile)} if region != "": args["region"] = region dt.tag("start") # The following code sets the sigma level for searching for sources using # the sigma and snmax keyword as appropriate # if no CubeStats BDP was given and no sigma was specified: # find a noise level via casa.imstat() # if a CubeStat_BDP is given get it from there. if bdpin_cst == None: # get statistics from input image with imstat because no CubeStat_BDP stat = casa.imstat(**args) dmin = float( stat["min"] [0]) # these would be wrong if robust were used already dmax = float(stat["max"][0]) args.update(casautil.parse_robust( robust)) # only now add robust keywords for the sigma stat = casa.imstat(**args) if sigma <= 0.0: sigma = float(stat["sigma"][0]) dt.tag("imstat") else: # get statistics from CubeStat_BDP sigma = bdpin_cst.get("sigma") dmin = bdpin_cst.get("minval") dmax = bdpin_cst.get("maxval") self.setkey("sigma", sigma) # calculate cutoff based either on RMS or dynamic range limitation drange = dmax / (nsigma * sigma) if snmax < 0.0: snmax = drange if drange > snmax: cutoff = 1.0 / snmax else: cutoff = 1.0 / drange logging.info("sigma, dmin, dmax, snmax, cutoff %g %g %g %g %g" % (sigma, dmin, dmax, snmax, cutoff)) # define arguments for call to findsources args2 = {"cutoff": cutoff} args2["nmax"] = nmax if region != "": args2["region"] = region #args2["mask"] = "" args2["point"] = False args2["width"] = 5 args2["negfind"] = False # set-up for SourceList_BDP slbdp = SourceList_BDP(slbase) # connect to casa image and call casa ia.findsources tool ia = taskinit.iatool() ia.open(self.dir(infile)) # findsources() cannot deal with 'Jy/beam.km/s' ??? # so for the duration of findsources() we patch it bunit = ia.brightnessunit() if bpatch and bunit != 'Jy/beam': logging.warning( "Temporarely patching your %s units to Jy/beam for ia.findsources()" % bunit) ia.setbrightnessunit('Jy/beam') else: bpatch = False atab = ia.findsources(**args2) if bpatch: ia.setbrightnessunit(bunit) taskargs = "nsigma=%4.1f sigma=%g region=%s robust=%s snmax=%5.1f nmax=%d" % ( nsigma, sigma, str(region), str(robust), snmax, nmax) dt.tag("findsources") nsources = atab["nelements"] xtab = [] ytab = [] logscale = False sumflux = 0.0 if nsources > 0: # @TODO: Why are Xpix, YPix not stored in the table? # -> PJT: I left them out since they are connected to an image which may not be available here # but we should store the frequency of the observation here for later bandmerging logging.debug("%s" % str(atab['component0']['shape'])) logging.info( "Right Ascen. Declination X(pix) Y(pix) Peak Flux Major Minor PA SNR" ) funits = atab['component0']['flux']['unit'] if atab['component0']['shape'].has_key('majoraxis'): sunits = atab['component0']['shape']['majoraxis']['unit'] aunits = atab['component0']['shape']['positionangle']['unit'] else: sunits = "n/a" aunits = "n/a" punits = ia.summary()['unit'] logging.info( " %s %s %s %s %s" % (punits, funits, sunits, sunits, aunits)) # # @todo future improvement is to look at image coordinates and control output appropriately # if ds9: # @todo variable name regname = self.mkext(infile, 'ds9.reg') fp9 = open(self.dir(regname), "w!") sn0 = -1.0 for i in range(nsources): c = "component%d" % i name = "%d" % (i + 1) r = atab[c]['shape']['direction']['m0']['value'] d = atab[c]['shape']['direction']['m1']['value'] pixel = ia.topixel([r, d]) xpos = pixel['numeric'][0] ypos = pixel['numeric'][1] rd = ia.toworld([xpos, ypos], 's') ra = rd['string'][0][:12] dec = rd['string'][1][:12] flux = atab[c]['flux']['value'][0] sumflux = sumflux + flux if atab[c]['shape'].has_key('majoraxis'): smajor = atab[c]['shape']['majoraxis']['value'] sminor = atab[c]['shape']['minoraxis']['value'] sangle = atab[c]['shape']['positionangle']['value'] else: smajor = 0.0 sminor = 0.0 sangle = 0.0 peakstr = ia.pixelvalue([xpos, ypos, 0, 0]) if len(peakstr) == 0: logging.warning("Problem with source %d @ %d,%d" % (i, xpos, ypos)) continue peakf = peakstr['value']['value'] snr = peakf / sigma if snr > dynlog: logscale = True if snr > sn0: sn0 = snr logging.info( "%s %s %8.2f %8.2f %10.3g %10.3g %7.3f %7.3f %6.1f %6.1f" % (ra, dec, xpos, ypos, peakf, flux, smajor, sminor, sangle, snr)) xtab.append(xpos) ytab.append(ypos) slbdp.addRow( [name, ra, dec, flux, peakf, smajor, sminor, sangle]) if ds9: ras = ra des = dec.replace('.', ':', 2) msg = 'ellipse(%s,%s,%g",%g",%g) # text={%s}' % ( ras, des, smajor, sminor, sangle + 90.0, i + 1) fp9.write("%s\n" % msg) if ds9: fp9.close() logging.info("Wrote ds9.reg") dt.tag("table") logging.regression("CONTFLUX: %d %g" % (nsources, sumflux)) summary = ia.summary() beammaj = summary['restoringbeam']['major']['value'] beammin = summary['restoringbeam']['minor']['value'] beamunit = summary['restoringbeam']['minor']['unit'] beamang = summary['restoringbeam']['positionangle']['value'] angunit = summary['restoringbeam']['positionangle']['unit'] # @todo add to table comments? logging.info(" Fitted Gaussian size; NOT deconvolved source size.") logging.info( " Restoring Beam: Major axis: %10.3g %s , Minor axis: %10.3g %s , PA: %5.1f %s" % (beammaj, beamunit, beammin, beamunit, beamang, angunit)) # form into a xml table # output is a table_bdp self.addoutput(slbdp) # instantiate a plotter for all plots made herein myplot = APlot(ptype=self._plot_type, pmode=self._plot_mode, abspath=self.dir()) # make output png with circles marking sources found if mpl: circles = [] nx = data.shape[1] # data[] array was already flipud(rot90)'d ny = data.shape[0] # for (x, y) in zip(xtab, ytab): circles.append([x, y, 1]) # @todo variable name if logscale: logging.warning("LogScaling applied") data = data / sigma data = np.where(data < 0, -np.log10(1 - data), +np.log10(1 + data)) if nsources == 0: title = "SFind2D: 0 sources above S/N=%.1f" % (nsigma) elif nsources == 1: title = "SFind2D: 1 source (%.1f < S/N < %.1f)" % (nsigma, sn0) else: title = "SFind2D: %d sources (%.1f < S/N < %.1f)" % ( nsources, nsigma, sn0) myplot.map1(data, title, slbase, thumbnail=True, circles=circles, zoom=self.getkey("zoom")) #--------------------------------------------------------- # Get the figure and thumbmail names and create a caption #--------------------------------------------------------- imname = myplot.getFigure(figno=myplot.figno, relative=True) thumbnailname = myplot.getThumbnail(figno=myplot.figno, relative=True) caption = "Image of input map with sources found by SFind2D overlayed in green." slbdp.table.description = "Table of source locations and sizes (not deconvolved)" #--------------------------------------------------------- # Add finder image to the BDP #--------------------------------------------------------- image = Image(images={bt.PNG: imname}, thumbnail=thumbnailname, thumbnailtype=bt.PNG, description=caption) slbdp.image.addimage(image, "finderimage") #------------------------------------------------------------- # Create the summary entry for the table and image #------------------------------------------------------------- self._summary["sources"] = SummaryEntry( [slbdp.table.serialize(), slbdp.image.serialize()], "SFind2D_AT", self.id(True), taskargs) dt.tag("done") dt.end()
def run(self): """ The run method creates the BDP Parameters ---------- None Returns ------- None """ self._summary = {} dt = utils.Dtime("Regrid") dt.tag("start") do_spatial_regrid = self.getkey("do_spatial_regrid") pix_scale = self.getkey("pix_scale") do_freq_regrid = self.getkey("do_freq_regrid") chan_width = self.getkey("chan_width") pix_size = [] chan_size = [] im_size = [] pix_wc_x = [] pix_wc_y = [] pix_wc_nu = [] src_dec = [] RADPERARCSEC = 4.848137E-6 for ibdp in self._bdp_in: # Convert input CASA images to numpy arrays. istem = ibdp.getimagefile(bt.CASA) ifile = ibdp.baseDir() + istem h = casa.imhead(ifile, mode='list') pix_size.append(np.abs( h['cdelt1'])) # pix scale in asec @todo QA ? chan_size.append(np.abs(h['cdelt3'])) # grab the pixels pix_x = h['shape'][0] pix_y = h['shape'][1] pix_nu = h['shape'][2] taskinit.ia.open(ifile) mycs = taskinit.ia.coordsys(axes=[0, 1, 2]) # getting all four corners handles the case of images where # x-y axis not aligned with RA-dec for xpix in [0, pix_x]: for ypix in [0, pix_y]: x = mycs.toworld([xpix, ypix])['numeric'][0] y = mycs.toworld([xpix, ypix])['numeric'][1] pix_wc_x.append(x) pix_wc_y.append(y) nu = mycs.toworld([pix_x, pix_y, 0])['numeric'][2] pix_wc_nu.append(nu) nu = mycs.toworld([pix_x, pix_y, pix_nu])['numeric'][2] pix_wc_nu.append(nu) taskinit.ia.close() min_ra = np.min(pix_wc_x) max_ra = np.max(pix_wc_x) min_dec = np.min(pix_wc_y) max_dec = np.max(pix_wc_y) mean_ra = 0.5 * (min_ra + max_ra) mean_dec = 0.5 * (min_dec + max_dec) if (pix_scale < 0): pix_scale = np.min(pix_size) else: pix_scale = pix_scale * RADPERARCSEC npix_ra = int((max_ra - min_ra) / pix_scale * np.cos(mean_dec)) npix_dec = (max_dec - min_dec) / pix_scale npix_dec = (int(npix_dec) if npix_dec == int(npix_dec) else int(npix_dec) + 1) min_nu = np.min(pix_wc_nu) max_nu = np.max(pix_wc_nu) mean_nu = 0.5 * (min_nu + max_nu) if (chan_width < 0): chan_width = np.min(chan_size) npix_nu = int((max_nu - min_nu) / chan_width) + 1 # now regrid everything innames = [] outnames = [] incdelt = [] outcdelt = [] #========================================================= #@todo - check if bdp_ins refer to same input file. # If so, the current code will fail because the output # file name is fixed to $INPUT_regrid. A valid use case # is "regrid the same input file different ways" -- which # is not supported in the current code but should be #========================================================= for ibdp in self._bdp_in: istem = ibdp.getimagefile(bt.CASA) ifile = ibdp.baseDir() + istem ostem = "%s_regrid/" % (istem) ofile = self.baseDir() + ostem # save the input/output file names innames.append(istem) outnames.append(ostem) header = casa.imregrid(imagename=ifile, template='get') # save the input cdelt1,2,3 for summary table incdelt.append( (header['csys']['direction0']['cdelt'][0] / RADPERARCSEC, header['csys']['direction0']['cdelt'][1] / RADPERARCSEC, utils.freqtovel(mean_nu, header['csys']['spectral2']['wcs']['cdelt']))) if (do_spatial_regrid): header['csys']['direction0']['cdelt'] = [ -1 * pix_scale, pix_scale ] header['csys']['direction0']['crval'] = [mean_ra, mean_dec] header['shap'][0] = npix_ra header['shap'][1] = npix_dec header['csys']['direction0']['crpix'] = [ npix_ra / 2, npix_dec / 2 ] if (do_freq_regrid): header['csys']['spectral2']['wcs']['crval'] = min_nu header['shap'][2] = npix_nu chan_size = np.abs(header['csys']['spectral2']['wcs']['cdelt']) header['csys']['spectral2']['wcs']['cdelt'] = chan_width flux_correction = chan_width / chan_size casa.imregrid(imagename=ifile, output=ofile, template=header) # save the output cdelt1,2,3 for summary table newhead = casa.imregrid(imagename=ofile, template='get') outcdelt.append( (newhead['csys']['direction0']['cdelt'][0] / RADPERARCSEC, newhead['csys']['direction0']['cdelt'][1] / RADPERARCSEC, utils.freqtovel( mean_nu, newhead['csys']['spectral2']['wcs']['cdelt']))) if (do_freq_regrid): taskinit.ia.open(ofile) print flux_correction taskinit.ia.calc(pixels=ofile.replace(r"/", r"\/") + '*' + str(flux_correction)) taskinit.ia.done() obdp = admit.SpwCube_BDP(ostem) self.addoutput(obdp) # make a table for summary atable = admit.util.Table() atable.columns = [ "Input Image", "cdelt1", "cdelt2", "cdelt3", "Regridded Image", "cdelt1", "cdelt2", "cdelt3" ] atable.units = [ "", "arcsec", "arcsec", "km/s", "", "arcsec", "arcsec", "km/s" ] for i in range(len(innames)): atable.addRow([ innames[i], incdelt[i][0], incdelt[i][1], incdelt[i][2], outnames[i], outcdelt[i][0], outcdelt[i][1], outcdelt[i][2] ]) #keys = "pixsize=%.4g naxis1=%d naxis2=%d mean_ra=%0.4f mean_dec=%0.4f reffreq=%g chan_width=%g" % (pix_scale/(4.848137E-6), npix_ra, npix_dec, mean_ra,mean_dec,min_nu,chan_width) taskargs = "pix_scale = " + str( self.getkey("pix_scale")) + " chan_width = " + str( self.getkey("chan_width")) self._summary["regrid"] = SummaryEntry(atable.serialize(), "Regrid_AT", self.id(True), taskargs) dt.tag("done") dt.end()
def run(self): """ The run method, calculates the moments and creates the BDP(s) Parameters ---------- None Returns ------- None """ self._summary = {} momentsummary = [] dt = utils.Dtime("Moment") # variable to track if we are using a single cutoff for all moment maps allsame = False moments = self.getkey("moments") numsigma = self.getkey("numsigma") mom0clip = self.getkey("mom0clip") # determine if there is only 1 cutoff or if there is a cutoff for each moment if len(moments) != len(numsigma): if len(numsigma) != 1: raise Exception("Length of numsigma and moment lists do not match. They must be the same length or the length of the cutoff list must be 1.") allsame = True # default moment file extensions, this is information copied from casa.immoments() momentFileExtensions = {-1: ".average", 0: ".integrated", 1: ".weighted_coord", 2: ".weighted_dispersion_coord", 3: ".median", 4: "", 5: ".standard_deviation", 6: ".rms", 7: ".abs_mean_dev", 8: ".maximum", 9: ".maximum_coord", 10: ".minimum", 11: ".minimum_coord", } logging.debug("MOMENT: %s %s %s" % (str(moments), str(numsigma), str(allsame))) # get the input casa image from bdp[0] # also get the channels the line actually covers (if any) bdpin = self._bdp_in[0] infile = bdpin.getimagefile(bt.CASA) chans = self.getkey("chans") # the basename of the moments, we will append _0, _1, etc. basename = self.mkext(infile, "mom") fluxname = self.mkext(infile, "flux") # beamarea = nppb(self.dir(infile)) beamarea = 1.0 # until we have it from the MOM0 map sigma0 = self.getkey("sigma") sigma = sigma0 ia = taskinit.iatool() dt.tag("open") # if no CubseStats BDP was given and no sigma was specified, find a # noise level via casa.imstat() if self._bdp_in[1] is None and sigma <= 0.0: raise Exception("A sigma or a CubeStats_BDP must be input to calculate the cutoff") elif self._bdp_in[1] is not None: sigma = self._bdp_in[1].get("sigma") # immoments is a bit peculiar. If you give one moment, it will use # exactly the outfile you picked for multiple moments, it will pick # extensions such as .integrated [0], .weighted_coord [1] etc. # we loop over the moments and will use the numeric extension instead. # Might be laborious loop for big input cubes # # arguments for immoments args = {"imagename" : self.dir(infile), "moments" : moments, "outfile" : self.dir(basename)} # set the channels if given if chans != "": args["chans"] = chans # error check the mom0clip input if mom0clip > 0.0 and not 0 in moments: logging.warning("mom0clip given, but no moment0 map was requested. One will be generated anyway.") # add moment0 to the list of computed moments, but it has to be first moments.insert(0,0) if not allsame: numsigma.insert(0, 2.0*sigma) if allsame: # this is only executed now if len(moments) > 1 and len(cutoff)==1 args["excludepix"] = [-numsigma[0] * sigma, numsigma[0] * sigma] casa.immoments(**args) dt.tag("immoments-all") else: # this is execute if len(moments)==len(cutoff) , even when len=1 for i in range(len(moments)): args["excludepix"] = [-numsigma[i] * sigma, numsigma[i] * sigma] args["moments"] = moments[i] args["outfile"] = self.dir(basename + momentFileExtensions[moments[i]]) casa.immoments(**args) dt.tag("immoments-%d" % moments[i]) taskargs = "moments=%s numsigma=%s" % (str(moments), str(numsigma)) if sigma0 > 0: taskargs = taskargs + " sigma=%.2f" % sigma0 if mom0clip > 0: taskargs = taskargs + " mom0clip=%g" % mom0clip if chans == "": taskargs = taskargs + " chans=all" else: taskargs = taskargs + " chans=%s" % str(chans) taskargs += ' <span style="background-color:white"> ' + basename.split('/')[0] + ' </span>' # generate the mask to be applied to all but moment 0 if mom0clip > 0.0: # get the statistics from mom0 map # this is usually a very biased map, so unclear if mom0sigma is all that reliable args = {"imagename": self.dir(infile)} stat = casa.imstat(imagename=self.dir(basename + momentFileExtensions[0])) mom0sigma = float(stat["sigma"][0]) # generate a temporary masked file, mask will be copied to other moments args = {"imagename" : self.dir(basename + momentFileExtensions[0]), "expr" : 'IM0[IM0>%f]' % (mom0clip * mom0sigma), "outfile" : self.dir("mom0.masked") } casa.immath(**args) # get the default mask name ia.open(self.dir("mom0.masked")) defmask = ia.maskhandler('default') ia.close() dt.tag("mom0clip") # loop over moments to rename them to _0, _1, _2 etc. # apply a mask as well for proper histogram creation map = {} myplot = APlot(pmode=self._plot_mode,ptype=self._plot_type,abspath=self.dir()) implot = ImPlot(pmode=self._plot_mode,ptype=self._plot_type,abspath=self.dir()) for mom in moments: figname = imagename = "%s_%i" % (basename, mom) tempname = basename + momentFileExtensions[mom] # rename and remove the old one if there is one utils.rename(self.dir(tempname), self.dir(imagename)) # copy the moment0 mask if requested; this depends on that mom0 was done before if mom0clip > 0.0 and mom != 0: #print "PJT: output=%s:%s" % (self.dir(imagename), defmask[0]) #print "PJT: inpmask=%s:%s" % (self.dir("mom0.masked"),defmask[0]) makemask(mode="copy", inpimage=self.dir("mom0.masked"), output="%s:%s" % (self.dir(imagename), defmask[0]), overwrite=True, inpmask="%s:%s" % (self.dir("mom0.masked"), defmask[0])) ia.open(self.dir(imagename)) ia.maskhandler('set', defmask) ia.close() dt.tag("makemask") if mom == 0: beamarea = nppb(self.dir(imagename)) implot.plotter(rasterfile=imagename,figname=figname, colorwedge=True,zoom=self.getkey("zoom")) imagepng = implot.getFigure(figno=implot.figno,relative=True) thumbname = implot.getThumbnail(figno=implot.figno,relative=True) images = {bt.CASA : imagename, bt.PNG : imagepng} thumbtype=bt.PNG dt.tag("implot") # get the data for a histogram (ia access is about 1000-2000 faster than imval()) map[mom] = casautil.getdata(self.dir(imagename)) data = map[mom].compressed() dt.tag("getdata") # make the histogram plot # get the label for the x axis bunit = casa.imhead(imagename=self.dir(imagename), mode="get", hdkey="bunit") # object for the caption objectname = casa.imhead(imagename=self.dir(imagename), mode="get", hdkey="object") # Make the histogram plot # Since we give abspath in the constructor, figname should be relative auxname = imagename + '_histo' auxtype = bt.PNG myplot.histogram(columns = data, figname = auxname, xlab = bunit, ylab = "Count", title = "Histogram of Moment %d: %s" % (mom, imagename), thumbnail=True) casaimage = Image(images = images, auxiliary = auxname, auxtype = auxtype, thumbnail = thumbname, thumbnailtype = thumbtype) auxname = myplot.getFigure(figno=myplot.figno,relative=True) auxthumb = myplot.getThumbnail(figno=myplot.figno,relative=True) if hasattr(self._bdp_in[0], "line"): # SpwCube doesn't have Line line = deepcopy(getattr(self._bdp_in[0], "line")) if not isinstance(line, Line): line = Line(name="Unidentified") else: # fake a Line if there wasn't one line = Line(name="Unidentified") # add the BDP to the output array self.addoutput(Moment_BDP(xmlFile=imagename, moment=mom, image=deepcopy(casaimage), line=line)) dt.tag("ren+mask_%d" % mom) imcaption = "%s Moment %d map of Source %s" % (line.name, mom, objectname) auxcaption = "Histogram of %s Moment %d of Source %s" % (line.name, mom, objectname) thismomentsummary = [line.name, mom, imagepng, thumbname, imcaption, auxname, auxthumb, auxcaption, infile] momentsummary.append(thismomentsummary) if map.has_key(0) and map.has_key(1) and map.has_key(2): logging.debug("MAPs present: %s" % (map.keys())) # m0 needs a new mask, inherited from the more restricted m1 (and m2) m0 = ma.masked_where(map[1].mask,map[0]) m1 = map[1] m2 = map[2] m01 = m0*m1 m02 = m0*m1*m1 m22 = m0*m2*m2 sum0 = m0.sum() vmean = m01.sum()/sum0 # lacking the full 3D cube, get two estimates and take the max sig1 = math.sqrt(m02.sum()/sum0 - vmean*vmean) sig2 = m2.max() #vsig = max(sig1,sig2) vsig = sig1 # consider clipping in the masked array (mom0clip) # @todo i can't use info from line, so just borrow basename for now for grepping # this also isn't really the flux, the points per beam is still in there loc = basename.rfind('/') sum1 = ma.masked_less(map[0],0.0).sum() # mom0clip # print out: LINE,FLUX1,FLUX0,BEAMAREA,VMEAN,VSIGMA for regression # the linechans parameter in bdpin is not useful to print out here, it's local to the LineCube s_vlsr = admit.Project.summaryData.get('vlsr')[0].getValue()[0] s_rest = admit.Project.summaryData.get('restfreq')[0].getValue()[0]/1e9 s_line = line.frequency if loc>0: if basename[:loc][0:2] == 'U_': # for U_ lines we'll reference the VLSR w.r.t. RESTFREQ in that band if abs(vmean) > vsig: vwarn = '*' else: vwarn = '' vlsr = vmean + (1.0-s_line/s_rest)*utils.c msg = "MOM0FLUX: %s %g %g %g %g %g %g" % (basename[:loc],map[0].sum(),sum0,beamarea,vmean,vlsr,vsig) else: # for identified lines we'll assume the ID was correct and not bother with RESTFREQ msg = "MOM0FLUX: %s %g %g %g %g %g %g" % (basename[:loc],map[0].sum(),sum0,beamarea,vmean,vmean,vsig) else: msg = "MOM0FLUX: %s %g %g %g %g %g %g" % ("SPW_FULL" ,map[0].sum(),sum0,beamarea,vmean,vmean,vsig) logging.regression(msg) dt.tag("mom0flux") # create a histogram of flux per channel # grab the X coordinates for the histogram, we want them in km/s # restfreq should also be in summary restfreq = casa.imhead(self.dir(infile),mode="get",hdkey="restfreq")['value']/1e9 # in GHz # print "PJT %.10f %.10f" % (restfreq,s_rest) imval0 = casa.imval(self.dir(infile)) freqs = imval0['coords'].transpose()[2]/1e9 x = (1-freqs/restfreq)*utils.c # h = casa.imstat(self.dir(infile), axes=[0,1]) if h.has_key('flux'): flux0 = h['flux'] else: flux0 = h['sum']/beamarea flux0sum = flux0.sum() * abs(x[1]-x[0]) # @todo make a flux1 with fluxes derived from a good mask flux1 = flux0 # construct histogram title = 'Flux Spectrum (%g)' % flux0sum xlab = 'VLSR (km/s)' ylab = 'Flux (Jy)' myplot.plotter(x,[flux0,flux1],title=title,figname=fluxname,xlab=xlab,ylab=ylab,histo=True) dt.tag("flux-spectrum") self._summary["moments"] = SummaryEntry(momentsummary, "Moment_AT", self.id(True), taskargs) # get rid of the temporary mask if mom0clip > 0.0: utils.rmdir(self.dir("mom0.masked")) dt.tag("done") dt.end()
def run(self): """ Main program for OverlapIntegral """ dt = utils.Dtime("OverlapIntegral") self._summary = {} chans =self.getkey("chans") cmap = self.getkey("cmap") normalize = self.getkey("normalize") doCross = True doCross = False myplot = APlot(pmode=self._plot_mode,ptype=self._plot_type,abspath=self.dir()) dt.tag("start") n = len(self._bdp_in) if n==0: raise Exception,"Need at least 1 input Image_BDP " logging.debug("Processing %d input maps" % n) data = range(n) # array in which each element is placeholder for the data mdata = range(n) # array to hold the max in each array summarytable = admit.util.Table() summarytable.columns = ["File name","Spectral Line ID"] summarytable.description = "Images used in Overlap Integral" for i in range(n): bdpfile = self._bdp_in[i].getimagefile(bt.CASA) if hasattr(self._bdp_in[i],"line"): line = getattr(self._bdp_in[i],"line") logging.info("Map %d: %s" % (i,line.uid)) lineid = line.uid else: lineid="no line" data[i] = casautil.getdata(self.dir(bdpfile),chans) mdata[i] = data[i].max() logging.info("shape[%d] = %s with %d good data" % (i,data[i].shape,data[i].count())) if i==0: shape = data[i].shape outfile = self.mkext("testOI","oi") else: if shape != data[i].shape: raise Exception,"Shapes not the same, cannot overlap them" # collect the file names and line identifications for the summary summarytable.addRow([bdpfile,lineid]) logging.regression("OI: %s" % str(mdata)) if len(shape)>2 and shape[2] > 1: raise Exception,"Cannot handle 3D cubes yet" if doCross: # debug: produce all cross-corr's of the N input maps (expensive!) crossn(data, myplot) dt.tag("crossn") b1 = Image_BDP(outfile) self.addoutput(b1) b1.setkey("image", Image(images={bt.CASA:outfile})) dt.tag("open") useClone = True # to create an output dataset, clone the first input, but using the chans=ch0~ch1 # e.g. using imsubimage(infile,outfile=,chans= if len(chans) > 0: # ia.regrid() doesn't have the chans= taskinit.ia.open(self.dir(self._bdp_in[0].getimagefile(bt.CASA))) taskinit.ia.regrid(outfile=self.dir(outfile)) taskinit.ia.close() else: # 2D for now if not useClone: logging.info("OVERLAP out=%s" % outfile) taskinit.ia.fromimage(infile=self.dir(self._bdp_in[0].getimagefile(bt.CASA)), outfile=self.dir(outfile), overwrite=True) taskinit.ia.close() dt.tag("fromimage") if n==3: # RGB logging.info("RGB mode") out = rgb1(data[0],data[1],data[2], normalize) else: # simple sum out = data[0] for i in range(1,n): out = out + data[i] if useClone: casautil.putdata_raw(self.dir(outfile),out,clone=self.dir(self._bdp_in[0].getimagefile(bt.CASA))) else: taskinit.ia.open(self.dir(outfile)) s1 = taskinit.ia.shape() s0 = [0,0,0,0] r1 = taskinit.rg.box(blc=s0,trc=s1) pixeldata = out.data pixelmask = ~out.mask taskinit.ia.putregion(pixels=pixeldata, pixelmask=pixelmask, region=r1) taskinit.ia.close() title = "OverlapIntegral" pdata = np.rot90(out.squeeze()) logging.info("PDATA: %s" % str(pdata.shape)) myplot.map1(pdata,title,"testOI",thumbnail=True,cmap=cmap) #----------------------------- # Populate summary information #----------------------------- taskargs = "chans=%s cmap=%s" % (chans, cmap) imname = "" thumbnailname = "" # uncomment when ready. imname = myplot.getFigure(figno=myplot.figno,relative=True) thumbnailname = myplot.getThumbnail(figno=myplot.figno,relative=True) #@todo fill in caption with more info - line names, etc. caption = "Need descriptive caption here" summaryinfo = [summarytable.serialize(),imname,thumbnailname,caption] self._summary["overlap"] = SummaryEntry(summaryinfo, "OverlapIntegral_AT", self.id(True),taskargs) #----------------------------- dt.tag("done") dt.end()
def _summarize(self, fitsname, casaname, header, shape, taskargs): """Convenience function to populate dictionary for items to add to the ADMIT Summary. The contract function is self.summary(), called by AT() """ self._summary = {} self._summary['fitsname'] = SummaryEntry(fitsname) self._summary['casaname'] = SummaryEntry(casaname) # these are one-to-one match keywords easy = [ 'object' , 'equinox', 'observer', 'date-obs', 'datamax', 'datamin' , 'badpixel', 'vlsr', ] naxis = len(shape) self._summary['naxis'] = SummaryEntry(naxis) for i in range(naxis): j = i+1 jay = str(j) easy.append('crpix'+jay) easy.append('ctype'+jay) easy.append('crval'+jay) easy.append('cdelt'+jay) easy.append('cunit'+jay) self._summary['naxis'+jay] = SummaryEntry(int(shape[i])) # FITS is only 8 chars. if 'telescope' in header: self._summary['telescop'] = SummaryEntry(header['telescope']) if 'imtype' in header: self._summary['bunit'] = SummaryEntry(header['bunit']) for k in easy: if k in header: self._summary[k] = SummaryEntry(header[k]) if 'restfreq' in header: self._summary['restfreq'] = SummaryEntry(header['restfreq'][0]) # These are in imhead returned as dictionaries {'unit','value'} # so we have to munge them # convert beam parameters if 'beampa' in header: self._summary['bpa'] = SummaryEntry(taskinit.qa.convert(header['beampa'],'deg')['value']) if 'beammajor' in header: self._summary['bmaj'] = SummaryEntry(taskinit.qa.convert(header['beammajor'],'rad')['value']) if 'beamminor' in header: self._summary['bmin'] = SummaryEntry(taskinit.qa.convert(header['beamminor'],'rad')['value']) # Now tag all summary items with task name and task ID. for k in self._summary: self._summary[k].setTaskname("Ingest_AT") self._summary[k].setTaskID(self.id(True)) self._summary[k].setTaskArgs(taskargs)
def run(self): """ The run method creates the BDP Parameters ---------- None Returns ------- None """ dt = utils.Dtime("CubeSum") # tagging time self._summary = {} # an ADMIT summary will be created here numsigma = self.getkey("numsigma") # get the input keys sigma = self.getkey("sigma") use_lines = self.getkey("linesum") pad = self.getkey("pad") b1 = self._bdp_in[0] # spw image cube b1a = self._bdp_in[1] # cubestats (optional) b1b = self._bdp_in[2] # linelist (optional) f1 = b1.getimagefile(bt.CASA) taskinit.ia.open(self.dir(f1)) s = taskinit.ia.summary() nchan = s['shape'][2] if b1b != None: ch0 = b1b.table.getFullColumnByName("startchan") ch1 = b1b.table.getFullColumnByName("endchan") s = Segments(ch0, ch1, nchan=nchan) # @todo something isn't merging here as i would have expected, # e.g. test0.fits [(16, 32), (16, 30), (16, 29)] if pad > 0: for (c0, c1) in s.getsegmentsastuples(): s.append([c0 - pad, c0]) s.append([c1, c1 + pad]) s.merge() s.recalcmask() # print "PJT segments:",s.getsegmentsastuples() ns = len(s.getsegmentsastuples()) chans = s.chans(not use_lines) if use_lines: msum = s.getmask() else: msum = 1 - s.getmask() logging.info("Read %d segments" % ns) # print "chans",chans # print "msum",msum # from a deprecated keyword, but kept here to pre-smooth the spectrum before clipping # examples are: ['boxcar',3] ['gaussian',7] ['hanning',5] smooth = [] sig_const = False # figure out if sigma is taken as constant in the cube if b1a == None: # if no 2nd BDP was given, sigma needs to be specified if sigma <= 0.0: raise Exception, "Neither user-supplied sigma nor CubeStats_BDP input given. One is required." else: sig_const = True # and is constant else: if sigma > 0: sigma = b1a.get("sigma") sig_const = True if sig_const: logging.info("Using constant sigma = %f" % sigma) else: logging.info("Using varying sigma per plane") infile = b1.getimagefile(bt.CASA) # ADMIT filename of the image (cube) bdp_name = self.mkext( infile, 'csm' ) # morph to the new output name with replaced extension 'csm' image_out = self.dir(bdp_name) # absolute filename args = { "imagename": self.dir(infile) } # assemble arguments for immoments() args["moments"] = 0 # only need moments=0 (or [0] is ok as well) args["outfile"] = image_out # note full pathname dt.tag("start") if sig_const: args["excludepix"] = [-numsigma * sigma, numsigma * sigma] # single global sigma if b1b != None: # print "PJT: ",chans args["chans"] = chans else: # @todo in this section bad channels can cause a fully masked cubesum = bad # cubestats input sigma_array = b1a.table.getColumnByName( "sigma") # channel dependent sigma sigma_pos = sigma_array[np.where(sigma_array > 0)] smin = sigma_pos.min() smax = sigma_pos.max() logging.info("sigma varies from %f to %f" % (smin, smax)) maxval = b1a.get("maxval") # max in cube nzeros = len(np.where(sigma_array <= 0.0)[0]) # check bad channels if nzeros > 0: logging.warning("There are %d NaN channels " % nzeros) # raise Exception,"need to recode CubeSum or use constant sigma" dt.tag("grab_sig") if len(smooth) > 0: # see also LineID and others filter = Filter1D.Filter1D( sigma_array, smooth[0], **Filter1D.Filter1D.convertargs(smooth)) sigma_array = filter.run() dt.tag("smooth_sig") # create a CASA image copy for making the mirror sigma cube to mask against file = self.dir(infile) mask = file + "_mask" taskinit.ia.fromimage(infile=file, outfile=mask) nx = taskinit.ia.shape()[0] ny = taskinit.ia.shape()[1] nchan = taskinit.ia.shape()[2] taskinit.ia.fromshape(shape=[nx, ny, 1]) plane = taskinit.ia.getchunk( [0, 0, 0], [-1, -1, 0]) # convenience plane for masking operation dt.tag("mask_sig") taskinit.ia.open(mask) dt.tag("open_mask") count = 0 for i in range(nchan): if sigma_array[i] > 0: if b1b != None: if msum[i]: taskinit.ia.putchunk(plane * 0 + sigma_array[i], blc=[0, 0, i, -1]) count = count + 1 else: taskinit.ia.putchunk(plane * 0 + maxval, blc=[0, 0, i, -1]) else: taskinit.ia.putchunk(plane * 0 + sigma_array[i], blc=[0, 0, i, -1]) count = count + 1 else: taskinit.ia.putchunk(plane * 0 + maxval, blc=[0, 0, i, -1]) taskinit.ia.close() logging.info("%d/%d channels used for CubeSum" % (count, nchan)) dt.tag("close_mask") names = [file, mask] tmp = file + '.tmp' if numsigma == 0.0: # hopefully this will also make use of the mask exp = "IM0[IM1<%f]" % (0.99 * maxval) else: exp = "IM0[abs(IM0/IM1)>%f]" % (numsigma) # print "PJT: exp",exp casa.immath(mode='evalexpr', imagename=names, expr=exp, outfile=tmp) args["imagename"] = tmp dt.tag("immath") casa.immoments(**args) dt.tag("immoments") if sig_const is False: # get rid of temporary files utils.remove(tmp) utils.remove(mask) # get the flux taskinit.ia.open(image_out) st = taskinit.ia.statistics() taskinit.ia.close() dt.tag("statistics") # report that flux, but there's no way to get the units from casa it seems # ia.summary()['unit'] is usually 'Jy/beam.km/s' for ALMA # imstat() does seem to know it. if st.has_key('flux'): rdata = [st['flux'][0], st['sum'][0]] logging.info("Total flux: %f (sum=%f)" % (st['flux'], st['sum'])) else: rdata = [st['sum'][0]] logging.info("Sum: %f (beam parameters missing)" % (st['sum'])) logging.regression("CSM: %s" % str(rdata)) # Create two output images for html and their thumbnails, too implot = ImPlot(ptype=self._plot_type, pmode=self._plot_mode, abspath=self.dir()) implot.plotter(rasterfile=bdp_name, figname=bdp_name, colorwedge=True) figname = implot.getFigure(figno=implot.figno, relative=True) thumbname = implot.getThumbnail(figno=implot.figno, relative=True) dt.tag("implot") thumbtype = bt.PNG # really should be correlated with self._plot_type!! # 2. Create a histogram of the map data # get the data for a histogram data = casautil.getdata(image_out, zeromask=True).compressed() dt.tag("getdata") # get the label for the x axis bunit = casa.imhead(imagename=image_out, mode="get", hdkey="bunit") # Make the histogram plot # Since we give abspath in the constructor, figname should be relative myplot = APlot(ptype=self._plot_type, pmode=self._plot_mode, abspath=self.dir()) auxname = bdp_name + "_histo" auxtype = bt.PNG # really should be correlated with self._plot_type!! myplot.histogram(columns=data, figname=auxname, xlab=bunit, ylab="Count", title="Histogram of CubeSum: %s" % (bdp_name), thumbnail=True) auxname = myplot.getFigure(figno=myplot.figno, relative=True) auxthumb = myplot.getThumbnail(figno=myplot.figno, relative=True) images = {bt.CASA: bdp_name, bt.PNG: figname} casaimage = Image(images=images, auxiliary=auxname, auxtype=auxtype, thumbnail=thumbname, thumbnailtype=thumbtype) if hasattr(b1, "line"): # SpwCube doesn't have Line line = deepcopy(getattr(b1, "line")) if type(line) != type(Line): line = Line(name="Undetermined") else: line = Line(name="Undetermined") # fake a Line if there wasn't one self.addoutput( Moment_BDP(xmlFile=bdp_name, moment=0, image=deepcopy(casaimage), line=line)) imcaption = "Integral (moment 0) of all emission in image cube" auxcaption = "Histogram of cube sum for image cube" taskargs = "numsigma=%.1f sigma=%g smooth=%s" % (numsigma, sigma, str(smooth)) self._summary["cubesum"] = SummaryEntry([ figname, thumbname, imcaption, auxname, auxthumb, auxcaption, bdp_name, infile ], "CubeSum_AT", self.id(True), taskargs) dt.tag("done") dt.end()