def __init__(self, root, registry=None, compress=True): if registry is None: registry = os.path.join(root, "registry.sqlite3") self.mapper = LsstSimMapper(root=root, registry=registry) bf = dafPersist.ButlerFactory(mapper=self.mapper) self.butler = bf.create() self.expFile = CsvFileWriter("Raw_Amp_Exposure.csv", compress=compress) self.mdFile = CsvFileWriter("Raw_Amp_Exposure_Metadata.csv", compress=compress) self.rToSFile = CsvFileWriter("Raw_Amp_To_Science_Ccd_Exposure.csv", compress=compress) self.polyFile = open("Raw_Amp_Exposure_Poly.tsv", "wb")
def __init__(self, origin, rotation_angle): # this line prevents the camera mapper from printing harmless warnings to # stdout (which, as of 5 November 2015, happens every time you instantiate # the camera below) pexLog.Log.getDefaultLog().setThresholdFor("CameraMapper", pexLog.Log.FATAL) # Make the camera if we haven't yet. if LsstCamera._camera is None: LsstCamera._camera = LsstSimMapper().camera # _pixel_system_dict will be a dictionary of chip pixel coordinate systems # keyed to chip names self._pixel_system_dict = {} # _tan_pixel_system_dict will be a dictionary of chip tan pixel coordinate # systems self._tan_pixel_system_dict = {} # _pupil_system_dict will be a dictionary of chip pupil coordinate systems # keyed to chip names self._pupil_system_dict = {} self._pointing = origin self._rotation_angle = rotation_angle self._cos_rot = np.cos(self._rotation_angle / galsim.radians) self._sin_rot = np.sin(self._rotation_angle / galsim.radians) self._cos_dec = np.cos(self._pointing.dec / galsim.radians) self._sin_dec = np.sin(self._pointing.dec / galsim.radians)
def generateInputList(self): with open("ccdlist", "w") as inputFile: print >> inputFile, ">intids visit" import lsst.daf.persistence as dafPersist from lsst.obs.lsstSim import LsstSimMapper butler = dafPersist.ButlerFactory(mapper=LsstSimMapper( root=self.inputDirectory)).create() numInputs = 0 for sensorRef in butler.subset("raw", "sensor"): numChannels = 0 for channelRef in sensorRef.subItems(): if butler.datasetExists("raw", channelRef.dataId): numChannels += 1 id = "visit=%(visit)d raft=%(raft)s sensor=%(sensor)s" % \ sensorRef.dataId if numChannels == 32: print >> inputFile, "raw", id numInputs += 1 if numInputs >= self.options.ccdCount: break else: print >>sys.stderr, "Warning:", id, \ "has %d channel files (should be 32);" % \ (numChannels,), "not processing" for i in xrange(self.nPipelines): print >> inputFile, "raw visit=0 raft=0 sensor=0"
def testAddStarByChipPos(self): # Instantiate the skySim object skySim = SkySim() # Set the ObservationMetaData RA = 0 Dec = 0 cameraRotation = 0 cameraMJD = 59580.0 obs = ObservationMetaData(pointingRA=RA, pointingDec=Dec, rotSkyPos=cameraRotation, mjd=cameraMJD) # Set the camera camera = LsstSimMapper().camera # Add the star sensorName = "R22_S11" starId = 0 starMag = 17 xInpixelInCam = 2000 yInPixelInCam = 2036 skySim.addStarByChipPos(camera, obs, sensorName, starId, xInpixelInCam, yInPixelInCam, starMag, self.testDataDir) # Test the result self.assertAlmostEqual(skySim.ra[0], 359.99971038) self.assertAlmostEqual(skySim.decl[0], 0.0001889) # Test to get the sensor box cornerInRaDecList = skySim.getCornOfChipOnSky(camera, obs, sensorName, self.testDataDir) self.assertEqual(len(cornerInRaDecList), 4)
def __init__(self): """Initialize the commissioning camera class.""" # The comcam's configuration here is approximated by taking the central # raft of lsst camera. super(ComCam, self).__init__(LsstSimMapper().camera) self._initDetectors(DetectorType.SCIENCE) # Remove the ccd data that are not belong to ComCam detectorList = [ "R:2,2 S:0,2", "R:2,2 S:1,2", "R:2,2 S:2,2", "R:2,2 S:0,1", "R:2,2 S:1,1", "R:2,2 S:2,1", "R:2,2 S:0,0", "R:2,2 S:1,0", "R:2,2 S:2,0", ] self.setWfsCcdList(detectorList) wfsCorners = dict() ccdDims = dict() for detector in detectorList: wfsCorners[detector] = self.getWfsCorner(detector) ccdDims[detector] = self.getCcdDim(detector) self.setWfsCorners(wfsCorners) self.setCcdDims(ccdDims)
def lsst_camera(): """ Return a copy of the LSST Camera model as stored in obs_lsstSim. """ if not hasattr(lsst_camera, '_lsst_camera'): lsst_camera._lsst_camera = LsstSimMapper().camera return lsst_camera._lsst_camera
def _setupCamera(self): """ Initialize camera mapper, etc. """ self.mapper = LsstSimMapper() self.camera = self.mapper.camera self.epoch = 2000.0 self.cameraFov=np.radians(2.1)
def lsst_camera(): """ Return a copy of the LSST Camera model as stored in obs_lsstSim. """ if not hasattr(lsst_camera, '_lsst_camera'): lsstLog.setLevel('CameraMapper', lsstLog.WARN) lsst_camera._lsst_camera = LsstSimMapper().camera return lsst_camera._lsst_camera
class ssmCatCamera(ssmCat): column_outputs = basic_columns + ['chipName'] camera = LsstSimMapper().camera cannot_be_null = ['visibility', 'chipName'] transformations = { 'raJ2000': np.degrees, 'decJ2000': np.degrees, 'velRa': np.degrees, 'velDec': np.degrees } default_formats = {'f': '%.13f'}
def __init__(self): """Initialization of sky simulator class.""" self.starId = np.array([], dtype=int) self.ra = np.array([]) self.decl = np.array([]) self.mag = np.array([]) self._camera = LsstSimMapper().camera self._obs = ObservationMetaData() self._sourProc = SourceProcessor()
def setUpClass(cls): if _USE_LSST_CAMERA: cls.camera = LsstSimMapper().camera cls.detector = cls.camera['R:1,1 S:2,2'] else: baseDir = os.path.join(getPackageDir('sims_GalSimInterface'), 'tests', 'cameraData') cls.camera = ReturnCamera(baseDir) cls.detector = cls.camera[0] cls.obs = ObservationMetaData(pointingRA=25.0, pointingDec=-10.0, boundType='circle', boundLength=1.0, mjd=49250.0, rotSkyPos=0.0) cls.epoch = 2000.0
class LsstObservatory: """ Class to encapsulate an Observatory object and compute the observatory location information. """ def __init__(self): self.observatory = LsstSimMapper().MakeRawVisitInfoClass().observatory def getLocation(self): """ The LSST observatory location in geocentric coordinates. Returns ------- astropy.coordinates.earth.EarthLocation """ return astropy.coordinates.EarthLocation.from_geodetic( self.observatory.getLongitude().asDegrees(), self.observatory.getLatitude().asDegrees(), self.observatory.getElevation()) def __getattr__(self, attr): if hasattr(self.observatory, attr): return getattr(self.observatory, attr)
def __init__(self, camera=None): """Initialize the world coordinate system (WCS) solution class. Parameters ---------- camera : lsst.afw.cameraGeom.camera.camera.Camera, optional A collection of Detectors that also supports coordinate transformation. (the default is None.) """ self._obs = ObservationMetaData() if camera is None: self._camera = LsstSimMapper().camera else: self._camera = camera
def __init__(self): """Initialization of sky simulator class.""" # Star ID self.starId = np.array([], dtype=int) # Star RA self.ra = np.array([]) # Star Decl self.decl = np.array([]) # Star magnitude self.mag = np.array([]) # DM camera object contains the information to do the coordinate # transformation self._camera = LsstSimMapper().camera # SIMS observation metadata object self._obs = ObservationMetaData() # Source processor in ts_wep self._sourProc = SourceProcessor()
conn.execute(cmd) conn.commit() # fill table cmd = "INSERT INTO defect VALUES (NULL, ?, ?, ?, ?, ?, ?)" numEntries = 0 os.chdir(registryDir) for filePath in glob.glob(os.path.join("rev_*", "defects*.fits")): m = re.search(r'rev_(\d+)/defects(\d+)[AB]*\.fits', filePath) if not m: sys.stderr.write("Skipping file with invalid name: %r\n" % (filePath,)) continue print("Processing %r" % (filePath,)) fitsTable = pyfits.open(filePath) ccd = fitsTable[1].header["NAME"] serial = LsstSimMapper.getShortCcdName(ccd)+"_"+phosimVersion conn.execute(cmd, ( filePath, int(m.group(1)), ccd, serial, "1970-01-01", "2037-12-31", )) numEntries += 1 conn.commit() print("Added %d entries" % (numEntries)) conn.close()
This script demonstrates how to use the stand-along findChipName method from astrometry using an ObservationMetaData generated from the OpSim database """ from __future__ import print_function from builtins import zip import numpy import os from collections import OrderedDict from lsst.sims.utils import arcsecFromRadians from lsst.sims.utils import pupilCoordsFromRaDec, observedFromICRS from lsst.sims.coordUtils import chipNameFromRaDec from lsst.sims.catUtils.baseCatalogModels import OpSim3_61DBObject from lsst.obs.lsstSim import LsstSimMapper mapper = LsstSimMapper() camera = mapper.camera epoch = 2000.0 #generate an ObservationMetaData object based on an actual OpSim pointing radiusDegrees = 3.0 OpSimDB = OpSim3_61DBObject() obs_metadata_list = OpSimDB.getObservationMetaData((88.0, -40.0), 5.0, fovRadius=radiusDegrees, makeCircBounds=True) obs_metadata = obs_metadata_list[0]
def main(file, psf, outdir): """ Drive GalSim to simulate the LSST. """ # Setup a parser to take command line arguments config = desc.imsim.read_config(None) logger = desc.imsim.get_logger("INFO") # Get the number of rows to read from the instance file. Use # default if not specified. numRows = None sensor = None # The PhoSim instance file contains both pointing commands and # objects. The parser will split them and return a both phosim # command dictionary and a dataframe of objects. commands, phosim_objects = \ desc.imsim.parsePhoSimInstanceFile(file, numRows) phosim_objects = \ desc.imsim.validate_phosim_object_list(phosim_objects).accepted # Build the ObservationMetaData with values taken from the # PhoSim commands at the top of the instance file. obs_md = desc.imsim.phosim_obs_metadata(commands) #print (commands) #obs_md.OpsimMetaData['altitude' ] = 20 camera = LsstSimMapper().camera # Sub-divide the source dataframe into stars and galaxies. if sensor is not None: # Trim the input catalog to a single chip. phosim_objects['chipName'] = \ chipNameFromRaDec(phosim_objects['raICRS'].values, phosim_objects['decICRS'].values, parallax=phosim_objects['parallax'].values, camera=camera, obs_metadata=obs_md, epoch=2000.0) starDataBase = \ phosim_objects.query("galSimType=='pointSource' and chipName=='%s'" % sensor) galaxyDataBase = \ phosim_objects.query("galSimType=='sersic' and chipName=='%s'" % sensor) else: starDataBase = \ phosim_objects.query("galSimType=='pointSource'") galaxyDataBase = \ phosim_objects.query("galSimType=='sersic'") # Simulate the objects in the Pandas Dataframes. # First simulate stars phoSimStarCatalog = desc.imsim.ImSimStars(starDataBase, obs_md) phoSimStarCatalog.photParams = desc.imsim.photometricParameters(commands) # Add noise and sky background # The simple code using the default lsst-GalSim interface would be: # # PhoSimStarCatalog.noise_and_background = ExampleCCDNoise(addNoise=True, # addBackground=True) # # But, we need a more realistic sky model and we need to pass more than # this basic info to use Peter Y's ESO sky model. # We must pass obs_metadata, chip information etc... phoSimStarCatalog.noise_and_background = ESOSkyModel(obs_md, addNoise=True, addBackground=True) # Add a PSF. if psf.lower() == "doublegaussian": # This one is taken from equation 30 of # www.astro.washington.edu/users/ivezic/Astr511/LSST_SNRdoc.pdf . # # Set seeing from self.obs_metadata. phoSimStarCatalog.PSF = \ SNRdocumentPSF(obs_md.OpsimMetaData['FWHMgeom']) elif psf.lower() == "kolmogorov": # This PSF was presented by David Kirkby at the 23 March 2017 # Survey Simulations Working Group telecon # # https://confluence.slac.stanford.edu/pages/viewpage.action?spaceKey=LSSTDESC&title=SSim+2017-03-23 # equation 3 of Krisciunas and Schaefer 1991 airmass = 1.0 / np.sqrt( 1.0 - 0.96 * (np.sin(0.5 * np.pi - obs_md.OpsimMetaData['altitude']))**2) phoSimStarCatalog.PSF = \ Kolmogorov_and_Gaussian_PSF(airmass=airmass, rawSeeing=obs_md.OpsimMetaData['rawSeeing'], band=obs_md.bandpass) else: raise RuntimeError("Do not know what to do with psf model: " "%s" % psf) phoSimStarCatalog.camera = camera phoSimStarCatalog.get_fitsFiles() # Now galaxies phoSimGalaxyCatalog = desc.imsim.ImSimGalaxies(galaxyDataBase, obs_md) phoSimGalaxyCatalog.copyGalSimInterpreter(phoSimStarCatalog) phoSimGalaxyCatalog.PSF = phoSimStarCatalog.PSF phoSimGalaxyCatalog.noise_and_background = phoSimStarCatalog.noise_and_background phoSimGalaxyCatalog.get_fitsFiles() # Write out the fits files outdir = outdir if not os.path.isdir(outdir): os.makedirs(outdir) prefix = config['persistence']['eimage_prefix'] phoSimGalaxyCatalog.write_images(nameRoot=os.path.join(outdir, prefix) + str(commands['obshistid']))
def getInputButler(opt): inmapper = LsstSimMapper(root=opt.inRoot, registry=opt.registry) bf = dafPersist.ButlerFactory(mapper=inmapper) inButler = bf.create() return inButler
cmdSettingFile = "./data/cmdFile/starDefault.cmd" instSettingFile = "./data/instFile/starSingleExp.inst" folderPath2FocalPlane = os.path.join(phosimDir, "data", "lsst") # Sky information outputFilePath = "./output/skyWfsAllInfo.txt" # Set the settings obsId = 9001000 aFilter = "g" wavelengthInNm = 500 mjdTime = 59580.0 # Generate the camera object camera = LsstSimMapper().camera # Set the ObservationMetaData RA = 0 Dec = 0 # The unit of camera rotation angle is in degree cameraRotation = 0 cameraMJD = 59580.0 obs = ObservationMetaData(pointingRA=RA, pointingDec=Dec, rotSkyPos=cameraRotation, mjd=mjdTime) # Instantiate the subsystems
def observatory(self): if self._observatory is None: self._observatory \ = LsstSimMapper().MakeRawVisitInfoClass().observatory return self._observatory
def testEndToEnd(self): """Test ISR, CcdAssembly, CrSplit, ImgChar, SFM pipelines""" #Setup up astrometry_net_data # Note - one of datarel's dependencies causes setup of # 'astrometry_net_data cfhttemplate' version; # datarel needs imsim_*. ver = 'imsim-2010-12-17-1' print "Setting up astrometry_net_data", ver # XXX what is actually used from this setup -- a path in the env? ok, version, reason = eups.Eups().setup("astrometry_net_data", versionName=ver) if not ok: raise ValueError("Couldn't set up version '%s' of astrometry_net_data: %s" % (ver, reason)) afwdataDir = lsst.utils.getPackageDir("afwdata") inputRoot = os.path.join(afwdataDir, "ImSim") if os.path.exists("endToEnd.py"): outputRoot = "." else: outputRoot = "tests" registryPath = os.path.join(inputRoot, "registry.sqlite3") bf = dafPersist.ButlerFactory(mapper=LsstSimMapper(root=inputRoot)) inButler = bf.create() obf = dafPersist.ButlerFactory(mapper=LsstSimMapper(root=outputRoot, registry=registryPath)) outButler = obf.create() stat = subprocess.call(["runImSim.py", "-T", "--force", "-i", inputRoot, "-o", outputRoot, "-v", "85408556", "-r", "2,3", "-s", "1,1"]) self.assertEqual(stat, 0, "Error while running end to end test") fname = "psf/v85408556-fr/R23/S11.boost" stat = subprocess.call(["cmp", os.path.join(outputRoot, fname), os.path.join(inputRoot, fname)]) psfDiffers = (stat != 0) if psfDiffers: print 'PSF differs (but carrying on and failing later...)' results = [] for datasetType in ("icSrc", "src", "calexp"): msg = compare(outButler, inButler, datasetType, visit=85408556, raft="2,3", sensor="1,1") results.append((datasetType, msg)) if msg is not None: print 'Dataset type', datasetType, 'differs (but carrying on and failing later...)' print 'message:', msg for snap in (0, 1): msg = compare(outButler, inButler, "sdqaCcd", visit=85408556, snap=snap, raft="2,3", sensor="1,1") results.append(('sdqaCcd snap %i' % snap, msg)) if msg is not None: print 'Snap', snap, 'sdqaCCD differs (but carrying on and failing later...)' print 'message:', msg for channel in inButler.queryMetadata("raw", "channel"): msg = compare(outButler, inButler, "sdqaAmp", visit=85408556, snap=snap, raft="2,3", sensor="1,1", channel=channel) print 'channel:', channel results.append(('sdqaAmp snap %i channel ' % (snap) + str(channel), msg)) if msg is not None: print 'Snap', snap, 'channel', channels, 'sdqaAmp differs (but carrying on and failing later...)' print 'message:', msg # Deferred failure! self.assertFalse(psfDiffers) for datasetType,msg in results: self.assert_(msg is None, msg)
class CameraCoordsCatalog(AstrometryStars, CameraCoords, InstanceCatalog): camera = LsstSimMapper().camera column_outputs = ['id', 'chipName']
camConfig.transformDict = tmc def makeDir(dirPath, doClobber=False): """Make a directory; if it exists then clobber or fail, depending on doClobber @param[in] dirPath: path of directory to create @param[in] doClobber: what to do if dirPath already exists: if True and dirPath is a dir, then delete it and recreate it, else raise an exception @throw RuntimeError if dirPath exists and doClobber False """ if os.path.exists(dirPath): if doClobber and os.path.isdir(dirPath): print("Clobbering directory %r" % (dirPath, )) shutil.rmtree(dirPath) else: raise RuntimeError("Directory %r exists" % (dirPath, )) print("Creating directory %r" % (dirPath, )) os.makedirs(dirPath) # write data products outDir = args.OutputDir makeDir(dirPath=outDir, doClobber=args.clobber) camConfigPath = os.path.join(outDir, "camera.py") camConfig.save(camConfigPath) for detectorName, ampTable in ampTableDict.items(): shortDetectorName = LsstSimMapper.getShortCcdName(detectorName) ampInfoPath = os.path.join(outDir, shortDetectorName + ".fits") ampTable.writeFits(ampInfoPath)
def __init__(self): """Initialize the LSST camera class.""" super(LsstCam, self).__init__(LsstSimMapper().camera) self._initDetectors(DetectorType.WAVEFRONT)
def __init__(self): self.observatory = LsstSimMapper().MakeRawVisitInfoClass().observatory
class CsvGenerator(object): def __init__(self, root, registry=None, compress=True): if registry is None: registry = os.path.join(root, "registry.sqlite3") self.mapper = LsstSimMapper(root=root, registry=registry) bf = dafPersist.ButlerFactory(mapper=self.mapper) self.butler = bf.create() self.expFile = CsvFileWriter("Raw_Amp_Exposure.csv", compress=compress) self.mdFile = CsvFileWriter("Raw_Amp_Exposure_Metadata.csv", compress=compress) self.rToSFile = CsvFileWriter("Raw_Amp_To_Science_Ccd_Exposure.csv", compress=compress) self.polyFile = open("Raw_Amp_Exposure_Poly.tsv", "wb") def csvAll(self): for visit, raft, sensor in self.butler.queryMetadata("raw", "sensor", ("visit", "raft", "sensor")): if self.butler.datasetExists("raw", visit=visit, snap=0, raft=raft, sensor=sensor, channel="0,0"): self.toCsv(visit, raft, sensor) self.expFile.flush() self.mdFile.flush() self.rToSFile.flush() self.polyFile.flush() self.polyFile.close() def getFullMetadata(self, datasetType, **keys): filename = self.mapper.map(datasetType, keys).getLocations()[0] return afwImage.readMetadata(filename) def toCsv(self, visit, raft, sensor): r1, comma, r2 = raft s1, comma, s2 = sensor raftNum = rafts.index(raft) raftId = int(r1) * 5 + int(r2) ccdNum = int(s1) * 3 + int(s2) sciCcdExposureId = (long(visit) << 9) + raftId * 10 + ccdNum for snap in xrange(2): rawCcdExposureId = (sciCcdExposureId << 1) + snap for channelY in xrange(2): for channelX in xrange(8): channel = "%d,%d" % (channelY, channelX) channelNum = (channelY << 3) + channelX rawAmpExposureId = (rawCcdExposureId << 4) + channelNum try: md = self.getFullMetadata("raw", visit=visit, snap=snap, raft=raft, sensor=sensor, channel=channel) except: print("*** Unable to read metadata for " "visit %d snap %d " "raft %s sensor %s channel %s" % (visit, snap, raft, sensor, channel)) continue self.rToSFile.write(rawAmpExposureId, sciCcdExposureId, snap, channelNum) width = md.get('NAXIS1') height = md.get('NAXIS2') wcs = afwImage.makeWcs(md.deepCopy()) cen = wcs.pixelToSky(0.5*width - 0.5, 0.5*height - 0.5).toIcrs() corner1 = wcs.pixelToSky(-0.5, -0.5).toIcrs() corner2 = wcs.pixelToSky(-0.5, height - 0.5).toIcrs() corner3 = wcs.pixelToSky(width - 0.5, height - 0.5).toIcrs() corner4 = wcs.pixelToSky(width - 0.5, -0.5).toIcrs() mjd = md.get('MJD-OBS') if mjd == 0.0: mjd = 49563.270671 obsStart = dafBase.DateTime(mjd, dafBase.DateTime.MJD, dafBase.DateTime.UTC) expTime = md.get('EXPTIME') obsMidpoint = dafBase.DateTime(obsStart.nsecs() + long(expTime * 1000000000 / 2)) filterName = md.get('FILTER').strip() self.expFile.write(rawAmpExposureId, visit, snap, raftNum, raft, ccdNum, sensor, channelNum, channel, filterMap.index(filterName), filterName, cen.getRa().asDegrees(), cen.getDec().asDegrees(), md.get('EQUINOX'), md.get('RADESYS'), md.get('CTYPE1'), md.get('CTYPE2'), md.get('CRPIX1'), md.get('CRPIX2'), md.get('CRVAL1'), md.get('CRVAL2'), md.get('CD1_1'), md.get('CD1_2'), md.get('CD2_1'), md.get('CD2_2'), corner1.getRa().asDegrees(), corner1.getDec().asDegrees(), corner2.getRa().asDegrees(), corner2.getDec().asDegrees(), corner3.getRa().asDegrees(), corner3.getDec().asDegrees(), corner4.getRa().asDegrees(), corner4.getDec().asDegrees(), obsStart.get(dafBase.DateTime.MJD, dafBase.DateTime.TAI), obsStart, obsMidpoint.get(dafBase.DateTime.MJD, dafBase.DateTime.TAI), expTime, md.get('AIRMASS'), md.get('DARKTIME'), md.get('ZENITH')) for name in md.paramNames(): if md.typeOf(name) == md.TYPE_Int: self.mdFile.write(rawAmpExposureId, name, 1, md.getInt(name), None, None) elif md.typeOf(name) == md.TYPE_Double: self.mdFile.write(rawAmpExposureId, name, 1, None, md.getDouble(name), None) else: self.mdFile.write(rawAmpExposureId, name, 1, None, None, str(md.get(name))) self.polyFile.write("\t".join([ str(rawAmpExposureId), repr(corner1.getRa().asDegrees()), repr(corner1.getDec().asDegrees()), repr(corner2.getRa().asDegrees()), repr(corner2.getDec().asDegrees()), repr(corner3.getRa().asDegrees()), repr(corner3.getDec().asDegrees()), repr(corner4.getRa().asDegrees()), repr(corner4.getDec().asDegrees())])) self.polyFile.write("\n") print("Processed visit %d raft %s sensor %s" % (visit, raft, sensor))
def setUpClass(cls): cls.camera = LsstSimMapper().camera
camConfig.transformDict = tmc def makeDir(dirPath, doClobber=False): """Make a directory; if it exists then clobber or fail, depending on doClobber @param[in] dirPath: path of directory to create @param[in] doClobber: what to do if dirPath already exists: if True and dirPath is a dir, then delete it and recreate it, else raise an exception @throw RuntimeError if dirPath exists and doClobber False """ if os.path.exists(dirPath): if doClobber and os.path.isdir(dirPath): print "Clobbering directory %r" % (dirPath,) shutil.rmtree(dirPath) else: raise RuntimeError("Directory %r exists" % (dirPath,)) print "Creating directory %r" % (dirPath,) os.makedirs(dirPath) # write data products outDir = args.OutputDir makeDir(dirPath=outDir, doClobber=args.clobber) camConfigPath = os.path.join(outDir, "camera.py") camConfig.save(camConfigPath) for detectorName, ampTable in ampTableDict.iteritems(): shortDetectorName = LsstSimMapper.getShortCcdName(detectorName) ampInfoPath = os.path.join(outDir, shortDetectorName + ".fits") ampTable.writeFits(ampInfoPath)
def getOutputButler(opt): outmapper = LsstSimMapper(root=opt.outRoot, registry=opt.registry) bf = dafPersist.ButlerFactory(mapper=outmapper) outButler = bf.create() return outButler
def __init__(self): """Initialize the LSST full-array mode (FAM) camera class.""" super(LsstFamCam, self).__init__(LsstSimMapper().camera) self._initDetectors(DetectorType.SCIENCE)
conn.execute(cmd) conn.commit() # fill table cmd = "INSERT INTO defect VALUES (NULL, ?, ?, ?, ?, ?, ?)" numEntries = 0 os.chdir(registryDir) for filePath in glob.glob(os.path.join("rev_*", "defects*.fits")): m = re.search(r'rev_(\d+)/defects(\d+)[AB]*\.fits', filePath) if not m: sys.stderr.write("Skipping file with invalid name: %r\n" % (filePath,)) continue print "Processing %r" % (filePath,) fitsTable = pyfits.open(filePath) ccd = fitsTable[1].header["NAME"] serial = LsstSimMapper.getShortCcdName(ccd)+"_"+phosimVersion conn.execute(cmd, ( filePath, int(m.group(1)), ccd, serial, "1970-01-01", "2037-12-31", )) numEntries += 1 conn.commit() print "Added %d entries" % (numEntries) conn.close()
def _setupLSSTCamera(self): """If we want to include the camera chip gaps, etc""" mapper = LsstSimMapper() self.camera = mapper.camera self.epoch = 2000.0