def cat(self, disk, userno): _userno = OSystem.PGetAIPSuser() OSystem.PSetAIPSuser(userno) try: num_slots = AIPSDir.PNumber(disk, userno, self.err) except OErr.OErr as err: OErr.PClear(err) return [] catalog = [] for cno in range(1, num_slots): entry = AIPSDir.PInfo(disk, userno, cno, self.err) if entry: dict = {} dict['cno'] = cno dict['name'] = entry[0:12].strip() dict['klass'] = entry[13:19].strip() dict['seq'] = int(entry[20:25]) dict['type'] = entry[26:28] dict['date'] = entry[29:40] dict['time'] = entry[41:49] catalog.append(dict) pass continue OSystem.PSetAIPSuser(_userno) return catalog
def newPACNO(disk, cno, exists, err, verbose=True): """ Create and initialize an AIPS based Image structure Create, set initial access information (full image, plane at a time) and if exists verifies the file. Returns the Python Image object isOK member set to indicate success * disk = AIPS directory number * cno = AIPS catalog number * exists = if true then the file is opened and closed to verify * err = Python Obit Error/message stack * verbose = If true any give error messages, else suppress """ ################################################################ out = ImageMF("AIPS Image") user = OSystem.PGetAIPSuser() out.isOK = True # until proven otherwise # print "disk, aseq", disk, seq # Does it really previously exist? test = AIPSDir.PInfo(disk, user, cno, err) out.exist = test != None if exists: Obit.ImageMFSetAIPS(out.me, 2, disk, cno, user, blc, trc, err.me) Obit.ImagefullInstantiate(out.cast("ObitImage"), 1, err.me) else: Obit.ImageMFSetAIPS(out.me, 2, disk, cno, user, blc, trc, err.me) # show any errors if wanted if verbose and err.isErr: out.isOK = False OErr.printErrMsg(err, "Error finding AIPS catalog entry") elif err.isErr: out.isOK = False OErr.PClear(err) # Clear unwanted messages # It work? if not out.isOK: return out # Add File info out.FileType = 'AIPS' out.Disk = disk out.Acno = cno # Lookup name etc s = AIPSDir.PInfo(disk, user, cno, err) # parse returned string Aname = s[0:12] Aclass = s[13:19] Aseq = int(s[20:25]) Atype = s[26:28] out.Aname = Aname out.Aclass = Aclass out.Aseq = Aseq out.Otype = "Image" return out # seems OK
def EVLAPolnCleanup(uv, Sources, err, \ logfile = "",check=False, debug = False): """ Zap uv data and any calibration images in AIPS Returns 0 on success otherwise failure * uv = UV data with calibration and editing * Sources = List of Source Models as created by EVLACal.EVLACalModel * err = Obit error/message stack * logfile = Log file for task * check = Only check script * debug = Run tasks debug, show input """ ################################################################ mess = "Cleanup, Zap AIPS files, check = "+str(check) printMess(mess, logfile) # Zap data if UV.PIsA(uv): mess = "Zap uv data" printMess(mess, logfile) if not check: uv.Zap(err) # cleanup if err.isErr: mess = "Error Zapping uv file" printMess(mess, logfile) return 1 # Zap calibration images stokes = ["I","Q","U"] for sou in Sources: # Ignore FITS images if sou["CalDataType"]=="FITS": continue for s in stokes: klass = s+sou["CalClass"][1:] # Test if file exists cno = AIPSDir.PTestCNO(sou["CalDisk"], AIPS.userno, \ sou["CalName"][0:12], klass, "MA", sou["CalSeq"], err) if cno>0: img = Image.newPAImage("img", sou["CalName"][0:12], klass, \ sou["CalDisk"], sou["CalSeq"], True, err) if err.isErr: mess = "Error finding "+s+" image for "+sou["Source"] printMess(mess, logfile) return 1 if Image.PIsA(img): mess = "Zap "+sou["Source"].strip()+" "+s+"Pol" printMess(mess, logfile) if not check: img.Zap(err) # cleanup del img if err.isErr: mess = "Error Zapping image" printMess(mess, logfile) return 1 # end if exist # end source/stokes loop return 0
def getname(cno, disk=Adisk): """ Return Obit object for AIPS file in cno on disk * cno = AIPS catalog slot number * disk = AIPS disk number """ ################################################################ Adisk = disk user = AIPS.AIPS.userno s = AIPSDir.PInfo(disk, user, cno, err) OErr.printErrMsg(err, "Error with AIPS catalog") # parse returned string Aname = s[0:12] Aclass = s[13:19] Aseq = int(s[20:25]) Atype = s[26:28] if Atype == 'MA': out = Image.newPAImage("AIPS image", Aname, Aclass, disk, Aseq, True, err) print("AIPS Image", Aname, Aclass, disk, Aseq) elif Atype == 'UV': out = UV.newPAUV("AIPS UV data", Aname, Aclass, disk, Aseq, True, err) print("AIPS UV", Aname, Aclass, disk, Aseq) out.Aname = Aname out.Aclass = Aclass out.Aseq = Aseq out.Atype = Atype out.Disk = disk out.Acno = cno return out
def AUcat(disk=Adisk, first=1, last=1000): """ Catalog listing of AIPS UV data files on disk disk * disk = AIPS disk number to list * first = lowest slot number to list * last = highest slot number to list """ ################################################################ Adisk = disk AIPSDir.PListDir(disk, err, type=AIPSDir.UVType, first=first, last=last) OErr.printErrMsg(err, "Error with AIPS catalog")
def exists(self): # Do I exist? exists = False if self.uv.FileType == "FITS": exists = FITSDir.PExist(self.uv.FileName, self.uv.Disk, self._err) elif self.uv.FileType == "AIPS": user = OSystem.PGetAIPSuser() test = AIPSDir.PTestCNO(self.uv.Disk, user, self.uv.Aname, self.uv.Aclass, "UV", self.uv.Aseq, self._err) exists = test > 0 return exists
def cat(self, disk, userno, url, AIPSdirs): # Init Obit if needed if not OSystem.PIsInit(): popsno = 1 if not self.err: self.err=OErr.OErr() ObitSys=OSystem.OSystem ("", popsno, userno, \ len(AIPSdirs), AIPSdirs, \ 0, [], True, False, self.err) OErr.printErrMsg(self.err, "Error with Obit startup") doInit = True else: doInit = False _userno = OSystem.PGetAIPSuser() OSystem.PSetAIPSuser(userno) try: num_slots = AIPSDir.PNumber(disk, userno, self.err) except OErr.OErr as err: OErr.PClear(err) if doInit: # Initialized Obit? OSystem.Shutdown(ObitSys) self.doInit = False return [] catalog = [] for slot in range(1, num_slots): entry = AIPSDir.PInfo(disk, userno, slot, self.err) if entry: catalog.append((slot, entry)) pass continue # Restore Obit to initial state OSystem.PSetAIPSuser(_userno) if doInit: # Initialized Obit? OSystem.Shutdown(ObitSys) self.doInit = False OErr.printErrMsg(self.err, "Error with AIPS Catalog") return catalog
def Acat(disk=Adisk, first=1, last=1000): """ Catalog listing of AIPS files on disk disk The class remembers the last disk accessed * disk = AIPS disk number to list * first = lowest slot number to list * last =highest slot number to list """ ################################################################ Adisk = disk AIPSDir.PListDir(disk, err, first=first, last=last) OErr.printErrMsg(err, "Error with AIPS catalog")
def AllDest(err, disk=None, Atype=" ", Aname=" ", Aclass=" ", Aseq=0): """ Delete AIPS files matching a pattern. Strings use AIPS wild cards: * blank => any * '?' => one of any character * "*" => arbitrary string * disk = AIPS disk number, 0=>all * Atype = AIPS entry type, 'MA' or 'UV'; ' => all * Aname = desired AIPS name, using AIPS wildcards, None -> don't check * Aclass = desired AIPS class, using AIPS wildcards, None -> don't check * Aseq = desired AIPS sequence, 0=> any """ ################################################################ if err.isErr: # Ignore if error condition return global Adisk if disk == None: disk = Adisk else: if disk > 0: Adisk = disk # NO Confirm #prompt = "Do you really want to delete all AIPS "+Atype+" files on disk(s) "\ # +str(disk)+"\nwith names matching "+Aname+"."+Aclass+"."+str(Aseq)+ \ # " y/n " #ans = raw_input(prompt) #if ans.startswith('y'): AIPSDir.PAllDest(disk, err, Atype=Atype, Aname=Aname, Aclass=Aclass, Aseq=Aseq) #else: # print "Not confirmed" OErr.printErrMsg(err, "Error with destroying AIPS enreies")
def cat(self, disk, userno, url, AIPSdirs): # Init Obit if needed if not OSystem.PIsInit(): popsno = 1 if not self.err: self.err=OErr.OErr() ObitSys=OSystem.OSystem ("", popsno, userno, \ len(AIPSdirs), AIPSdirs, \ 0, [], True, False, self.err) OErr.printErrMsg(self.err, "Error with Obit startup") doInit = True else: doInit = False _userno = OSystem.PGetAIPSuser() OSystem.PSetAIPSuser(userno) try: num_slots = AIPSDir.PNumber(disk, userno, self.err) except OErr.OErr, err: OErr.PClear(err) if doInit: # Initialized Obit? OSystem.Shutdown(ObitSys) self.doInit = False return []
print exception mess = "TabCopy Failed retCode= "+str(taco.retCode) printMess(mess, logfile) return 1 # end loop over tables # Write calibration images stokes = ["I","Q","U"] for sou in Sources: # Ignore FITS images if sou["CalDataType"]=="FITS": continue for s in stokes: klass = s+sou["CalClass"][1:] # Test if file exists cno = AIPSDir.PTestCNO(sou["CalDisk"], AIPS.userno, \ sou["CalName"][0:12], klass, "MA", sou["CalSeq"], err) if cno>0: img = Image.newPAImage("img", sou["CalName"][0:12], klass, \ sou["CalDisk"], sou["CalSeq"], True, err) if err.isErr: mess = "Error finding "+s+" image for "+sou["Source"] printMess(mess, logfile) return 1 imgfile = sou["Source"].strip()+session+s+"Pol.fits" EVLACal. EVLAImFITS (img, imgfile, outDisk, err, logfile=logfile) if err.isErr: OErr.printErrMsg(err, "Error Writing image") return 1 else: mess = "Skip writing "+s+" image for "+sou["Source"] printMess(mess, logfile)
def VLAUVLoad(filename, inDisk, Aname, Aclass, Adisk, Aseq, err, logfile=''): """ Read FITS uvtab file into AIPS Read a UVTAB FITS UV data file and write an AIPS data set filename = name of FITS file inDisk = FITS directory number Aname = AIPS name of file Aclass = AIPS class of file Aseq = AIPS sequence number of file, 0=> create new Adisk = FITS directory number err = Python Obit Error/message stack logfile = logfile for messages returns AIPS UV data object """ ################################################################ # # Checks if not OErr.OErrIsA(err): raise TypeError, "err MUST be an OErr" # # Get input inUV = UV.newPFUV("FITS UV DATA", filename, inDisk, True, err) if err.isErr: OErr.printErrMsg(err, "Error with FITS data") # Get output, create new if seq=0 if Aseq < 1: OErr.printErr(err) # Print any outstanding messages user = OSystem.PGetAIPSuser() Aseq = AIPSDir.PHiSeq(Adisk, user, Aname, Aclass, "MA", err) # If it already exists, increment seq if AIPSDir.PTestCNO(Adisk, user, Aname, Aclass, "MA", Aseq, err) > 0: Aseq = Aseq + 1 OErr.PClear(err) # Clear any message/error mess = "Creating AIPS UV file " + Aname + "." + Aclass + "." + str( Aseq) + " on disk " + str(Adisk) printMess(mess, logfile) outUV = UV.newPAUV("AIPS UV DATA", Aname, Aclass, Adisk, Aseq, False, err) if err.isErr: OErr.printErrMsg(err, "Error creating AIPS data") # Copy UV.PCopy(inUV, outUV, err) if err.isErr: OErr.printErrMsg(err, "Error copying UV data to AIPS") # Copy History inHistory = History.History("inhistory", inUV.List, err) outHistory = History.History("outhistory", outUV.List, err) History.PCopyHeader(inHistory, outHistory, err) # Add history outHistory.Open(History.READWRITE, err) outHistory.TimeStamp(" Start Obit uvlod", err) outHistory.WriteRec( -1, "uvlod / FITS file " + filename + " disk " + str(inDisk), err) outHistory.Close(err) # # Copy Tables exclude = [ "AIPS HI", "AIPS AN", "AIPS FQ", "AIPS SL", "AIPS PL", "History" ] include = [] UV.PCopyTables(inUV, outUV, exclude, include, err) return outUV # return new object
def SetEnviron(AIPS_ROOT=None, AIPS_VERSION=None, OBIT_EXEC=None, \ DA00=None, ARCH="LNX64", aipsdirs=None, fitsdirs=None): """ Set environment variables for AIPS, Obit and data access AIPS_ROOT = name of the directory at the root of the AIPS directories AIPS_VERSION = name of the directory at root of specific AIPS version OBIT_EXEC = name of directory with Obit bin and TDF directories DA00 = name of directory for AIPS DA00 ARCH = AIPS architecture string aipsdirs = list of tuples defining AIPS data directories first element is url, None = local, for remote data use form 'http://mymachine.org:8000/RPC2' second element is full path to AIPS data directory fitsdirs = list of tuples defining FITS data directories first element is url, None = local second element is full path to FITS directory """ # Set AIPS_ROOT and AIPS_VERSION for access to AIPS Software if AIPS_ROOT: os.environ["AIPS_ROOT"] = AIPS_ROOT # python environment cmd = "export AIPS_ROOT="+AIPS_ROOT # shell environment #print cmd z=os.system(cmd) if AIPS_VERSION: os.environ["AIPS_VERSION"] = AIPS_VERSION # python environment cmd = "export AIPS_VERSION="+AIPS_VERSION # shell environment #print cmd z=os.system(cmd) # Set Obit directory if OBIT_EXEC: os.environ["OBITEXEC"] = OBIT_EXEC # python environment cmd = "export OBITEXEC="+OBIT_EXEC # shell environment #print cmd z=os.system(cmd) # Set AIPS DA00 if DA00: os.environ["DA00"] = DA00 # python environment cmd = "export DA00="+DA00 # shell environment #print cmd z=os.system(cmd) # Set AIPS DA00 if ARCH: os.environ["ARCH"] = ARCH # python environment cmd = "export ARCH="+ARCH # shell environment #print cmd z=os.system(cmd) # Set AIPS directories if aipsdirs: for dirname in aipsdirs: url = dirname[0] # Already known? known = False for adisk in AIPS.disks[1:]: if (adisk.url==url) and (adisk.dirname==dirname[1]): known = True break if not known: # New local or remote AIPS disk disk = len(AIPS.disks) AIPS.disks.append(AIPSDisk(url, disk, dirname[1]+'/')) AIPSDir.PSetDir(disk, dirname[1]+'/', err, URL=url) # Define environment variable for local disks if url==None: dskno = "DA"+AIPSUtil.ehex(disk,width=2,padding='0') os.environ[dskno] = dirname[1]+'/' # Python environment cmd = "export "+dskno+"="+dirname[1]+'/' # shell environment #print cmd z=os.system(cmd) # Set NVOL so AIPS Tasks will know how many AIPS disks naips = len(AIPS.disks)-1 os.environ['NVOL'] = str(naips) # Python evironment # Set FITS directories (URL, disk name) import FITSDir # Need Obit/python if fitsdirs: from FITS import FITSDisk # First is $FITS if len(fitsdirs)>0: cmd = "export FITS="+fitsdirs[0][1]+'/' z=os.system(cmd) # shell environment os.environ["FITS"] = fitsdirs[0][1]+'/' # Python environment # Override previous? if len(FITS.disks)>1: FITS.disks[1].dirname = fitsdirs[0][1]+'/' FITSDir.FITSdisks[0] = fitsdirs[0][1] disk = 0 FITSDir.PSetDir(fitsdirs[0][1]+'/', disk, err, URL=url) else: url = fitsdirs[0][0] FITSDir.PAddDir(fitsdirs[0][1]+'/', err, URL=url) # Other FITS directories for dirname in fitsdirs[1:]: url = dirname[0] # Already known? known = False for fdisk in FITS.disks[1:]: if (fdisk.url==url) and (fdisk.dirname==dirname[1]): known = True break if not known: # New local or remote AIPS disk disk = len(FITS.disks) FITSDir.PAddDir(dirname[1]+'/', err, URL=url) # Define environment variable for local disks if url==None: dskno = "FITS"+AIPSUtil.ehex(disk-1,width=2,padding='0') os.environ[dskno] = dirname[1]+'/' # Python environment cmd = "export "+dskno+"="+dirname[1]+'/' # shell environment #print cmd z=os.system(cmd)
# Test AIPS directory listing import Obit, OSystem, OErr, AIPSDir, Image, ODisplay # Init Obit err=OErr.OErr() ObitSys=OSystem.OSystem ("Imager", 1, 100, 1, ["/DATA/LUSUS_1/"], 1, ["../PythonData/"], 1, 0, err) OErr.printErrMsg(err, "Error with Obit startup") from Obit import Bomb disk=1 # list directory AIPSDir.PListDir(disk, err) a=Image.newPACNO(1,4,True,err) d=ODisplay.ODisplay("ObitView","ObitView",err) ODisplay.PImage(d,a,err) # Shutdown Obit OErr.printErr(err) del ObitSys
def EVLAPolnToFITS(uv, outFile, outDisk, Sources, session, err, \ logfile = "",check=False, debug = False): """ Copy new calibration and editing tables from uv to the input FITS file Any SN, CL, BP, PD, CP tables not on outFile are copied from uv uv FG table 1 is copied to outFile table 2 Also writes AIPS calibrator images (I, Q, U) Returns 0 on success otherwise failure * uv = UV data with calibration and editing * outFile = Name of FITS file to write tables to * outDisk = FITS disk for inFile, 0=>cwd * Sources = List of Source Models as created by EVLACal.EVLACalModel * session = Name of session, used for FITS images * err = Obit error/message stack * logfile = Log file for task * check = Only check script * debug = Run tasks debug, show input """ ################################################################ mess = "Save resultant tables, calibration images" printMess(mess, logfile) # Copy tables not on inFile # UV Data for infile outUV = UV.newPFUV("FITS UV DATA", outFile, outDisk, True, err) if err.isErr: OErr.printErrMsg(err, "Error with FITS data") # Use TabCopy taco = ObitTask.ObitTask("TabCopy") taco.user = AIPS.userno # This gets lost somehow setname(uv, taco) taco.taskLog = logfile taco.DataType = "AIPS" taco.outDType = "FITS" taco.outFile = outFile taco.outDisk = outDisk # FG inHi = UV.PGetHighVer(uv, "AIPS FG") outHi = UV.PGetHighVer(outUV, "AIPS FG") if outHi < 2: # copy uv FG table 1 to outUV FG 2 (new table) mess = "Copy FG 1 to FG 2" printMess(mess, logfile) taco.inTab = "AIPS FG" taco.inVer = 1 taco.outVer = 2 # Trap failure try: if not check: taco.g except Exception as exception: print(exception) mess = "TabCopy Failed retCode= " + str(taco.retCode) printMess(mess, logfile) return 1 # Other tables tabs = ["BP", "CL", "SN", "PD", "CP"] for tt in tabs: ttype = "AIPS " + tt inHi = UV.PGetHighVer(uv, ttype) outHi = UV.PGetHighVer(outUV, ttype) mess = "Copy " + tt + " tables " + str(outHi + 1) + " to " + str(inHi) printMess(mess, logfile) for ver in range(outHi + 1, inHi + 1): taco.inTab = ttype taco.inVer = ver taco.outVer = ver # Trap failure try: if not check: taco.g except Exception as exception: print(exception) mess = "TabCopy Failed retCode= " + str(taco.retCode) printMess(mess, logfile) return 1 # end loop over tables # Write calibration images stokes = ["I", "Q", "U"] for sou in Sources: # Ignore FITS images if sou["CalDataType"] == "FITS": continue for s in stokes: klass = s + sou["CalClass"][1:] # Test if file exists cno = AIPSDir.PTestCNO(sou["CalDisk"], AIPS.userno, \ sou["CalName"][0:12], klass, "MA", sou["CalSeq"], err) if cno > 0: img = Image.newPAImage("img", sou["CalName"][0:12], klass, \ sou["CalDisk"], sou["CalSeq"], True, err) if err.isErr: mess = "Error finding " + s + " image for " + sou["Source"] printMess(mess, logfile) return 1 imgfile = sou["Source"].strip() + session + s + "Pol.fits" EVLACal.EVLAImFITS(img, imgfile, outDisk, err, logfile=logfile) if err.isErr: OErr.printErrMsg(err, "Error Writing image") return 1 else: mess = "Skip writing " + s + " image for " + sou["Source"] printMess(mess, logfile) # end if exist # end loops over Stokes and source return 0
def EVLAPolnImage(uv, err, Sources=None, FreqID=1, seq=1, sclass="IClean", band="", \ doCalib=-1, gainUse=0, doBand=-1, BPVer=0, flagVer=-1, maxPixel=50000, \ doPol=False, PDVer=-1, minFlux=0.0, BIF=1, EIF=0, \ Stokes="I", FOV=20.0/3600.0, Robust=0, Niter=300, CleanRad=None, \ maxPSCLoop=0, minFluxPSC=0.1, solPInt=20.0/60.,\ solPMode="P", solPType= "L1", Gain=0.1, \ maxASCLoop=0, minFluxASC=0.5, solAInt=2.0, \ solAMode="A&P", solAType= "L1", Beam=[0.0,0.0,0.0], \ avgPol=False, avgIF=False, minSNR = 5.0, refAnt=0, \ do3D=False, BLFact=0.999, BLchAvg=False, doOutlier=None, \ doMB=False, norder=1, maxFBW=0.05, doComRes=False, \ nTaper=0, Tapers=[20.0], dispURL="None", \ nThreads=1, noScrat=[], logfile='', check=False, debug=False): """ Image a list of sources with optional selfcal Uses Imager or MFImage to image a list of sources. Data must be at least approximately calibrated Returns list of source models, None on failure * uv = UV data object * err = Python Obit Error/message stack * Sources = Source name or list of names to use If an empty list all sources in uv are included * seq = sequence number of output * sclass = Image output class * band = project band - appended to name * BIF = First IF * CIF = Highest IF * FreqID = Frequency group identifier * doCalib = Apply calibration table * gainUse = CL/SN table to apply * doBand = If >0.5 apply bandpass cal. * BPVer = Bandpass table version * flagVer = Input Flagging table version * doPol = Apply polarization cal? * PDVer = PD version for pol cal, -1=>use IF * minFlux = minimum flux density for initial CLEAN * Stokes = Stokes parameters to image * FOV = Field of view to image in deg * Robust = Weighting robustness parameter * Niter = max no. iterations * Gain = CLEAN loop gain * maxPixel = Maximum number of residuals in inner CLEAN * CleanRad = CLEAN radius about center or None=autoWin * maxPSCLoop = max. number of phase sc loops * minFluxPSC = Trip level for phase self cal (Jy) * solPInt = Phase solution interval (min) * solPMode = Phase soln mode "P", "DELA" * solPType = Phase soln type * maxASCLoop = max. number of amp&phase sc loops * minFluxASC = Trip level for amp&phase self cal (Jy) * solAInt = Amp&phase solution interval (min) * solAMode = Amp&Phase soln mode "A&P", "P", "DELA" * solAType = Amp&PPhase soln type * Beam = CLEAN restoring beam * avgPol = Average poln in SC? * avgIF = Average IFs in SC? * minSNR = minimum acceptable SNR in SC * refAnt = Reference antenna * do3D = Use 3D imaging? * doComRes = Force common resolution in frequency? (MF) * BLFact = Baseline dependent averaging factor * BLchAvg = If True and BLFact>=1.0 also average channels * doOutlier = Outliers from NVSS? Yes=> 4*FOV, 1 mJy None = Default, Yes if freq<6 GHz * doMB = If True is wideband imaging * norder = order on wideband imaging * maxFBW = max. fractional wideband imaging * nTaper = number of (additional) multi resolution tapers * Tapers = Sizes of additional tapers in pixels * dispURL = Name of image display * nThreads = Max. number of threads to use * noScrat = list of disks to avoid for scratch files * logfile = logfile for messages * check = Only check script, don't execute tasks * debug = show input """ ################################################################ mess = "Image a list of sources " printMess(mess, logfile) # Tolerate missing BP table # Open and close image to sync with disk uv.Open(UV.READONLY, err) uv.Close(err) hiBP = uv.GetHighVer("AIPS BP") if hiBP<=0: doBand = -1 # get reference Freq refFreq = uv.Desc.Dict["crval"][uv.Desc.Dict["jlocf"]] # If list empty get all sources if type(Sources)==list: sl = Sources else: sl = [Sources] if len(sl)<=0: slist = EVLAAllSource(uv,err,logfile=logfile,check=check,debug=debug) else: slist = sl if doMB: imager = ObitTask.ObitTask("MFImage") imager.norder = norder imager.maxFBW = maxFBW imager.prtLv = 2 else: imager = ObitTask.ObitTask("Imager") imager.prtLv = 2 imager.user = AIPS.userno # This gets lost somehow imager.taskLog = logfile if not check: setname(uv,imager) imager.outDisk = imager.inDisk imager.outName = "_"+band imager.out2Name = "_"+band imager.out2Disk = imager.inDisk imager.outSeq = seq imager.out2Seq = seq imager.outClass = sclass imager.BIF = BIF imager.EIF = EIF imager.BLFact = BLFact imager.BLchAvg = BLchAvg imager.flagVer = flagVer imager.doCalib = doCalib imager.gainUse = gainUse imager.doBand = doBand imager.BPVer = BPVer imager.doPol = doPol if "PDVer" in imager.__dict__: imager.PDVer = PDVer imager.Stokes = Stokes imager.FOV = FOV imager.Robust = Robust imager.Niter = Niter imager.Gain = Gain imager.Beam = Beam imager.maxPixel = maxPixel imager.minFlux = minFlux imager.maxPixel = maxPixel imager.maxPSCLoop = maxPSCLoop imager.minFluxPSC = minFluxPSC imager.solPInt = solPInt imager.solPMode = solPMode imager.solPType = solPType imager.maxASCLoop = maxASCLoop imager.minFluxASC = minFluxASC imager.solAInt = solAInt imager.solAMode = solAMode imager.solAType = solAType imager.avgPol = avgPol imager.avgIF = avgIF imager.refAnt = refAnt imager.minSNR = minSNR imager.do3D = do3D imager.dispURL = dispURL imager.nTaper = nTaper imager.Tapers = Tapers if doOutlier or ((doOutlier==None) and refFreq<6.0e9): FWHM = (45.0 /(refFreq*1.0e-9) ) / 60. # FWHM in deg imager.OutlierDist = FWHM*2.0 # Outliers from NVSS for lower frequencies imager.OutlierFlux = 0.01 # Auto window or centered box if CleanRad: imager.CLEANBox=[-1,CleanRad,0,0] else: imager.autoWindow = True if "doComRes" in imager.__dict__: imager.doComRes = doComRes imager.noScrat = noScrat imager.nThreads = nThreads if debug: imager.prtLv = 5 imager.i imager.debug = debug OK = False # Some must work modelList = [] # Init output model list # Loop over slist for sou in slist: imager.Sources[0] = sou mess = "Image "+sou printMess(mess, logfile) # Trap failure try: if not check: imager.g except Exception, exception: print exception mess = "Imager Failed retCode= "+str(imager.retCode) printMess(mess, logfile) #return 1 Allow some failures # Cleanup image mess AllDest(err,Atype="MA",Aname=imager.Sources[0], disk=imager.outDisk, Aseq=imager.outSeq); else: OK = True # delete Imager file if not debug if not debug: out2Name = imager.Sources[0].strip()+"_"+band out2Name = out2Name[0:12] if doMB: out2Class = "MFImage" else: out2Class = "Imager" # Tolerate failures try: # Test if file exists cno = AIPSDir.PTestCNO(imager.out2Disk, AIPS.userno, \ out2Name, out2Class, "UV", imager.out2Seq, err) if cno>0: u = UV.newPAUV("zap", out2Name, out2Class, imager.out2Disk, imager.out2Seq, False, err) if UV.PIsA(u): u.Zap(err) # cleanup if err.isErr: mess = "Error deleting Imager work file" printMess(mess, logfile) #return 1 del u # Create model, add to modelList modelList.append(EVLACal.EVLACalModel(sou, CalName=imager.Sources[0]+imager.outName, \ CalClass=imager.outClass, \ CalSeq=imager.outSeq, \ CalCmethod="DFT", CalDataType="AIPS", \ CalDisk=imager.outDisk, CalNfield=1)) except Exception, exception: print exception mess = "Imager Cleanup Failed source= "+imager.Sources[0].strip()+"_"+band printMess(mess, logfile) OErr.PClear(err) # Clear any message/error #return 1 Allow some failures else: pass
def EVLAPolnFlag (uv, souModels, err, \ flagTab=1, timeAvg=0.0, maxAmp=1.0, \ doCalib=0, gainUse=0, doBand=0, BPVer=0, flagVer=-1, \ doPol=False, PDVer=1, nThreads=1, \ check=False, debug = False, noScrat=[], logfile = ""): """ Subtract a polarization model from a data set and flag by residuals Data flagged using AutoFlag with points larger than maxAmp Returns task error code, 0=OK, else failed * uv = UV data object to calibrate * souModels= List of Source Models as created by EVLACal.EVLACalModel * err = Obit error/message stack * flagTab = Output Flagging table version * timeAvg = Time over which data is vector averaged * maxAmp = maximum allowed residual, single or list per source #* flagSig = Flagging level (sigma) #* alpha = Smoothing parameter #* timeWind = MWF width (min) #* avgTime = pre average time (min) #* avgFreq = Averaging in frequency # 0 = none # 1 = average chAvg channels # 2 = average all channels # 3 = average all channels, IFs * doCalib = Apply calibration table * chAvg = Number of channels to average * gainUse = CL/SN table to apply * doBand = If >0.5 apply bandpass cal. * BPVer = Bandpass table version * doPol = If True apply poln cal * PDVer = AIPS PD polarization cal table to apply * flagVer = Input Flagging table version * check = Only check script, don't execute tasks * debug = Run tasks debug, show input * nThreads = Number of threads to use * noScrat = list of disks to avoid for scratch files * logfile = Log file for task """ if len(souModels)<=0: # Anything to work on? return 0 mess = "Flag residuals from models " printMess(mess, logfile) # Setup UVSub uvsub = ObitTask.ObitTask("UVSub") if not check: setname(uv,uvsub) uvsub.user = AIPS.userno # This gets lost somehow uvsub.taskLog = logfile uvsub.nThreads = nThreads uvsub.noScrat = noScrat uvsub.outDisk = uv.Disk uvsub.flagVer = flagVer uvsub.doCalib = doCalib uvsub.gainUse = gainUse uvsub.doBand = doBand uvsub.BPVer = BPVer if "PDVer" in uvsub.__dict__: uvsub.doPol = doPol uvsub.PDVer = PDVer # setup for flagging #flag = ObitTask.ObitTask("MednFlag") flag = ObitTask.ObitTask("AutoFlag") flag.user = AIPS.userno # This gets lost somehow if not check: setoname(uv,flag) flag.taskLog = logfile flag.nThreads = nThreads flag.flagTab = flagTab flag.timeAvg = timeAvg if type(maxAmp)!=list: flag.IClip = [maxAmp, 0.1] #flag.flagSig = flagSig #flag.alpha = alpha #flag.timeWind = timeWind #flag.avgTime = avgTime #flag.avgFreq = avgFreq #flag.chAvg = chAvg # Loop over sources OK = False i = -1 for model in souModels: i += 1 uvsub.Sources[0]= model["Source"] if "DataType2" in uvsub.__dict__: uvsub.DataType2 = model["CalDataType"] uvsub.in2File = model["CalFile"] uvsub.in2Name = model["CalName"][0:12] uvsub.in2Class = model["CalClass"] uvsub.in2Seq = model["CalSeq"] uvsub.in2Disk = model["CalDisk"] if "nmaps" in uvsub.__dict__: uvsub.nmaps = model["CalNfield"] else: uvsub.nfield = model["CalNfield"] uvsub.CCVer = model["CalCCVer"] uvsub.BComp = model["CalBComp"] uvsub.EComp = model["CalEComp"] uvsub.Cmethod = model["CalCmethod"] uvsub.Cmodel = model["CalCmodel"] uvsub.Flux = model["CalFlux"] if "Alpha" in uvsub.__dict__: uvsub.Alpha = model["CalModelSI"] uvsub.modelFlux = model["CalModelFlux"] uvsub.modelPos = model["CalModelPos"] uvsub.modelParm = model["CalModelParm"] # Setup scratch output file uvsub.outName = model["Source"][0:12] uvsub.outClass = "PolFlg" uvsub.outSeq = 6666 if debug: uvsub.i uvsub.debug = debug # Trap failure try: mess = "Run UVSub on "+uvsub.Sources[0]+", then edit residuals above "+str(maxAmp[i]) printMess(mess, logfile) if not check: uvsub.g except Exception, exception: print exception mess = "UVSub Failed retCode= "+str(uvsub.retCode)+" Source "+uvsub.Sources[0] printMess(mess, logfile) return uvsub.retCode else: OK = True # Now flag cno = AIPSDir.PTestCNO(uvsub.outDisk, AIPS.userno, \ uvsub.outName, uvsub.outClass, "UV", uvsub.outSeq, err) if cno>0: uvscr = UV.newPAUV("zap", uvsub.outName, uvsub.outClass, uvsub.outDisk, uvsub.outSeq, False, err) else: mess = "No subtracted data created for Source "+uvsub.Sources[0] printMess(mess, logfile) return 1 # Flag using scratch writing input FG flag.Sources[0]= uvsub.Sources[0] if type(maxAmp)==list: flag.IClip = [maxAmp[i], 0.1] if not check: setname(uvscr, flag) if debug: flag.i flag.debug = debug # Trap failure try: if not check: flag.g except Exception, exception: print exception mess = "AutoFlag Failed retCode= "+str(flag.retCode)+" Source "+flag.Sources[0] printMess(mess, logfile) return flag.retCode
def newPAImage(name, Aname, Aclass, disk, seq, exists, err, verbose=False): """ Create and initialize an AIPS based Image structure Create, set initial access information (full image, plane at a time) and if exists verifies the file. Returns the Python Image object isOK member set to indicate success * name = name desired for object (labeling purposes) * Aname = AIPS name of file * Aclass = AIPS class of file * seq = AIPS sequence number of file * disk = FITS directory number * exists = if true then the file is opened and closed to verify * err = Python Obit Error/message stack * verbose = If true any give error messages, else suppress """ ################################################################ out = ImageMF(name) out.isOK = True # until proven otherwise cno = -1 user = OSystem.PGetAIPSuser() # print "disk, aseq", disk, seq # Does it really previously exist? test = AIPSDir.PTestCNO(disk, user, Aname, Aclass, "MA", seq, err) out.exist = test > 0 if exists: # If user thinks file exists... if out.exist: # If file is defined in catalog -> verify that file exists OErr.PLog(err, OErr.Info, Aname + " image found. Now verifying...") if verbose: OErr.printErr(err) cno = AIPSDir.PFindCNO(disk, user, Aname, Aclass, "MA", seq, err) Obit.ImageMFSetAIPS(out.me, 2, disk, cno, user, blc, trc, err.me) Obit.ImagefullInstantiate(out.cast("ObitImage"), 1, err.me) #print "found",Aname,Aclass,"as",cno else: # If file not defined in catalog -> error OErr.PLog(err, OErr.Error, Aname + " image does not exist") out.isOK = False else: # exists=False # Create new image entry in catalog; if image already defined, this # has no effect OErr.PLog(err, OErr.Info, "Creating new image: " + Aname + ", " + Aclass) if verbose: OErr.printErr(err) cno = AIPSDir.PAlloc(disk, user, Aname, Aclass, "MA", seq, err) Obit.ImageMFSetAIPS(out.me, 2, disk, cno, user, blc, trc, err.me) #print "assigned",Aname,Aclass,"to",cno # show any errors if wanted if verbose and err.isErr: out.isOK = False OErr.printErrMsg(err, "Error creating AIPS Image object") elif err.isErr: out.isOK = False OErr.PClear(err) # Clear unwanted messages else: OErr.PClear(err) # Clear non-error messages # It work? if not out.isOK: return out # Add File info out.FileType = 'AIPS' out.Disk = disk out.Aname = Aname out.Aclass = Aclass out.Aseq = seq out.Otype = "Image" out.Acno = cno return out # seems OK