def test_quickgen_seed_brick(self):
cmd = "quickgen --seed 1 --brickname test1a --objtype BRIGHT_MIX -n 1 --outdir {}".format(
self.testDir)
quickgen.main(quickgen.parse(cmd.split()[1:]))
cmd = "quickgen --seed 1 --brickname test1b --objtype BRIGHT_MIX -n 1 --outdir {}".format(
self.testDir)
quickgen.main(quickgen.parse(cmd.split()[1:]))
cmd = "quickgen --seed 2 -b test2 --objtype BRIGHT_MIX -n 1 --outdir {}".format(
self.testDir)
quickgen.main(quickgen.parse(cmd.split()[1:]))
f1a = desispec.io.read_frame('{}/brick-b-test1a.fits'.format(
self.testDir))
f1b = desispec.io.read_frame('{}/brick-b-test1b.fits'.format(
self.testDir))
f2 = desispec.io.read_frame('{}/brick-b-test2.fits'.format(
self.testDir))
self.assertTrue(np.all(f1a.flux == f1b.flux)) #- same seed
self.assertTrue(np.all(f1a.ivar == f1b.ivar))
self.assertTrue(np.any(f1a.flux != f2.flux)) #- different seed
t1a = fits.getdata('{}/brick-b-test1a.fits'.format(self.testDir),
'_TRUTH')
t1b = fits.getdata('{}/brick-b-test1b.fits'.format(self.testDir),
'_TRUTH')
t2 = fits.getdata('{}/brick-b-test2.fits'.format(self.testDir),
'_TRUTH')
self.assertTrue(np.all(t1a['TRUE_OBJTYPE'] == t1b['TRUE_OBJTYPE']))
self.assertTrue(np.all(t1b['TRUEZ'] == t1b['TRUEZ']))
self.assertTrue(np.any(t1a['TRUEZ'] != t2['TRUEZ']))
def test_quickgen_moonzenith_simspec(self):
night = self.night
camera = 'r0'
expid0 = 100
expid1 = 101
# generate exposures
obs.new_exposure('bgs', night=night, expid=expid0, nspec=1, seed=1)
simspec0 = io.findfile('simspec', night, expid0)
fibermap0 = desispec.io.findfile('fibermap', night, expid0)
obs.new_exposure('bgs', night=night, expid=expid1, nspec=1, seed=1)
simspec1 = io.findfile('simspec', night, expid1)
fibermap1 = desispec.io.findfile('fibermap', night, expid1)
# generate quickgen output for each moon phase
cmd = "quickgen --simspec {} --fibermap {} --moon-zenith 0".format(
simspec0, fibermap0)
quickgen.main(quickgen.parse(cmd.split()[1:]))
cmd = "quickgen --simspec {} --fibermap {} --moon-zenith 90".format(
simspec1, fibermap1)
quickgen.main(quickgen.parse(cmd.split()[1:]))
cframe0 = desispec.io.findfile("cframe", night, expid0, camera)
cframe1 = desispec.io.findfile("cframe", night, expid1, camera)
cf0 = desispec.io.read_frame(cframe0)
cf1 = desispec.io.read_frame(cframe1)
self.assertLess(np.median(cf0.ivar), np.median(cf1.ivar))
def test_quickgen_moonzenith_simspec(self):
night = self.night
camera = 'r0'
expid0 = 100
expid1 = 101
# generate exposures
obs.new_exposure('bgs',night=night,expid=expid0,nspec=1,seed=1)
simspec0 = io.findfile('simspec', night, expid0)
fibermap0 = desispec.io.findfile('fibermap', night, expid0)
obs.new_exposure('bgs',night=night,expid=expid1,nspec=1,seed=1)
simspec1 = io.findfile('simspec', night, expid1)
fibermap1 = desispec.io.findfile('fibermap', night, expid1)
# generate quickgen output for each moon phase
cmd = "quickgen --simspec {} --fibermap {} --moon-zenith 0".format(simspec0,fibermap0)
quickgen.main(quickgen.parse(cmd.split()[1:]))
cmd = "quickgen --simspec {} --fibermap {} --moon-zenith 90".format(simspec1,fibermap1)
quickgen.main(quickgen.parse(cmd.split()[1:]))
cframe0=desispec.io.findfile("cframe",night,expid0,camera)
cframe1=desispec.io.findfile("cframe",night,expid1,camera)
cf0=desispec.io.read_frame(cframe0)
cf1=desispec.io.read_frame(cframe1)
self.assertLess(np.median(cf0.ivar),np.median(cf1.ivar))
def test_quickgen_airmass_simspec(self):
night=self.night
camera = 'r0'
expid0 = 100
expid1 = 101
# generate exposures of varying airmass
obscond = simexp.reference_conditions['DARK']
obscond['AIRMASS'] = 1.5
obs.new_exposure('dark',night=night,expid=expid0,nspec=1,seed=1,obsconditions=obscond)
simspec0 = io.findfile('simspec', night, expid0)
fibermap0 = desispec.io.findfile('fibermap', night, expid0)
obscond['AIRMASS'] = 1.0
obs.new_exposure('dark',night=night,expid=expid1,nspec=1,seed=1,obsconditions=obscond)
simspec1 = io.findfile('simspec', night, expid1)
fibermap1 = desispec.io.findfile('fibermap', night, expid1)
# generate quickgen output for each airmass
cmd = "quickgen --simspec {} --fibermap {}".format(simspec0,fibermap0)
quickgen.main(quickgen.parse(cmd.split()[1:]))
cmd = "quickgen --simspec {} --fibermap {}".format(simspec1,fibermap1)
quickgen.main(quickgen.parse(cmd.split()[1:]))
cframe0=desispec.io.findfile("cframe",night,expid0,camera)
cframe1=desispec.io.findfile("cframe",night,expid1,camera)
cf0=desispec.io.read_frame(cframe0)
cf1=desispec.io.read_frame(cframe1)
self.assertLess(np.median(cf0.ivar),np.median(cf1.ivar))
def test_quickgen_simspec(self):
night = self.night
expid = self.expid
camera = 'r0'
# flavors = ['flat','dark','gray','bright','bgs','mws','elg','lrg','qso','arc']
flavors = ['flat', 'dark', 'bright']
for i in range(len(flavors)):
flavor = flavors[i]
obs.new_exposure(flavor, night=night, expid=expid, nspec=2)
#- output to same directory as input
os.environ['DESI_SPECTRO_REDUX'] = os.path.join(
os.getenv('DESI_SPECTRO_SIM'), os.getenv('PIXPROD'))
#- run quickgen
simspec = io.findfile('simspec', night, expid)
fibermap = io.findfile('simfibermap', night, expid)
self.assertTrue(os.path.exists(simspec))
self.assertTrue(os.path.exists(fibermap))
if flavor == 'flat':
try:
cmd = "quickgen --simspec {} --fibermap {}".format(
simspec, fibermap)
quickgen.main(quickgen.parse(cmd.split()[1:]))
except SystemExit:
pass
#- verify flat outputs
fiberflatfile = desispec.io.findfile('fiberflat', night, expid,
camera)
self.assertTrue(os.path.exists(fiberflatfile))
else:
cmd = "quickgen --simspec {} --fibermap {}".format(
simspec, fibermap)
quickgen.main(quickgen.parse(cmd.split()[1:]))
#- verify outputs
framefile = desispec.io.findfile('frame', night, expid, camera)
self.assertTrue(os.path.exists(framefile))
cframefile = desispec.io.findfile('cframe', night, expid,
camera)
self.assertTrue(os.path.exists(cframefile))
skyfile = desispec.io.findfile('sky', night, expid, camera)
self.assertTrue(os.path.exists(skyfile))
fluxcalibfile = desispec.io.findfile('calib', night, expid,
camera)
self.assertTrue(os.path.exists(fluxcalibfile))
os.remove(simspec)
os.remove(fibermap)
def test_quickgen_seed_simspec(self):
night = self.night
camera = 'r0'
expid0 = 100
expid1 = 101
expid2 = 102
# generate exposures seed 1 & 2
obs.new_exposure('dark', night=night, expid=expid0, nspec=1, seed=1)
simspec0 = io.findfile('simspec', night, expid0)
fibermap0 = desispec.io.findfile('fibermap', night, expid0)
obs.new_exposure('dark', night=night, expid=expid1, nspec=1, seed=1)
simspec1 = io.findfile('simspec', night, expid1)
fibermap1 = desispec.io.findfile('fibermap', night, expid1)
obs.new_exposure('dark', night=night, expid=expid2, nspec=1, seed=2)
simspec2 = io.findfile('simspec', night, expid2)
fibermap2 = desispec.io.findfile('fibermap', night, expid2)
# generate quickgen output for each exposure
cmd = "quickgen --simspec {} --fibermap {} --seed 1".format(
simspec0, fibermap0)
quickgen.main(quickgen.parse(cmd.split()[1:]))
cmd = "quickgen --simspec {} --fibermap {} --seed 1".format(
simspec1, fibermap1)
quickgen.main(quickgen.parse(cmd.split()[1:]))
cmd = "quickgen --simspec {} --fibermap {} --seed 2".format(
simspec2, fibermap2)
quickgen.main(quickgen.parse(cmd.split()[1:]))
cframe0 = desispec.io.findfile("cframe", night, expid0, camera)
cframe1 = desispec.io.findfile("cframe", night, expid1, camera)
cframe2 = desispec.io.findfile("cframe", night, expid2, camera)
cf0 = desispec.io.read_frame(cframe0)
cf1 = desispec.io.read_frame(cframe1)
cf2 = desispec.io.read_frame(cframe2)
self.assertTrue(np.all(cf0.flux == cf1.flux)) #- same seed
self.assertTrue(np.all(cf0.ivar == cf1.ivar))
self.assertTrue(np.any(cf0.flux != cf2.flux)) #- different seed
s0 = fits.open(simspec0)
s1 = fits.open(simspec1)
s2 = fits.open(simspec2)
self.assertEqual(s0['TRUTH'].data['OBJTYPE'][0],
s1['TRUTH'].data['OBJTYPE'][0])
self.assertEqual(s0['TRUTH'].data['REDSHIFT'][0],
s1['TRUTH'].data['REDSHIFT'][0])
self.assertNotEqual(s0['TRUTH'].data['REDSHIFT'][0],
s2['TRUTH'].data['REDSHIFT'][0])
def test_quickgen_exptime_brick(self):
cmd = "quickgen --brickname test1 --exptime 100 --objtype DARK_MIX -n 1 --outdir {}".format(
self.testDir)
quickgen.main(quickgen.parse(cmd.split()[1:]))
cmd = "quickgen --brickname test2 --exptime 1000 --objtype DARK_MIX -n 1 --outdir {}".format(
self.testDir)
quickgen.main(quickgen.parse(cmd.split()[1:]))
f1 = desispec.io.read_frame('{}/brick-b-test1.fits'.format(
self.testDir))
f2 = desispec.io.read_frame('{}/brick-b-test2.fits'.format(
self.testDir))
#- test1 has shorter exposure time thus larger errors thus smaller ivar
self.assertLess(np.median(f1.ivar), np.median(f2.ivar))
def test_quickgen_moonzenith_brick(self):
cmd = "quickgen --brickname zenith0 --objtype BRIGHT_MIX -n 1 --outdir {} --moon-zenith 0".format(
self.testDir)
quickgen.main(quickgen.parse(cmd.split()[1:]))
cmd = "quickgen --brickname zenith90 --objtype BRIGHT_MIX -n 1 --outdir {} --moon-zenith 90".format(
self.testDir)
quickgen.main(quickgen.parse(cmd.split()[1:]))
brick1 = desispec.io.read_frame('{}/brick-b-zenith0.fits'.format(
self.testDir))
brick2 = desispec.io.read_frame('{}/brick-b-zenith90.fits'.format(
self.testDir))
#- brick1 has more moonlight thus larger errors thus smaller ivar
self.assertLess(np.median(brick1.ivar), np.median(brick2.ivar))
def test_quickgen_brick(self):
brickname = 'test1'
nspec = 3
cmd = "quickgen --brickname {} --objtype ELG -n {} --outdir {}".format(
brickname, nspec, self.testDir)
args = quickgen.parse(cmd.split()[1:])
results = quickgen.main(args)
#- Do the bricks exist?
for channel in ['z', 'r', 'b']:
brickfile = '{}/brick-{}-{}.fits'.format(self.testDir, channel,
brickname)
self.assertTrue(os.path.exists(brickfile))
#- Check one of them for correct dimensionality of contents
brickfile = '{}/brick-b-{}.fits'.format(self.testDir, brickname)
with fits.open(brickfile) as fx:
self.assertEqual(fx['FLUX'].shape[0], nspec)
self.assertEqual(fx['FLUX'].shape, fx['IVAR'].shape)
self.assertEqual(fx['FLUX'].shape[1], fx['WAVELENGTH'].shape[0])
self.assertEqual(fx['FLUX'].shape[0], fx['RESOLUTION'].shape[0])
self.assertEqual(fx['FLUX'].shape[1], fx['RESOLUTION'].shape[2])
self.assertEqual(len(fx['FIBERMAP'].data), nspec)
self.assertEqual(fx['_TRUEFLUX'].shape, fx['FLUX'].shape)
self.assertTrue(np.all(fx['_TRUTH'].data['OBJTYPE'] == 'ELG'))
#- Make sure that desispec I/O functions can read it
frame = desispec.io.read_frame(brickfile)
self.assertEqual(frame.flux.shape[0], nspec)
brick = desispec.io.Brick(brickfile)
self.assertEqual(brick.get_num_spectra(), nspec)
brick.close()
def test_quickgen_simspec(self):
night = self.night
expid = self.expid
camera = 'r0'
# flavors = ['flat','dark','gray','bright','bgs','mws','elg','lrg','qso','arc']
flavors = ['flat', 'dark', 'bright']
for i in range(len(flavors)):
flavor = flavors[i]
obs.new_exposure(flavor, night=night, expid=expid, nspec=2)
#- output to same directory as input
os.environ['DESI_SPECTRO_REDUX'] = os.path.join(os.getenv('DESI_SPECTRO_SIM'), os.getenv('PIXPROD'))
#- run quickgen
simspec = io.findfile('simspec', night, expid)
fibermap = io.findfile('simfibermap', night, expid)
self.assertTrue(os.path.exists(simspec))
self.assertTrue(os.path.exists(fibermap))
if flavor == 'flat':
try:
cmd = "quickgen --simspec {} --fibermap {}".format(simspec,fibermap)
quickgen.main(quickgen.parse(cmd.split()[1:]))
except SystemExit:
pass
#- verify flat outputs
fiberflatfile = desispec.io.findfile('fiberflat', night, expid, camera)
self.assertTrue(os.path.exists(fiberflatfile))
else:
cmd = "quickgen --simspec {} --fibermap {}".format(simspec,fibermap)
quickgen.main(quickgen.parse(cmd.split()[1:]))
#- verify outputs
framefile = desispec.io.findfile('frame', night, expid, camera)
self.assertTrue(os.path.exists(framefile))
cframefile = desispec.io.findfile('cframe', night, expid, camera)
self.assertTrue(os.path.exists(cframefile))
skyfile = desispec.io.findfile('sky', night, expid, camera)
self.assertTrue(os.path.exists(skyfile))
fluxcalibfile = desispec.io.findfile('calib', night, expid, camera)
self.assertTrue(os.path.exists(fluxcalibfile))
os.remove(simspec)
os.remove(fibermap)
def test_parse(self):
night = self.night
expid = self.expid
obs.new_exposure('dark', night=night, expid=expid, nspec=4)
simspec = io.findfile('simspec', self.night, self.expid)
fibermap = desispec.io.findfile('fibermap', self.night, self.expid)
opts = ['--simspec', simspec, '--fibermap', fibermap]
opts += ['--spectrograph', '3', '--config', 'desi']
args = quickgen.parse(opts)
self.assertEqual(args.simspec, simspec)
self.assertEqual(args.fibermap, fibermap)
self.assertEqual(args.spectrograph, 3)
self.assertEqual(args.config, 'desi')
with self.assertRaises(ValueError):
quickgen.parse([])
def test_parse(self):
night = self.night
expid = self.expid
obs.new_exposure('dark', night=night, expid=expid, nspec=4)
simspec = io.findfile('simspec', self.night, self.expid)
fibermap = desispec.io.findfile('fibermap', self.night, self.expid)
opts = ['--simspec', simspec, '--fibermap', fibermap]
opts += ['--spectrograph', '3', '--config', 'desi']
args = quickgen.parse(opts)
self.assertEqual(args.simspec, simspec)
self.assertEqual(args.fibermap, fibermap)
self.assertEqual(args.spectrograph, 3)
self.assertEqual(args.config, 'desi')
with self.assertRaises(SystemExit):
quickgen.parse([])
def test_expand_args(self):
night = self.night
expid = self.expid
obs.new_exposure('arc', night=night, expid=expid, nspec=4)
simspec = io.findfile('simspec', self.night, self.expid)
fibermap = desispec.io.findfile('fibermap', self.night, self.expid)
opts = ['--simspec', simspec, '--fibermap', fibermap]
args = quickgen.parse(opts)
self.assertEqual(args.simspec, simspec)
self.assertEqual(args.fibermap, fibermap)
def test_expand_args(self):
night = self.night
expid = self.expid
obs.new_exposure('arc', night=night, expid=expid, nspec=4)
simspec = io.findfile('simspec', self.night, self.expid)
fibermap = desispec.io.findfile('fibermap', self.night, self.expid)
opts = ['--simspec', simspec, '--fibermap', fibermap]
args = quickgen.parse(opts)
self.assertEqual(args.simspec, simspec)
self.assertEqual(args.fibermap, fibermap)
def test_quickgen_airmass_simspec(self):
night = self.night
camera = 'r0'
expid0 = 100
expid1 = 101
# generate exposures of varying airmass
obscond = simexp.reference_conditions['DARK']
obscond['AIRMASS'] = 1.5
obs.new_exposure('dark',
night=night,
expid=expid0,
nspec=1,
seed=1,
obsconditions=obscond)
simspec0 = io.findfile('simspec', night, expid0)
fibermap0 = desispec.io.findfile('fibermap', night, expid0)
obscond['AIRMASS'] = 1.0
obs.new_exposure('dark',
night=night,
expid=expid1,
nspec=1,
seed=1,
obsconditions=obscond)
simspec1 = io.findfile('simspec', night, expid1)
fibermap1 = desispec.io.findfile('fibermap', night, expid1)
# generate quickgen output for each airmass
cmd = "quickgen --simspec {} --fibermap {}".format(simspec0, fibermap0)
quickgen.main(quickgen.parse(cmd.split()[1:]))
cmd = "quickgen --simspec {} --fibermap {}".format(simspec1, fibermap1)
quickgen.main(quickgen.parse(cmd.split()[1:]))
cframe0 = desispec.io.findfile("cframe", night, expid0, camera)
cframe1 = desispec.io.findfile("cframe", night, expid1, camera)
cf0 = desispec.io.read_frame(cframe0)
cf1 = desispec.io.read_frame(cframe1)
self.assertLess(np.median(cf0.ivar), np.median(cf1.ivar))
def test_quickgen_options_brick(self):
brickname = 'test2'
nspec = 7
seed = np.random.randint(2**30)
cmd = "quickbrick --brickname {} --objtype BGS -n {} --outdir {} --seed {}".format(
brickname, nspec, self.testDir, seed)
cmd = cmd + " --airmass 1.5 --verbose --zrange-bgs 0.1 0.2"
cmd = cmd + " --moon-phase 0.1 --moon-angle 30 --moon-zenith 20"
args = quickgen.parse(cmd.split()[1:])
results = quickgen.main(args)
brickfile = '{}/brick-b-{}.fits'.format(self.testDir, brickname)
truth = fits.getdata(brickfile, '_TRUTH')
z = truth['TRUEZ']
self.assertTrue(np.all((0.1 <= z) & (z <= 0.2)))
#- Basic empirical sanity check of median(error) vs. median(flux)
#- These coefficients are taken from 50 quickbrick BGS targets
#- The main point is to trigger if something significantly changed
#- in a new version, not to validate that this is actually the right
#- error vs. flux model.
coeff = dict()
coeff['b'] = [6.379e-08, -2.824e-05, 1.952e-02, 8.051e+00]
coeff['r'] = [6.683e-08, -4.537e-05, 2.230e-02, 3.767e+00]
coeff['z'] = [1.358e-07, -7.210e-05, 2.392e-02, 2.090e+00]
for channel in ['b', 'r', 'z']:
brickfile = '{}/brick-{}-{}.fits'.format(self.testDir, channel,
brickname)
brick = desispec.io.read_frame(brickfile)
medflux = np.median(brick.flux, axis=1)
mederr = np.median(1 / np.sqrt(brick.ivar), axis=1)
ii = (medflux < 250)
if np.count_nonzero(ii) < 3:
print(cmd)
print('Too few points for stddev; skipping comparison')
else:
std = np.std(mederr[ii] -
np.polyval(coeff[channel], medflux[ii]))
if std > 0.15:
print(cmd)
self.assertLess(
std, 0.25,
'noise model failed for channel {} seed {}'.format(
channel, seed))
# Generate the fibermap and specsim files needed by quickgen
# fibermap: table of simulated information about the position of each target in the DESI focal plane
# simspec: "truth" table of spectra and the intrinsic properties of each object (e.g. redshift,
# noiseless photometry, [OII] flux, etc.)
# If you want to use your own mix of objects, you need to write your own fibermap and specsim files
# following the particular format (rather than calling new_exposure)
# new_exposure generates random exposures of various types
output = new_exposure(args.flavor,
nspec=args.nspec,
seed=args.seed,
night=args.night,
expid=args.expid,
tileid=None,
exptime=None)
# Check in on the data we just wrote
rawdata_dir = desispec.io.rawdata_root()
os.system('find {} | sort'.format(rawdata_dir))
fiberfile = desispec.io.findfile('fibermap',
night=args.night,
expid=args.expid)
simspecfile = desisim.io.findfile('simspec',
night=args.night,
expid=args.expid)
# Now we simulate the spectra using quickgen
quickgen.main(
quickgen.parse(['--simspec', simspecfile, '--fibermap', fiberfile]))
def main(args):
# Set up the logger.
if args.verbose:
log = get_logger(DEBUG)
else:
log = get_logger()
objtype = args.objtype.upper()
log.debug('Using OBJTYPE {}'.format(objtype))
log.debug('Simulating {:g} bricks each with {:g} spectra'.format(args.nbrick, args.nspec))
# Draw priors uniformly given the input ranges.
rand = np.random.RandomState(args.seed)
exptime = rand.uniform(args.exptime_range[0], args.exptime_range[1], args.nbrick)
airmass = rand.uniform(args.airmass_range[0], args.airmass_range[1], args.nbrick)
moonphase = rand.uniform(args.moon_phase_range[0], args.moon_phase_range[1], args.nbrick)
moonangle = rand.uniform(args.moon_angle_range[0], args.moon_angle_range[1], args.nbrick)
moonzenith = rand.uniform(args.moon_zenith_range[0], args.moon_zenith_range[1], args.nbrick)
# Build a metadata table with the simulation inputs.
metafile = makepath(os.path.join(args.outdir, '{}-input.fits'.format(args.brickname)))
metacols = [
('BRICKNAME', 'S20'),
('SEED', 'S20'),
('EXPTIME', 'f4'),
('AIRMASS', 'f4'),
('MOONPHASE', 'f4'),
('MOONANGLE', 'f4'),
('MOONZENITH', 'f4')]
meta = Table(np.zeros(args.nbrick, dtype=metacols))
meta['EXPTIME'].unit = 's'
meta['MOONANGLE'].unit = 'deg'
meta['MOONZENITH'].unit = 'deg'
meta['BRICKNAME'] = ['{}-{:03d}'.format(args.brickname, ii) for ii in range(args.nbrick)]
meta['EXPTIME'] = exptime
meta['AIRMASS'] = airmass
meta['MOONPHASE'] = moonphase
meta['MOONANGLE'] = moonangle
meta['MOONZENITH'] = moonzenith
log.debug('Writing {}'.format(metafile))
write_bintable(metafile, meta, extname='METADATA', clobber=True)
# Generate each brick in turn.
for ii in range(args.nbrick):
thisbrick = meta['BRICKNAME'][ii]
log.debug('Building brick {}'.format(thisbrick))
brickargs = ['--brickname', thisbrick,
'--objtype', args.objtype,
'--nspec', '{}'.format(args.nspec),
'--outdir', os.path.join(args.brickdir, thisbrick),
'--outdir-truth', os.path.join(args.brickdir, thisbrick),
'--exptime', '{}'.format(exptime[ii]),
'--airmass', '{}'.format(airmass[ii]),
'--moon-phase', '{}'.format(moonphase[ii]),
'--moon-angle', '{}'.format(moonangle[ii]),
'--moon-zenith', '{}'.format(moonzenith[ii]),
'--zrange-bgs', '{}'.format(args.zrange_bgs[0]), '{}'.format(args.zrange_bgs[1]),
'--rmagrange-bgs', '{}'.format(args.rmagrange_bgs[0]), '{}'.format(args.rmagrange_bgs[1])]
if args.seed is not None:
brickargs.append('--seed')
brickargs.append('{}'.format(args.seed))
quickargs = quickbrick.parse(brickargs)
if args.verbose:
quickargs.verbose = True
quickbrick.main(quickargs)
def main(args):
# Set up the logger.
if args.verbose:
log = get_logger(DEBUG)
else:
log = get_logger()
objtype = args.objtype.upper()
log.debug('Using OBJTYPE {}'.format(objtype))
log.debug('Simulating {:g} bricks each with {:g} spectra'.format(
args.nexp, args.nspec))
# Draw priors uniformly given the input ranges.
rand = np.random.RandomState(args.seed)
exptime = rand.uniform(args.exptime_range[0], args.exptime_range[1],
args.nexp)
airmass = rand.uniform(args.airmass_range[0], args.airmass_range[1],
args.nexp)
moonphase = rand.uniform(args.moon_phase_range[0],
args.moon_phase_range[1], args.nexp)
moonangle = rand.uniform(args.moon_angle_range[0],
args.moon_angle_range[1], args.nexp)
moonzenith = rand.uniform(args.moon_zenith_range[0],
args.moon_zenith_range[1], args.nexp)
maglimits = args.rmagrange - bgs
zrange = args.zrange - bgs
# Build a metadata table with the simulation inputs.
metafile = makepath(
os.path.join(args.outdir, '{}-input.fits'.format(args.brickname)))
metacols = [('BRICKNAME', 'S20'), ('SEED', 'S20'), ('EXPTIME', 'f4'),
('AIRMASS', 'f4'), ('MOONPHASE', 'f4'), ('MOONANGLE', 'f4'),
('MOONZENITH', 'f4')]
meta = Table(np.zeros(args.nexp, dtype=metacols))
meta['EXPTIME'].unit = 's'
meta['MOONANGLE'].unit = 'deg'
meta['MOONZENITH'].unit = 'deg'
meta['BRICKNAME'] = [
'{}-{:03d}'.format(args.nexp, ii) for ii in range(args.nexp)
]
meta['EXPTIME'] = exptime
meta['AIRMASS'] = airmass
meta['MOONPHASE'] = moonphase
meta['MOONANGLE'] = moonangle
meta['MOONZENITH'] = moonzenith
log.debug('Writing {}'.format(metafile))
write_bintable(metafile, meta, extname='METADATA', clobber=True)
# Generate each brick in turn.
for ii in range(args.nexp):
thisbrick = meta['BRICKNAME'][ii]
log.debug('Building brick {}'.format(thisbrick))
brickargs = [
'--brickname', thisbrick, '--objtype', args.objtype, '--nspec',
'{}'.format(args.nspec), '--outdir',
os.path.join(args.brickdir, thisbrick), '--outdir-truth',
os.path.join(args.brickdir,
thisbrick), '--exptime', '{}'.format(exptime[ii]),
'--airmass', '{}'.format(airmass[ii]), '--moon-phase', '{}'.format(
moonphase[ii]), '--moon-angle', '{}'.format(moonangle[ii]),
'--moon-zenith', '{}'.format(moonzenith[ii]), '--zrange-bgs',
'{}'.format(args.zrange_bgs[0]), '{}'.format(args.zrange_bgs[1]),
'--rmagrange-bgs', '{}'.format(args.rmagrange_bgs[0]),
'{}'.format(args.rmagrange_bgs[1])
]
if args.seed is not None:
brickargs.append('--seed')
brickargs.append('{}'.format(args.seed))
quickargs = quickbrick.parse(brickargs)
if args.verbose:
quickargs.verbose = True
quickbrick.main(quickargs)
