def readConfig(self, configName, args): _cfgPath = os.path.join( util.getEnvPath("THIS_DIR"), "cfg", configName + ".ini") if not os.path.exists(_cfgPath): raise ValueError("Config with name %s not found in %r" % ( configName, _cfgPath)) return util.readConfigFile(_cfgPath, args)
def __init__(self, allImageObjects, destDirectory): self.allImageObjects = allImageObjects self.destDirectory = destDirectory config = readConfigFile() general = config["GENERAL"] self.allowedAspectDiff = general.getfloat("ALLOWED_ASPECT_DIFF") self.selectedImages = [] self.combineId = None
def __init__(self, args): self.args = args config = readConfigFile() general = config["GENERAL"] self.nsfw_allowed = general.getboolean("NSFW_ALLOWED") self.subreddits = general["SUBREDDITS"] self.incorrect_aspect = [] self.correct_aspect = [] self.apiObject = praw.Reddit(client_id=os.environ["CLIENT_ID"], client_secret=os.environ["SECRET"], user_agent=os.environ["USER_AGENT"])
#util.raiseNotDefined() ############################################ #TESTING ########################################### # run with '-h' for 'usage' import argparse parser = argparse.ArgumentParser() parser.add_argument("-p", choices=['NQueens', 'sudoku'], default='NQueens', help="type of problem") parser.add_argument("-n", type=int, default=4, help="size of problem") parser.add_argument("-t", type=int, default=10000, help="number of iterations") parser.add_argument("-i", default='test', help="file containing the initial input configuration for sudoku") args = parser.parse_args() if args.p == "NQueens": prob = [NQueensProblem(args.n)] # no solution for < 4 print 'NQueens: n =', args.n elif args.p == "sudoku": predefValues = util.readConfigFile(args.i) print len(predefValues), 'sudoku(s)' prob = [sudoku(N=args.n, predefinedValues=val) for val in predefValues] print 'sudoku: n =', args.n #state = prob.getStartState() for p in prob: print solveAgent.minConflict(p, args.t)
def run(args, logger, plotter): # Read config file for simulation parameters. # cfg = readConfigFile(logger, args.i) xtra_header_keys = {} # dict of extra keys and values for FITS header st = time.time() logger.debug(" Beginning simulation") # Build Zemax spectrograph model # zspec = zSpectrograph(cfg['SIM_COLLIMATOR_ZMX_FILE'], cfg['SIM_CAMERA_ZMX_FILE']) # Build the instrument using the instrument_builder package. # # Although we construct the components from the configuration files, we # override some attributes to both ensure consistency and accept some # limitations of the current version. # # -> Assign camera/collimator EFFL to directly match the Zemax models. # -> Set the preoptics WFNO such that a spatial resolution element spans # [IFU_SLICES_PER_RESEL] slices. # -> Set the preoptics anamorphic magnification to 1 # instrument = SWIFT_like(cfg['PREOPTICS_CFG_NAME'], cfg['IFU_CFG_NAME'], cfg['SPECTROGRAPH_CFG_NAME'], cfg['DETECTOR_CFG_NAME'], config_dir=cfg['SIM_INSTRUMENT_CONFIGS_DIR_PATH'], logger=logger) zspec_attr = zspec.getSystemAttr(cfg['PUPIL_REFERENCE_WAVELENGTH']) instrument.spectrograph.cfg['camera_EFFL'] = zspec_attr['camera_EFFL'] instrument.spectrograph.cfg['collimator_EFFL'] = zspec_attr['collimator_EFFL'] instrument.preoptics.cfg['magnification_across_slices'] = \ instrument.preoptics.cfg['magnification_along_slices'] # following assumes diffraction-limited reimaging performance instrument.preoptics.cfg['WFNO'] = cfg['IFU_SLICES_PER_RESEL'] * \ instrument.ifu.cfg['slice_width_physical'] / \ cfg['PUPIL_REFERENCE_WAVELENGTH'] instrument.assemble() # Get wavelength range as decimal. # waves = np.arange(cfg['SIM_WAVELENGTH_START'], Decimal(cfg['SIM_WAVELENGTH_END'] + \ cfg['SIM_WAVELENGTH_INTERVAL']), Decimal(cfg['SIM_WAVELENGTH_INTERVAL']), dtype=Decimal) # Determine the smallest pupil size (D_pupil) that corresponds to Nyquist # sampling at the detector given a camera focal length, f_cam, and some # reference wavelength, lambda. # # As we want to be AT LEAST Nyquist sampling at all wavelengths, we really # want to ensure that the system is Nyquist sampling at the shortest # wavelength. Doing so means that longer wavelengths will be oversampled. # The wavelength at which the pupil is constructed for can be adjusted in # the configuration file as [pupil.reference_wavelength]. # # We get [D_pupil], the pupil size for a single slice, by equating the spatial # size of 2 detector pixels (D_p) with the spatial size of one resolution # element, i.e. # # 2 x D_p = lambda*f_cam / D_pupil # pupil_physical_diameter = (cfg['PUPIL_REFERENCE_WAVELENGTH'] * \ instrument.camera_EFFL)/(2*instrument.detector_pixel_pitch) pupil_physical_radius = (pupil_physical_diameter/2) xtra_header_keys['EPD'] = (pupil_physical_diameter*1e3, "physical entrance pupil diameter (mm)") # Now find parameters with which we will rescale the image. # # As the angular size (and thus spatial size) of the resolution element is # dependent on lambda, we need to define a reference system through which we # can resample each wavelength. The wavelength this is done for is defined # in the configuration file as [pupil.resample_to_wavelength]. # # To do this, we first stablish the spatial pixel scale (m/px) for the # reference wavelength. The latter is then used to determine the scale factor # which needs to be applied to the wavelength currently being considered. To # avoid extrapolation, this reference wavelength should be blueward of the # smallest wavelength to be considered. # # All the information required to rescale is held in the [resampling_im] # instance. # logger.debug(" Ascertaining parameters to resample to " + \ str(cfg['PUPIL_RESAMPLE_TO_WAVELENGTH']*Decimal('1e9')) + "nm") resampling_pupil = pupil_circular(logger, cfg['PUPIL_SAMPLING'], cfg['PUPIL_GAMMA'], pupil_physical_radius, verbose=True) preoptics_reimager = reimager(instrument.preoptics_WFNO) resampling_im = resampling_pupil.toConjugateImage( cfg['PUPIL_RESAMPLE_TO_WAVELENGTH'], preoptics_reimager, verbose=True) # Initialise datacube and run simulations for each wavelength. # # The result from a simulation is an image instance which we can append # to the datacube. # dcube = cube(logger) s = sim(logger, plotter, resampling_im, resampling_pupil, len(waves), preoptics_reimager, zspec, cfg, instrument) for idx, w in enumerate(waves): logger.info(" !!! Processing for a wavelength of " + str(float(w)*1e9) + "nm...") this_st = time.time() dcube.append(s.run(w, verbose=args.v)) this_duration = time.time()-this_st if idx>0: logger.debug(" Last wavelength iteration took " + str(int(this_duration)) + "s, expected time to completion is " + str(int(((len(waves)-(idx+1))*this_duration))) + "s.") # Make and view output. # # Note that pyds9 interaction only works with systems with the XPA protocol # installed, and i've yet to find a way to get this working on a Windows box. # dcube.write(args, cfg, xtra_header_keys) if args.d: import pyds9 d = pyds9.DS9() d.set("file " + args.f) d.set('cmap heat') d.set('scale log') d.set('zoom 4') duration = time.time()-st logger.debug(" This simulation completed in " + str(sf(duration, 4)) + "s.")