def replaceSuffix(filename, suffix): """Replace the suffix in the file name. If filename includes an underscore ('_') character, the slice between that point (the rightmost underscore) and the extension will be replaced with the specified suffix. If there is no underscore, the suffix will be inserted before the extension. If filename does not end with one of the recognized extensions, all of the string starting with the rightmost underscore will be replaced by the specified suffix, or the suffix will be appended if there is no underscore in filename. >>> print replaceSuffix ('abc_raw.fits', '_flt') abc_flt.fits >>> print replaceSuffix ('abc.fits ', '_flt') abc_flt.fits >>> print replaceSuffix ('abc_raw.flub', '_flt') abc_flt >>> print replaceSuffix ('abc.flub', '_flt') abc.flub_flt @param filename: a file name @type filename: string @param suffix: the suffix to replace the existing suffix @type suffix: string @return: the input file name with the suffix included @rtype: string """ # retrieve global logger object global log if log==None: # instantiate the logger object and put into the global variable log = gemLog.getGeminiLog() found = False # Extensions is a list of recognized filename extensions. for extn in extensions: if filename.endswith(extn): j = filename.rfind('_') if j >= 0: newname = filename[:j] + suffix + extn else: k = filename.rfind(extn) newname = filename[:k] + suffix + extn found = True break if not found: j = filename.rfind('_') if j >= 0: newname = filename[:j] + suffix else: newname = filename + suffix log.status('replaceSuffix changed the filename from '+filename+' to '+ newname, category='IQ') return newname
def showParameters(self, rc): """ A simple primitive to log the currently set parameters in the reduction context dictionary. """ # Instantiate the log log = gemLog.getGeminiLog(logType=rc["logType"], logLevel=rc["logLevel"]) rcparams = rc.param_names() if (rc["show"]): toshows = rc["show"].split(":") for toshow in toshows: if toshow in rcparams: log.stdinfo("%s = %s" % (toshow, repr(rc[toshow]))) else: log.stdinfo("%s is not set" % (toshow)) else: for param in rcparams: log.stdinfo("%s = %s" % (param, repr(rc[param]))) # print "all",repr(rc.parm_dict_by_tag("showParams", "all")) # print "iraf",repr(rc.parm_dict_by_tag("showParams", "iraf")) # print "test",repr(rc.parm_dict_by_tag("showParams", "test")) # print "sdf",repr(rc.parm_dict_by_tag("showParams", "sdf")) # print repr(dir(rc.ro.primDict[rc.ro.curPrimType][0])) yield rc
def printlog(text, logfile=None, verbose=True): """Append text to the log file. @param text: text string to log @type text: string @param logfile: name of log file, or None @type logfile: string @param verbose: if True, then also print to standard output @type verbose: boolean """ # retrieve global logger object global log if log==None: # instantiate the logger object and put into the global variable log = gemLog.getGeminiLog() if logfile == 'STDOUT': logfile = None verbose = True if (text[0:5] == 'ERROR') or (text[0:7] == 'WARNING'): verbose = True if logfile is not None: fd = open(logfile, mode='a') fd.write(text + '\n') fd.close() if verbose: log.fullinfo(text, category='IQ')
def getList(self, rc): """ This primitive will check the files in the stack lists are on disk, and then update the inputs list to include all members of the stack for stacking. :param purpose: :type purpose: string """ # Instantiate the log log = gemLog.getGeminiLog(logType=rc["logType"], logLevel=rc["logLevel"]) # Get purpose of list sidset = set() purpose=rc["purpose"] if purpose is None: purpose = "" # Get ID for all inputs for inp in rc.inputs: sidset.add(purpose+IDFactory.generate_stackable_id(inp.ad)) # Import inputs from all lists for sid in sidset: stacklist = rc.get_list(sid) #.filelist log.stdinfo("List for stack id %s(...):" % sid[0:35]) for f in stacklist: rc.report_output(f, stream=rc["to_stream"]) log.stdinfo(" %s" % os.path.basename(f)) yield rc
def __init__(self,ad, addBPM=True, sigma=0.0, threshold=2.5, fwhm=5.5, logfile='fluxcal.log'): """ Run all the functions to calculate ZP with the default parameters. If you want to change some of then, you could run the individual functions. - DetectSources(ad) - AddReferenceCatalogs(ad) - CorrelateWithReferenceCatalogs (ad) - CalculateZeroPoint(ad) """ basename = os.path.basename(ad.filename) adout = deepcopy(ad) adout.filename = 'fc_'+basename self.adout = adout self.addBPM=addBPM self.sigma=sigma self.threshold=threshold self.fwhm=fwhm self.logfile = logfile self.log=gemLog.getGeminiLog(logName=logfile,logLevel=6) log = self.log log.info( "\n ==================== FLUXCAL for "+ad.filename+" ====================")
def stackFlats(self, rc): """ This primitive will combine the input flats with rejection parameters set appropriately for GMOS imaging twilight flats. """ # Instantiate the log log = gemLog.getGeminiLog(logType=rc["logType"], logLevel=rc["logLevel"]) # Log the standard "starting primitive" debug message log.debug(gt.log_message("primitive", "stackFlats", "starting")) # Check for at least 2 input frames adinput = rc.get_inputs_as_astrodata() nframes = len(adinput) if nframes<2: log.stdinfo("At least two frames must be provided to " + "stackFlats") # Report input to RC without change adoutput_list = adinput rc.report_output(adoutput_list) else: # Define rejection parameters based on number of input frames, # to be used with minmax rejection. Note: if reject_method # parameter is overridden, these parameters will just be # ignored reject_method = rc["reject_method"] nlow = 0 nhigh = 0 if nframes <= 2: reject_method = None elif nframes <= 5: nlow = 1 nhigh = 1 elif nframes <= 10: nlow = 2 nhigh = 2 else: nlow = 2 nhigh = 3 log.fullinfo("For %d input frames, using reject_method=%s, "\ "nlow=%d, nhigh=%d" % (nframes, reject_method, nlow, nhigh)) # Run the scaleByIntensity primitive to scale flats to the # same level rc.run("scaleByIntensity") # Run the stackFrames primitive with the defined parameters prim_str = "stackFrames(suffix=%s,operation=%s,mask=%s," \ "reject_method=%s,nlow=%s,nhigh=%s)" % \ (rc["suffix"],rc["operation"],rc["mask"], reject_method,nlow,nhigh) rc.run(prim_str) yield rc
def log(self, rc): log = gemLog.getGeminiLog(logType=rc["logType"], logLevel=rc["logLevel"]) msg = rc["msg"] if msg == None: msg = "..." log.fullinfo(msg) yield rc
def __init__(self): ''' Goes into ConfigSpace and gets all the file URIs to create a XML index. ''' # raise FatalDeprecation("CalibrationDefinitionLibrary NOT IN USE!") self.xmlIndex = {} #self.update_xml_index() # instantiate the logger object and put into the global variable self.log = gemLog.getGeminiLog()
def _header_align(reference, adinput): """ This function uses the POFFSET and QOFFSET header keywords to get reference points to use in correcting an input WCS to a reference WCS. Positive POFFSET is assumed to mean higher x value, and positive QOFFSET is assumed to mean higher y value. This function only allows for relative shifts between the images; rotations and scales will not be handled properly :param reference: reference image to register other images to. Must have only one SCI extension. :type reference: AstroData object :param adinput: images to register to reference image. Must have only one SCI extension. :type adinput: AstroData objects, either a single instance or a list """ log = gemLog.getGeminiLog() if not isinstance(adinput, list): adinput = [adinput] # get starting offsets from reference image (first one given) pixscale = float(reference.pixel_scale()) ref_xoff = reference.phu_get_key_value("POFFSET") / pixscale ref_yoff = reference.phu_get_key_value("QOFFSET") / pixscale # reference position is the center of the reference frame data_shape = reference["SCI"].data.shape ref_coord = [data_shape[1] / 2, data_shape[0] / 2] log.fullinfo("Pixel scale: %.4f" % pixscale) log.fullinfo("Reference offsets: %.4f %.4f" % (ref_xoff, ref_yoff)) log.fullinfo("Reference coordinates: %.1f %.1f" % (ref_coord[0], ref_coord[1])) objIns = [] for i in range(len(adinput)): ad = adinput[i] pixscale = float(ad.pixel_scale()) xoff = ad.phu_get_key_value("POFFSET") / pixscale yoff = ad.phu_get_key_value("QOFFSET") / pixscale img_x = xoff - ref_xoff + ref_coord[0] img_y = yoff - ref_yoff + ref_coord[1] log.fullinfo("For image " + ad.filename + ":") log.fullinfo(" Image offsets: %.4f %.4f" % (xoff, yoff)) log.fullinfo(" Coordinates to transform: %.4f %.4f" % (img_x, img_y)) objIns.append(np.array([[ref_coord], [[img_x, img_y]]])) adoutput_list = _align_wcs(reference, adinput, objIns, rotate=False, scale=False) return adoutput_list
def subtract(self,rc): # This is a bare-bones primitive interface to the ad sub # function from the arith module. The value, dictionary, # or AD instance to be subtracted from the input is stored in # rc["operand"] # Instantiate the log log = gemLog.getGeminiLog(logType=rc["logType"], logLevel=rc["logLevel"]) # Log the standard "starting primitive" debug message log.debug(gt.log_message("primitive", "subtract", "starting")) # Define the keyword to be used for the time stamp for this primitive timestamp_key = self.timestamp_keys["subtract"] # Initialize the list of output AstroData objects adoutput_list = [] # Get data to be subtracted from the RC operand = rc["operand"] if operand is None: log.stdinfo("No operand to subtract; no changes will be "\ "made to input") elif type(operand)==AstroData: log.stdinfo("Subtracting %s from input" % (operand.filename)) else: log.stdinfo("Subtracting %s from input" % (repr(operand))) # Loop over each input AstroData object in the input list for ad in rc.get_inputs_as_astrodata(): if operand is not None: # Subtract operand from data ad.sub(operand) # Add the appropriate time stamps to the PHU gt.mark_history(adinput=ad, keyword=timestamp_key) # Change the filename ad.filename = gt.filename_updater( adinput=ad, suffix=rc["suffix"], strip=True) # Append the output AstroData object to the list # of output AstroData objects adoutput_list.append(ad) # Report the list of output AstroData objects to the reduction # context rc.report_output(adoutput_list) yield rc
def checkParam(parameter, paramType, defaultValue, compareValue=0.0): """ This is a very basic and general parameter checking function. Basically, pass a parameter, expected type and a default value. If it is the same type then: 1) If it is a list, return it. 2) If it is a string, check if it is '', if it is then return default value. 3) If it is a number, check that it is greater than 'compareValue', if it is not then return defaultValue. Example usage: -checkParam( mode, type(''), 'constant' ) -checkParam( fwhm, type(0.0), 5.5, compareValue=1.5 ) @param parameter: Parameter for testing. @type parameter: Any @param paramType: What the expected type of the parameter should be. @type paramType: type( Any ) @param defaultValue: What the default value will be if failures occur. Hopefully, the type matches paramType. @type defaultValue: type( Any ) @param compareValue: Value to compare against in the case the parameter is a float or int. This will check whether the parameter is greater than the compareValue. @type compareValue: float or int @return: Parameter if it is the correct type and compare, default if it fails comparison, or None if errors. @rtype: paramType or None """ global log if log==None: log = gemLog.getGeminiLog() if type(parameter) == paramType: if (paramType == type(0)) or (paramType == type(0.0)): if parameter > compareValue: return parameter elif paramType == str: if parameter != '': return parameter else: return parameter else: log.warning('Type of parameter, '+str(type(parameter))+ ' is not the correct type:'+str(paramType)) #$$$ There needs to be an exception class to properly handle this raise raise 'Incorrect Parameter Type', type(parameter) return defaultValue
def addToList(self, rc): """ This primitive will update the lists of files to be stacked that have the same observationID with the current inputs. This file is cached between calls to reduce, thus allowing for one-file-at-a-time processing. :param purpose: :type purpose: string """ # Instantiate the log log = gemLog.getGeminiLog(logType=rc["logType"], logLevel=rc["logLevel"]) from astrodata import memorytrack as mt mt.memtrack("addToList [inside]", "1") # Perform an update to the stack cache file (or create it) using the # current inputs in the reduction context purpose = rc["purpose"] if purpose is None: purpose = "" if purpose == "": suffix = "_list" else: suffix = "_%s" % purpose mt.memtrack("addToList [inside]", "2") # Update file names and write the files to disk to ensure the right # version is stored before adding it to the list. adoutput = [] for ad in rc.get_inputs_as_astrodata(): mt.memtrack("addToList [inside]", "3") ad.filename = gt.filename_updater(adinput=ad, suffix=suffix, strip=True) mt.memtrack("addToList [inside]", "3.1") log.stdinfo("Writing %s to disk" % ad.filename) mt.memtrack("addToList [inside]", "3.2") ad.write(clobber=True) mt.memtrack("addToList [inside]", "3.3") adoutput.append(ad) mt.memtrack("addtoList [inside]", "3.4") rc.report_output(adoutput) # Call the rq_stack_update method rc.rq_stack_update(purpose=purpose) mt.memtrack("addToList [inside]", "4") yield rc
def sleep(self, rc): # Instantiate the log log = gemLog.getGeminiLog(logType=rc["logType"], logLevel=rc["logLevel"]) if rc["duration"]: dur = float(rc["duration"]) else: dur = 5. log.status("Sleeping for %f seconds" % dur) time.sleep(dur) yield rc
def addObjectMaskToDQ(self, rc): """ This primitive combines the object mask in a OBJMASK extension into the DQ plane """ # Instantiate the log log = gemLog.getGeminiLog(logType=rc["logType"], logLevel=rc["logLevel"]) # Log the standard "starting primitive" debug message log.debug(gt.log_message("primitive", "addObjectMaskToDQ", "starting")) # Define the keyword to be used for the time stamp for this primitive timestamp_key = self.timestamp_keys["addObjectMaskToDQ"] # Initialize the list of output AstroData objects adoutput_list = [] # Loop over each input AstroData object in the input list for ad in rc.get_inputs_as_astrodata(): for sciext in ad["SCI"]: extver = sciext.extver() dqext = ad["DQ",extver] mask = ad["OBJMASK",extver] if mask is None: log.warning("No object mask present for "\ "%s[SCI,%d]; "\ "cannot apply object mask" % (ad.filename,extver)) else: if dqext is not None: ad["DQ",extver].data = dqext.data | mask.data else: dqext = deepcopy(mask) dqext.rename_ext("DQ",extver) ad.append(dqext) # Change the filename ad.filename = gt.filename_updater(adinput=ad, suffix=rc["suffix"], strip=True) # Append the output AstroData object to the list # of output AstroData objects adoutput_list.append(ad) # Report the list of output AstroData objects to the reduction # context rc.report_output(adoutput_list) yield rc
def alignToReferenceImage(self, rc): """ This primitive applies the transformation encoded in the input images WCSs to align them with a reference image, in reference image pixel coordinates. The reference image is taken to be the first image in the input list. By default, the transformation into the reference frame is done via interpolation. The interpolator parameter specifies the interpolation method. The options are nearest-neighbor, bilinear, or nth-order spline, with n = 2, 3, 4, or 5. If interpolator is None, no interpolation is done: the input image is shifted by an integer number of pixels, such that the center of the frame matches up as well as possible. The variance plane, if present, is transformed in the same way as the science data. The data quality plane, if present, must be handled a little differently. DQ flags are set bit-wise, such that each pixel is the sum of any of the following values: 0=good pixel, 1=bad pixel (from bad pixel mask), 2=nonlinear, 4=saturated, etc. To transform the DQ plane without losing flag information, it is unpacked into separate masks, each of which is transformed in the same way as the science data. A pixel is flagged if it had greater than 1% influence from a bad pixel. The transformed masks are then added back together to generate the transformed DQ plane. In order not to lose any data, the output image arrays (including the reference image's) are expanded with respect to the input image arrays. The science and variance data arrays are padded with zeros; the DQ plane is padded with ones. The WCS keywords in the headers of the output images are updated to reflect the transformation. :param interpolator: type of interpolation desired :type interpolator: string, possible values are None, 'nearest', 'linear', 'spline2', 'spline3', 'spline4', or 'spline5' :param suffix: string to add on the end of the input filenames to generate output filenames :type suffix: string """ log = gemLog.getGeminiLog(logType=rc['logType'],logLevel=rc['logLevel']) log.debug(gt.log_message("primitive", "alignToReferenceImage", "starting")) adoutput_list = rf.align_to_reference_image( adinput=rc.get_inputs(style='AD'), interpolator=rc['interpolator']) rc.report_output(adoutput_list) yield rc
def contextReport(self, rc): # Instantiate the log log = gemLog.getGeminiLog(logType=rc["logType"], logLevel=rc["logLevel"]) log.fullinfo(rc.report(report_history=rc["report_history"], internal_dict=rc["internal_dict"], context_vars=rc["context_vars"], report_inputs=rc["report_inputs"], report_parameters=rc["report_parameters"], showall=rc["showall"])) yield rc
def time(self, rc): # Instantiate the log log = gemLog.getGeminiLog(logType=rc["logType"], logLevel=rc["logLevel"]) cur = datetime.now() elap = "" if rc["lastTime"] and not rc["start"]: td = cur - rc["lastTime"] elap = " (%s)" % str(td) log.stdinfo("Time: %s %s" % (str(datetime.now()), elap)) rc.update({"lastTime":cur}) yield rc
def __init__(self, ad, logLevel=6, firstPass=50, delta=7, logfile=""): if not logfile: logfile = "selectreferences.log" basename = os.path.basename(ad.filename) outad = deepcopy(ad) outad.filename = "corr_" + basename self.outad = outad self.log = gemLog.getGeminiLog(logName=logfile, logLevel=logLevel) log = self.log log.defaultCategory(level="ALL", category="corrObjRef") log.info("\n ****** CORRELATE OBJECT AND REFERENCE POSITIONS for: %s. *********" % ad.filename) self.firstpass = firstPass self.delta = delta
def __init__(self, ad, catalogName=None, logLevel=6, logfile=''): self.ad = ad basename = os.path.basename(ad.filename) self.outad = deepcopy(ad) self.outad.filename = 'ref_'+basename if not logfile: logfile = 'selectreferences.log' self.log = gemLog.getGeminiLog(logName=logfile, logLevel=logLevel) log = self.log log.defaultCategory(level='ALL', category='selectReferences') log.info( "\n ****** SELECT REFERENCES for: %s *******"%ad.filename)
def __init__(self, ad, logLevel=6, logfile='', zplogfile='ZPcorr.log', extinction=None): if not logfile: logfile = 'calculateZeropoint.log' self.log = gemLog.getGeminiLog(logName=logfile, logLevel=logLevel) log = self.log log.defaultCategory(level='ALL',category='calczp') basename = os.path.basename(ad.filename) outad = deepcopy(ad) outad.filename = 'zpcalc_'+basename self.outad = outad self.zplogfile = zplogfile self.extinction = extinction log.info( "\n ****** CALCULATE ZERO POINT CORRECTION for: %s. *********"%ad.filename)
def showOutputs(self, rc): log = gemLog.getGeminiLog(logType=rc["logType"], logLevel=rc["logLevel"]) streams = rc.outputs.keys() streams.sort() streams.remove("main") streams.insert(0,"main") tstream = rc["streams"] for stream in streams: if tstream == None or stream in tstream: log.stdinfo("stream: "+stream) if len(rc.outputs[stream])>0: for adr in rc.outputs[stream]: log.stdinfo(str(adr)) else: log.stdinfo(" empty") yield rc
def appendSuffix(filename, suffix): """Append a suffix to the root of the file name. If filename does not end with one of the recognized extensions, the suffix will just be appended to filename. >>> print appendSuffix ('abc.fits', '_flt') abc_flt.fits >>> print appendSuffix ('abc', '_flt') abc_flt >>> print appendSuffix ('abc.xyz', '_flt') abc.xyz_flt @param filename: a file name @type filename: string @param suffix: the suffix (e.g. '_flt') to append @type suffix: string @return: the input file name with the suffix included @rtype: string """ # retrieve global logger object global log if log==None: # instantiate the logger object and put into the global variable log = gemLog.getGeminiLog() found = False # Extensions is a list of recognized filename extensions. for extn in extensions: if filename.endswith(extn): k = filename.rfind(extn) newname = filename[:k] + suffix + extn found = True break if not found: newname = filename + suffix log.status('appendSuffix changed the filename from '+filename+' to '+ newname, category='IQ') return newname
def urlfetch(url, store = None, clobber = False): log = gemLog.getGeminiLog() purl = urlparse.urlparse(url) host = "fits" #"hbffits3.hi.gemini.edu" #@@CONFIG: FITSSTORE RETRIEVAL HOST npurl = urlparse.ParseResult(purl.scheme, purl.hostname, purl.path, purl.params, purl.query, purl.fragment) url = npurl.geturl() #log.debug("nu20: adutils.urlfetch asked to get ", url) #print("nu20: adutils.urlfetch asked to get ", url) try: res = urllib2.urlopen(url) except urllib2.HTTPError, error: print "ERROR" print error.read() raise
def showInputs(self, rc): """ A simple primitive to show the filenames for the current inputs to this primitive. """ # Instantiate the log log = gemLog.getGeminiLog(logType=rc["logType"], logLevel=rc["logLevel"]) log.stdinfo("Inputs:") #print "pG977:", id(rc), repr(rc.inputs) #if "stream" in rc: # stream = rc["stream"] #else: # stream = "main" log.stdinfo("stream: %s" % (rc._current_stream)) for inf in rc.inputs: log.stdinfo(" %s" % inf.filename) yield rc
def forwardInput(self, rc): log = gemLog.getGeminiLog(logType=rc["logType"], logLevel=rc["logLevel"]) if rc["to_stream"] != None: stream = rc["to_stream"] else: stream = "main" prefix = rc["prefix"]; do_deepcopy = rc["deepcopy"] if do_deepcopy is None: do_deepcopy = True if "by_token" in rc: bt = rc["by_token"] for ar in rc.inputs: if bt in ar.filename: rc.report_output(ar.ad, stream = stream) #print "pG110:",repr(rc.outputs) else: inputs = rc.get_inputs_as_astrodata() inputs_copy = [] for ad in inputs: if do_deepcopy: from copy import deepcopy ad_copy = deepcopy(ad) else: ad_copy = ad if prefix: ad_copy.filename = os.path.join( prefix+os.path.basename(ad.filename)) else: ad_copy.filename = ad.filename inputs_copy.append(ad_copy) log.fullinfo("Reporting Output: "+ \ ", ".join([ ad.filename for ad in inputs_copy])) rc.report_output(inputs_copy, stream = stream, ) yield rc
def listDir(self, rc): # Instantiate the log log = gemLog.getGeminiLog(logType=rc["logType"], logLevel=rc["logLevel"]) if rc["dir"] == None: thedir = "." else: thedir = rc["dir"] log.status("Listing for: "+ thedir) files = os.listdir(thedir) sfiles = [] for f in files: if f[-5:].lower() == ".fits": sfiles.append(f) sfiles.sort() if len(sfiles) == 0: log.status("No FITS files") else: log.status("\n\t".join(sfiles)) yield rc
def __init__(self, ad, sigma=0.0, threshold=2.5, fwhm=5.5, logLevel=6, logfile=''): if 'CAL' in ad.types: raise RuntimeError, " **** AD type 'CAL' not supported by DetectSources****" basename = os.path.basename(ad.filename) self.sigma = sigma self.threshold = threshold self.fwhm = fwhm if not logfile: logfile = 'detectSources.log' self.log = gemLog.getGeminiLog() log = self.log log.defaultCategory(level='ALL',category='DetecSources') outad = deepcopy(ad) outad.filename = 'ds_'+basename self.outad = outad log.info( "\n ****** DETECTING SOURCES for: %s *************"%ad.filename)
def addInputs(self, rc): # Instantiate the log log = gemLog.getGeminiLog(logType=rc["logType"], logLevel=rc["logLevel"]) import glob as gl if rc["files"] == None: glob = "./*.fits" else: glob = rc["files"] log.status("Listing for: "+ glob) files = gl.glob(glob) files.sort() if len(files) == 0: log.status("No files") else: log.status("\t"+"\n\t".join(files)) yield rc add = True # rc["inputs"] if add: rc.add_input(files) yield rc
def verifyOutlist( inlist, outlist ): """ Verifies that for every file in the inList, there is a corresponding output file. @param inList: A list of input file paths. @type inList: list @param outlist: A list of output file paths. @type outlist: list """ global log if log==None: log = gemLog.getGeminiLog() try: if outlist == []: # Will append unique filenames if none exist in outlist for i in range(len(inlist)): line = 'output' + str(i+1)+ '.fits' outlist.append(line) return outlist elif len(outlist) < len(inlist): # Will append unique filenames if not enough in outlist l = len(inlist) - len(outlist) for i in range(l): line = 'output' + str(l+i)+ '.fits' outlist.append(line) return outlist else: return outlist except: log.error('An error occured while trying to verify'+ ' the outputs existance for inlist '+repr(inlist)) return None
def showList(self, rc): """ This primitive will log the list of files in the stacking list matching the current inputs and 'purpose' value. :param purpose: :type purpose: string """ # Instantiate the log log = gemLog.getGeminiLog(logType=rc["logType"], logLevel=rc["logLevel"]) sidset = set() purpose = rc["purpose"] if purpose is None: purpose = "" # print "pG710" if purpose == "all": allsids = rc.get_stack_ids() # print "pG713:", repr(allsids) for sid in allsids: sidset.add(sid) else: for inp in rc.inputs: sidset.add(purpose+IDFactory.generate_stackable_id(inp.ad)) for sid in sidset: stacklist = rc.get_list(sid) #.filelist log.status("List for stack id=%s" % sid) if len(stacklist) > 0: for f in stacklist: log.status(" %s" % os.path.basename(f)) else: log.status("No datasets in list") yield rc