def writeSelf(self, configData): """ Writes itself to a JSON file in the web folder """ filename = ultracamutils.addPaths(configData.SITE_PATH, self.runDate) filename = ultracamutils.addPaths(filename, self.runID) if self.version!='primary': filename+= "_" + str(self.version); filename+= "_info.json" print "Updating runinfo in file: ", filename outputObject = {} outputObject["target"] = self.target outputObject["date"] = self.runDate outputObject["runID"] = self.runID outputObject["comment"] = self.comment outputObject["ra"] = self.ra outputObject["dec"] = self.dec outputObject["expose"] = self.expose outputObject["objectID"] = self.objectID outputObject["dataProcessed"] = self.dataProcessed outputObject['numWindows'] = self.numWindows outputObject['maxExtents'] = self.maxExtents if hasattr(self, 'sexMagnitude'): outputObject['sexMagnitude'] = self.sexMagnitude if hasattr(self, 'sexOptions'): outputObject['sexOptions'] = self.sexOptions JSONfile = open(filename, 'w') json.dump(outputObject, JSONfile) JSONfile.close()
def checkForComments(self, rawDataPath): """ Does a check for comments in the DDDD-MM-YY.dat file in the raw data path """ filename = ultracamutils.addPaths(rawDataPath, self.runDate) filename = ultracamutils.addPaths(filename, self.runDate) + '.dat' dataFile = open(filename, 'r') for line in dataFile: runIdentifier = line[:6] if (runIdentifier==self.runID): self.comment = line[7:]
def __init__(self, date, runName): self.runID = runName self.runDate = date config = utils.readConfigFile() runPath = utils.addPaths(config.ULTRACAMRAW, date) runPath = ultracamutils.addPaths(runPath, runName) self.totalTime = 0 runMetaData = trm.ultracam.Rhead(runPath, server=False) self.mode = runMetaData.mode #self.userData = runMetaData.user try: self.nblue = runMetaData.nblue except AttributeError: self.nblue = 1 if (self.mode != "PONOFF"): runData = trm.ultracam.Rdata(runPath, 1, server=False) self.numFrames = runData.ntotal() else: self.numFrames = 0 self.runClass = 0 self.comment = "" self.ra = 0 self.dec = 0 self.objectID = "?" self.target = "?" self.expose = 0 try: self.exposeTime = runMetaData.exposeTime except: self.exposeTime = -1 self.num = 0 self.dataProcessed = False self.numWindows = 0 self.maxExtents = [0, 0, 0, 0] self.version = 'primary'
def loadFromXML(self, rawDataDirectory): """ This method is called upon if the loadFromJSON method fails to return any data """ print "Trying to load run info from the XML file" XMLFilename = ultracamutils.addPaths(rawDataDirectory, self.runPath) + ".xml" print XMLFilename try: tree = ElementTree.parse(XMLFilename) except IOError as e: print "Could not get read the run's XML file." return False root = tree.getroot() user = root.find('user') target = user.find('target').text PI = user.find('PI').text ID = user.find('ID').text observers = user.find('Observers').text raStr = user.find('RA').text decStr = user.find('Dec').text ra, dec = ultracamutils.fromSexagesimal(raStr, decStr) print "Target:", target print "PI: %s Observers: %s Programme: %s"%(PI, observers, ID) print "(ra, dec): (%f, %f)"%(ra, dec) self.ra = ra self.dec = dec self.target = target return True
def loadSelf(self, configData): """ Checks to see if a saved file exists that contains info for this run. Loads it into this object. """ filename = ultracamutils.addPaths(configData.SITE_PATH, self.runDate) filename = ultracamutils.addPaths(filename, self.runID) if (self.version!='primary'): filename+= "_" + str(self.version) filename+= "_info.json" print "Trying to load myself from a file.", filename if os.path.exists(filename): JSONfile = open(filename, "r") wholeFileString = JSONfile.read() parsedObject = json.loads(wholeFileString) for key in parsedObject.keys(): print "Setting property:", key, parsedObject[key] setattr(self,key,parsedObject[key]) else: print "Not found... falling back to ultra.json" self.mergeULTRAJSON(configData.RUNINFO)
debug = classes.debugObject(config.DEBUG) debug.toggleTimeLog() if (arg.debuglevel!=None): debug.setLevel(arg.debuglevel); debug.write(arg, level = 2) debug.write("Astropy version %s"%(astropy.__version__), level = 3) runInfo = ultraspecClasses.runInfo(arg.runname) found = runInfo.loadFromJSON(config.RUNINFO) if not found: debug.write("Could not get info for this run from the ultra.json file.", level = 1) xmlRead = runInfo.loadFromXML(config.ULTRASPECRAW) debug.write(runInfo, 2) runFilename = ultracamutils.addPaths(config.ULTRASPECRAW, arg.runname) debug.write("Opening the Ultraspec raw file at: " + runFilename, level = 2) runDate, runID = ultracamutils.separateRunNameAndDate(arg.runname) """ Check that the working folders and the output folders are there """ (runDate, runNumber) = ultracamutils.separateRunNameAndDate(arg.runname) workingFolder = ultracamutils.addPaths(config.WORKINGDIR, runDate) ultracamutils.createFolder(workingFolder) startFrame = arg.startframe if startFrame<1: debug.error("startframe cannot be less than 1")
channels = ['r', 'g', 'b'] channelDescriptions = {'r':'Red', 'g':'Green', 'b':'Blue'} """ Read info about the run to get the starting RA and DEC coordinates """ debug.write("Getting run info from the file:" + config.RUNINFO, level = 2) runInfo = ultracamutils.getRunInfo(config.RUNINFO, arg.runname) debug.write("Run Info:\n----------------------", level = 2) debug.write(runInfo, level = 2) debug.write("----------------------", level = 2) jsonFilename = ultracamutils.addPaths(config.SITE_PATH, arg.runname) + "_objects.json" JSONfile = open(jsonFilename, "r") wholeFileString = JSONfile.read() allObjectsJSON = json.loads(wholeFileString) objects = [] for i in allObjectsJSON: ob = json.loads(i) object = {} object['id'] = ob['id'] colourIDs = ob['colourID'] object['colourID'] = colourIDs
runInfo.loadSelf(config) # runInfo = ultracamutils.getRunInfo(config.RUNINFO, arg.runname) debug.write("Run Info:\n----------------------", level = 2) debug.write(runInfo, level = 2) debug.write("----------------------", level = 2) channels = ['r', 'g', 'b'] channelDescriptions = {'r': "Red", 'g': "Green", 'b': "Blue"} allObjects = {'r': [], 'g':[], 'b':[]} pixelMatch = False # This is set to True if we don't have a WCS solution and need to use pixel locations for matching colours = ['r', 'g', 'b'] """ Load the information about the frames """ jsonFilename = ultracamutils.addPaths(config.SITE_PATH, runName) + "_frameInfo.json" if (arg.version!='primary'): jsonFilename = ultracamutils.addPaths(config.SITE_PATH, runName) + "_" + str(arg.version) + "_frameInfo.json" debug.write("Loading frame info from %s"%(jsonFilename), level = 2) jsonFile = open(jsonFilename, 'r') jsonObjects = json.loads(jsonFile.read()) frameData = [] for j in jsonObjects: object = json.loads(j) frame = ucamObjectClass.frameObject() frame.setFromObject(object) frameData.append(frame)
yll = frameInfo.getWindow(j).yll xsize = frameInfo.getWindow(j).xsize ysize = frameInfo.getWindow(j).ysize fullImage[xll:xll+xsize, yll:yll+ysize] = fullImage[xll:xll+xsize, yll:yll+ysize] + ultracamutils.percentiles(windowImage, 20, 98) fullImage = numpy.fliplr(fullImage) imgData = fullImage imgSize = numpy.shape(imgData) imgLength = imgSize[0] * imgSize[1] testData = numpy.reshape(imgData, imgLength, order="F") img = Image.new("L", imgSize) img.putdata(testData) rgbImage[channel] = img colourImage = Image.merge("RGB", (rgbImage['r'],rgbImage['g'],rgbImage['b'])) imageFilename = ultracamutils.addPaths(config.SITE_PATH,runIdent) + "_colour.png" debug.write("Writing PNG file: " + imageFilename) colourImage.save(imageFilename, "PNG") """ Write the normalised stacked images to individual FITS files. """ for channel in channelNames: runIdent = arg.runname imageFilename = utils.addPaths(config.SITE_PATH,runIdent) + "_" + channel + "_n.fits" stackedImage = stackedImages[channel] fullImage = numpy.zeros((frameInfo.nxmax, frameInfo.nymax)) for j in range(frameInfo.numWindows): windowImage = stackedImage.getWindow(j) xll = frameInfo.getWindow(j).xll yll = frameInfo.getWindow(j).yll xsize = frameInfo.getWindow(j).xsize
debug.write("Getting run info from the file:" + config.RUNINFO, level = 2) runInfo = ultracamutils.getRunInfo(config.RUNINFO, arg.runname) debug.write("Run Info:\n----------------------", level = 2) debug.write(runInfo, level = 2) debug.write("----------------------", level = 2) channels = ['r', 'g', 'b'] channelDescriptions = {'r': "Red", 'g': "Green", 'b': "Blue"} allObjects = {'r': [], 'g':[], 'b':[]} pixelMatch = False # This is set to True if we don't have a WCS solution and need to use pixel locations for matching """ Load the objects from the .json files.... channel by channel (r, g, b) """ for c in channels: jsonFilename = ultracamutils.addPaths(config.SITE_PATH, runName) + "_" + c + ".json" debug.write("Loading the json file for the %s objects from path: %s"%(channelDescriptions[c], jsonFilename), level = 2) objects = ultracamutils.buildObjectsFromJSON(jsonFilename) allObjects[c] = objects debug.write("%d %s objects loaded."%(len(allObjects[c]), channelDescriptions[c]), level = 2) """ Look for and load WCS solutions for each colour (if they exist) """ for c in channels: wcsSolutionFilename = ultracamutils.addPaths(config.WORKINGDIR, runName) + "_" + c + ".wcs" if os.path.exists(wcsSolutionFilename): debug.write("There is a WCS solution for channel: %s"%(channelDescriptions[c]), level = 2) wcsParametersFile = astropy.io.fits.open(wcsSolutionFilename) header = wcsParametersFile[0].header wcs = wcsclasses.wcsSolution()
parser.add_argument('-d', '--debuglevel', type=int, help='Debug level: 3 - verbose, 2 - normal, 1 - warnings only') parser.add_argument('--startframe', default=1, type=int, help='Start frame. \'1\' is the default') parser.add_argument('-n', '--numframes', type=int, help='Number of frames. No parameter means all frames, or from startframe to the end of the run') parser.add_argument('-t', '--sleep', default=0, type=int, help='Sleep time (in seconds) between frames. \'0\' is the default') parser.add_argument('-o', default = 0, type=int, help = "Only plot photometry for the top [o] objects.") arg = parser.parse_args() config = ultracamutils.readConfigFile(arg.configfile) debug = classes.debugObject(config.DEBUG) debug.toggleTimeLog() if (arg.debuglevel!=None): debug.setLevel(arg.debuglevel); runFilename = ultracamutils.addPaths(config.ULTRASPECRAW, arg.runname) debug.write("Opening the Ultraspec raw file at: " + runFilename, level = 3) runDate, runID = ultracamutils.separateRunNameAndDate(arg.runname) """ Check that the working folders and the output folders are there """ (runDate, runNumber) = ultracamutils.separateRunNameAndDate(arg.runname) workingFolder = ultracamutils.addPaths(config.WORKINGDIR, runDate) outputFolder = ultracamutils.addPaths(config.SITE_PATH, runDate) ultracamutils.createFolder(workingFolder) ultracamutils.createFolder(outputFolder) """ Load the apertures from an existing aperture file
runInfo = classes.runObject(runDate, runID) runInfo.version = arg.version runInfo.loadSelf(config) debug.write("Run Info:\n----------------------", level = 2) debug.write(runInfo, level = 2) debug.write("----------------------", level = 2) if arg.preview: matplotlib.pyplot.ion() fig = matplotlib.pyplot.gcf() """ Check that the working folders and the output folders are there """ (runDate, runNumber) = ultracamutils.separateRunNameAndDate(arg.runname) workingFolder = ultracamutils.addPaths(config.WORKINGDIR, runDate) outputFolder = ultracamutils.addPaths(config.SITE_PATH, runDate) ultracamutils.createFolder(workingFolder) ultracamutils.createFolder(outputFolder) startFrame = arg.startframe if startFrame<1: debug.error("startframe cannot be less than 1") sys.exit() rdat = ultracam.Rdata(runFilename, startFrame, server=False) maximumFrames = rdat.ntotal() if startFrame>maximumFrames: debug.error("startframe " + str(startFrame) + ", is beyond the end of the run, which has only " + str(maximumFrames) + " frames in it.") sys.exit()
debug.write("----------------------", level = 2) runDuration = ultracamutils.writeFriendlyTimeMinutes(runInfo.expose) debug.write("Approx run time: %s"%(runDuration), level =2) # Read the template file using the environment object. # This also constructs our Template object. template = templateEnv.get_template(config.RUNTEMPLATE) # Specify any input variables to the template as a dictionary. templateVars = { "runName" : runID, "date" : date, "comments" : runInfo.comment, "object" : runInfo.target, "duration" : runDuration, "version" : runInfo.version } outputFilename = ultracamutils.addPaths(config.SITE_PATH, arg.runname) if arg.version!='primary': outputFilename+="_" + str(arg.version) outputFilename+= ".html" debug.write("Writing HTML file to: %s"%(outputFilename)) outFile = open(outputFilename, "w") outFile.write(template.render(templateVars)) outFile.close()
channelDescriptions = {'r':'Red', 'g':'Green', 'b':'Blue'} """ Read info about the run to get the starting RA and DEC coordinates """ debug.write("Getting run info from the file:" + config.RUNINFO, level = 2) runInfo = ultracamutils.getRunInfo(config.RUNINFO, arg.runname) debug.write("Run Info:\n----------------------", level = 2) debug.write(runInfo, level = 2) debug.write("----------------------", level = 2) solved = [False, False, False] for n,c in enumerate(channels): # Check that there is a solution for each channel solvedFileMarker = ultracamutils.addPaths(config.WORKINGDIR, arg.runname) + '_' + c + ".solved" if os.path.exists(solvedFileMarker): solved[n] = True print solved if solved[0] & solved[1] & solved[2]: print "All solved!" """ Load the fits files of the wcs solutions """ wcsSolutions = {'r': None, 'g': None, 'b': None } for n,c in enumerate(channels): if solved[n]: wcsFilename = ultracamutils.addPaths(config.WORKINGDIR, arg.runname) + '_' + c + ".wcs" wcsJSONFilename = ultracamutils.addPaths(config.SITE_PATH, arg.runname) + '_' + c + "_wcs.json" wcsFile = astropy.io.fits.open(wcsFilename)
runInfo.version = arg.version runInfo.loadSelf(config) debug.write("Run Info:\n----------------------", level = 2) debug.write(runInfo, level = 2) debug.write("----------------------", level = 2) channels = ['r', 'g', 'b'] channelDescriptions = {'r': "Red", 'g': "Green", 'b': "Blue"} allObjects = {'r': [], 'g':[], 'b':[]} """ Load the objects from the .json files.... channel by channel (r, g, b) """ for c in channels: debug.write("Loading the json file for the %s objects."%(channelDescriptions[c]), level = 2) jsonFilename = ultracamutils.addPaths(config.WORKINGDIR, runName) + "_" + c + "_raw.json" if (arg.version!='primary'): jsonFilename = ultracamutils.addPaths(config.WORKINGDIR, runName) + "_" + c + "_" + str(arg.version) + "_raw.json" objects = ultracamutils.buildObjectsFromJSON(jsonFilename) allObjects[c] = objects debug.write("%d %s objects loaded."%(len(allObjects[c]), channelDescriptions[c]), level = 2) """ Do some filtering of the objects """ for c in channels: objects = allObjects[c] beforeCount = len(objects) objects = ultracamutils.filterOutCosmicRays(objects) allObjects[c] = objects
parser.add_argument('-f', '--forcesolve', action='store_true', help='Force a "solve" even if we already have a solution') parser.add_argument('-p', '--preview', action='store_true', help='Show a preview of the check plots.') parser.add_argument('-v', '--version', default='primary', help="Optional version string.") arg = parser.parse_args() config = ultracamutils.readConfigFile(arg.configfile) debug = classes.debugObject(config.DEBUG) debug.toggleTimeLog() if (arg.debuglevel!=None): debug.setLevel(arg.debuglevel); """ First check if a directory is made for the output files in the working director folder. and create one. """ runDate, runNumber = ultracamutils.separateRunNameAndDate(arg.runname) outputDirectory = ultracamutils.addPaths(config.WORKINGDIR, runDate) if not os.path.exists(outputDirectory): debug.write("Creating the directory: " + outputDirectory, level = 2) os.mkdir(outputDirectory) """ Produce a 'preview plot' of the catalogs and the png files """ channels = ['r', 'g', 'b'] channelDescriptions = {'r':'Red', 'g':'Green', 'b':'Blue'} for c in channels: pngFile = ultracamutils.addPaths(config.SITE_PATH, arg.runname) + '_' + c + ".png" xylsFile = ultracamutils.addPaths(config.WORKINGDIR, arg.runname) + '_' + c + ".xyls" checkplotFile = ultracamutils.addPaths(config.WORKINGDIR, arg.runname) + '_' + c + "_preview.png"
def loadFromXML(self, rawDataDirectory): """ This method is called upon if the loadFromJSON method fails to return any data """ XMLFilename = ultracamutils.addPaths(rawDataDirectory, self.runPath) + ".xml" try: tree = ElementTree.parse(XMLFilename) except IOError as e: print "Could not get read the run's XML file at:", XMLFilename return False root = tree.getroot() # Read the window sizes and binning, etc filesave = root.find("filesave_status") instrument = filesave.find("instrument_status") detector = instrument.find("detector_status") powerToDetector = detector.attrib["power"] if powerToDetector == "OFF": self.powerCycle = True return True parameter = instrument.findall("parameter_status") parameters = {} for param in parameter: parameters[param.attrib["name"]] = param.attrib["value"] if parameters.has_key("COM_TAB_START"): self.powerCycle = True return True windows = [] xbin = int(parameters["X_BIN"]) ybin = int(parameters["Y_BIN"]) for number in range(1, 5): try: xStartStr = "X%d_START" % number xStart = int(parameters[xStartStr]) yStartStr = "Y%d_START" % number yStart = int(parameters[yStartStr]) xSizeStr = "X%d_SIZE" % number xSize = int(parameters[xSizeStr]) ySizeStr = "Y%d_SIZE" % number ySize = int(parameters[ySizeStr]) except KeyError: continue if xSize != 0 and ySize != 0: # Add this to the list of windows windowDict = {} windowDict["xll"] = xStart windowDict["nx"] = xSize windowDict["yll"] = yStart windowDict["ny"] = ySize windowDict["xbin"] = xbin windowDict["ybin"] = ybin windows.append(windowDict) self.windowInfo = windows # Get the observation meta-data user = root.find("user") target = user.find("target").text flags = user.find("flags").text PI = user.find("PI").text ID = user.find("ID").text observers = user.find("Observers").text try: raStr = user.find("RA").text decStr = user.find("Dec").text ra, dec = ultracamutils.fromSexagesimal(raStr, decStr) except AttributeError: ra, dec = (0, 0) # print "Target:", target # print "PI: %s Observers: %s Programme: %s"%(PI, observers, ID) # print "(ra, dec): (%f, %f)"%(ra, dec) self.ra = ra self.dec = dec self.target = target self.flags = flags return True
runInfo = ultraspecClasses.runInfo(arg.runname) runInfo.loadFromJSON(config.RUNINFO) debug.write(runInfo, 2) coordinates = (runInfo.ra, runInfo.dec) debug.write(coordinates, 2) debug.write(ultracamutils.toSexagesimal(coordinates), 2) runDate, runID = ultracamutils.separateRunNameAndDate(arg.runname) """ Check that the stacked image is available """ (runDate, runNumber) = ultracamutils.separateRunNameAndDate(arg.runname) workingFolder = ultracamutils.addPaths(config.WORKINGDIR, runDate) stackedImageFilename = workingFolder + '/' + runNumber + ".png" if os.path.isfile(stackedImageFilename): print "Found - ", stackedImageFilename else: print "No stacked image found at:", stackedImageFilename solutionOutputFile = workingFolder + '/' + runNumber + "_wcs_solution.fits" FITSSolutionOutputFile = workingFolder + '/' + runNumber + "_wcs_solved_image.fits" # Run astrometryClient astrometryCommand = ['astrometryClient.py'] astrometryCommand.append("-kpadlqljoevlogqik") astrometryCommand.append("-u" + stackedImageFilename) astrometryCommand.append("--wcs=" + solutionOutputFile) astrometryCommand.append("--wcsfits=" + FITSSolutionOutputFile)
arg = parser.parse_args() config = ultracamutils.readConfigFile(arg.configfile) debug = classes.debugObject(config.DEBUG) debug.toggleTimeLog() if arg.debuglevel != None: debug.setLevel(arg.debuglevel) if arg.numframes != None: numFrames = arg.numframes """ First check if a directory is made for the output files in the ucamsite folder. and create one. """ runDate, runNumber = ultracamutils.separateRunNameAndDate(arg.runname) outputDirectory = ultracamutils.addPaths(config.SITE_PATH, runDate) if not os.path.exists(outputDirectory): debug.write("Creating the directory: " + outputDirectory) os.mkdir(outputDirectory) print arg # Run OBJECTDBCREATOR objectdbcreatorCommand = ["objectdbcreator.py"] objectdbcreatorCommand.append(arg.runname) dString = "-d" + str(arg.debuglevel) objectdbcreatorCommand.append(dString) if arg.numframes != None: objectdbcreatorCommand.append("-n" + str(arg.numframes)) if arg.version != "primary":
parser.add_argument('-r', '--buildruns', action='store_true', help='Build the run output for each run (if no existing output found)') parser.add_argument('-f', '--forcebuildruns', action='store_true', help='Force build of each run (even if existing data is found)') arg = parser.parse_args() config = ultracamutils.readConfigFile(arg.configfile) debug = classes.debugObject(config.DEBUG) debug.toggleTimeLog() if (arg.debuglevel!=None): debug.setLevel(arg.debuglevel); if arg.numframes!=None: numFrames = arg.numframes """ First check if a directory for the output files exists in the ucamsite folder and if not, create one. """ outputDirectory = ultracamutils.addPaths(config.SITE_PATH, arg.date) if not os.path.exists(outputDirectory): debug.write("Creating the directory: " + outputDirectory) os.mkdir(outputDirectory) debug.write("Arguments: " + str(arg)) """ Get a list of all of the .dat files in the folder. This is going to be our list of 'runs' """ path = ultracamutils.addPaths(config.ULTRACAMRAW, arg.date) filer = subprocess.Popen(["ls", str(path)], stdout = subprocess.PIPE) fileList = filer.communicate()[0].split('\n')
innerSkyRadius = float(config.INNER_SKY) outerSkyRadius = float(config.OUTER_SKY) apertureRadius = float(config.APERTURE_RADIUS) polynomialDegree = int(config.POLY_DEGREE) numReferenceApertures = int(config.REF_APERTURES) if arg.apertures!=None: numReferenceApertures = arg.apertures applyShift = True if (arg.noshift): applyShift = False debug = classes.debugObject(config.DEBUG) debug.toggleTimeLog() if (arg.debuglevel!=None): debug.setLevel(arg.debuglevel); debug.write(arg, level = 2) debug.write("Astropy version %s"%(astropy.__version__), level = 3) sourcesFilename = ultracamutils.addPaths(config.WORKINGDIR, arg.runname) + "_sources.csv" debug.write("Loading source list from: " + sourcesFilename, 2) sourceList = ultraspecClasses.sourceList() success = sourceList.loadFromCSV(sourcesFilename) if (not success): debug.error("Unable to open the list of sources. Have you run uspecCreateSourceMap yet?") sys.exit() else: debug.write("Loaded %d sources from the CSV file."%sourceList.getNumSources(), 2) referenceApertures = ultraspecClasses.referenceApertures() referenceApertures.initFromSourceList(sourceList, max=numReferenceApertures) debug.write("Number of reference apertures we are going to use is %d."%len(referenceApertures.sources), 2) margins = 10 runInfo = ultraspecClasses.runInfo(arg.runname)
print "sourceMap mean:", numpy.mean(smoothedSourceMap) print "sourceMap max:", numpy.max(smoothedSourceMap) threshold = frameRange/100. print "threshold:", threshold apertureSources = daofind(smoothedSourceMap, fwhm=4.0, threshold=threshold) # Draw the source map sourceMapImage = matplotlib.pyplot.figure(figsize=(10, 10)) matplotlib.pyplot.title("Source map") matplotlib.pyplot.imshow(smoothedSourceMap, cmap='hot') for s in apertureSources: x, y = s['xcentroid'], s['ycentroid'] matplotlib.pyplot.gca().add_artist(matplotlib.pyplot.Circle((x,y), 10, color='green', fill=False, linewidth=1.0)) matplotlib.pyplot.gca().invert_yaxis() #matplotlib.pyplot.show(block=False) outputFilename = ultracamutils.addPaths(config.WORKINGDIR, arg.runname) + "_sourcemap.png" matplotlib.pyplot.savefig(outputFilename) # Draw the source map with no apertures sourceMapImage = matplotlib.pyplot.figure(figsize=(10, 10)) matplotlib.pyplot.title("Source map") matplotlib.pyplot.imshow(smoothedSourceMap, cmap='hot') matplotlib.pyplot.gca().invert_yaxis() outputFilename = ultracamutils.addPaths(config.WORKINGDIR, arg.runname) + "_sourcemap_clean.png" matplotlib.pyplot.savefig(outputFilename) # Write the XYLS FITS file if (arg.xyls): IDs = [] x_values = []