def __init__(self, starlight_dir, db, sample, galaxy_id, err_factor=None, blue_clip=None):
self.starlightDir = starlight_dir
self.galaxyId = galaxy_id
self.sample = sample
self._errFactor = err_factor
self._blueClip = blue_clip
self._dc = DecompContainer()
self._dc.loadHDF5(db, sample, galaxy_id)
self._gridTemplate, self._runTemplate = self._getTemplates()
self._createDirs()
################################################################################
parser = argparse.ArgumentParser(description='Plot Bulge/Disk decomposition.')
parser.add_argument('galaxyId', type=str, nargs=1,
help='CALIFA galaxy ID. Ex.: K0001')
parser.add_argument('--sample', dest='sample', default= 'sample004',
help='Sample file. Default: sample004.')
parser.add_argument('--db', dest='db', default='data/decomposition.005.h5',
help='HDF5 database path.')
args = parser.parse_args()
galaxyId = args.galaxyId[0]
sampleId = path.basename(args.sample)
c = DecompContainer()
c.loadHDF5(args.db, sampleId, galaxyId)
t = c.fitParams
t_1p = c.firstPassParams
l_obs_1p = t_1p['wl'][:]
flag_bad_1p = (t_1p['flag'] > 0.0) | (t_1p['chi2'] > 20.0)
box_radius = c.attrs['box_radius']
target_vd = c.attrs['target_vd']
PSF_FWHM = c.attrs['PSF_FWHM']
galaxyName = c.attrs['object_name']
flux_unit = c.attrs['flux_unit']
flag_bad = (t['flag'] > 0.0) | (t['chi2'] > 20.0)
flag_ok = ~flag_bad
fit_l_obs = t['wl']
masked_wl = load_line_mask('data/starlight/Mask.mE', fit_l_obs)
class GridManager(object):
def __init__(self, starlight_dir, db, sample, galaxy_id, err_factor=None, blue_clip=None):
self.starlightDir = starlight_dir
self.galaxyId = galaxy_id
self.sample = sample
self._errFactor = err_factor
self._blueClip = blue_clip
self._dc = DecompContainer()
self._dc.loadHDF5(db, sample, galaxy_id)
self._gridTemplate, self._runTemplate = self._getTemplates()
self._createDirs()
def _getTemplates(self):
template_path = path.join(self.starlightDir, 'grid.template.in')
grid = GridFile.fromFile(self.starlightDir, template_path)
grid.setLogDir('log')
grid.fluxUnit = self._dc.attrs['flux_unit']
run = grid.runs.pop()
run.lumDistanceMpc = self._dc.attrs['distance_Mpc']
grid.clearRuns()
return grid, run
def _createDirs(self):
obs_dir = path.normpath(self._gridTemplate.obsDirAbs)
out_dir = path.normpath(self._gridTemplate.outDirAbs)
log_dir = path.normpath(self._gridTemplate.logDirAbs)
makedirs(obs_dir + '_bulge')
makedirs(obs_dir + '_disk')
makedirs(obs_dir + '_total')
makedirs(out_dir + '_bulge')
makedirs(out_dir + '_disk')
makedirs(out_dir + '_total')
makedirs(log_dir + '_bulge')
makedirs(log_dir + '_disk')
makedirs(log_dir + '_total')
def _getZoneSpectra(self, component):
comp = getattr(self._dc, component)
l_obs = comp.wl
f_obs, f_err, f_flag = comp.asZones(self._dc.zones)
f_obs = np.hstack((comp.i_f_obs[:, np.newaxis], f_obs))
if self._errFactor is None:
f_err = np.hstack((comp.i_f_err[:, np.newaxis], f_err))
else:
f_err = np.ones_like(f_obs) * (self._errFactor * f_obs.mean(axis=0))
f_flag = np.hstack((comp.i_f_flag[:, np.newaxis], f_flag))
if self._blueClip is not None:
f_flag[l_obs < self._blueClip] = True
return l_obs, f_obs, f_err, f_flag
def _getGrid(self, component, l_obs, f_obs, f_err, f_flag, zone1, zone2):
grid = self._gridTemplate.copy()
if zone1 != zone2:
grid.name = 'grid_%04d-%04d' % (zone1, zone2)
else:
grid.name = 'grid_%04d' % zone1
grid.setObsDir(grid.obsDir + '_%s' % component)
grid.setOutDir(grid.outDir + '_%s' % component)
grid.setLogDir(grid.logDir + '_%s' % component)
grid.randPhone = -958089828
# grid.seed()
for z in xrange(zone1, zone2):
print 'Creating inputs for %s, zone %d' % (component, z)
run = self._createRun(component, l_obs, f_obs, f_err, f_flag, z, grid.obsDirAbs)
if run is not None:
grid.runs.append(run)
else:
print 'Skipping zone %d of %s' % (z, component)
return grid
def _createRun(self, component, l_obs, f_obs, f_err, f_flag, z, obs_dir):
n_good = (f_flag == 0.0).sum()
if n_good <= 400:
return None
new_run = self._runTemplate.copy()
new_run.inFile = '%s_%04d_%s.%s.in' % (self.galaxyId, z, self.sample, component)
new_run.outFile = '%s_%04d_%s.%s.out' % (self.galaxyId, z, self.sample, component)
write_table(l_obs, f_obs[:, z], f_err[:, z], f_flag[:, z],
path.join(obs_dir, new_run.inFile))
return new_run
def gridIterator(self, chunk_size):
for component in ['bulge', 'disk', 'total']:
l_obs, f_obs, f_err, f_flag = self._getZoneSpectra(component)
N_zone = f_obs.shape[1]
print 'Component %s: %d zones in chunks of %d' % (component, N_zone, chunk_size)
for z in xrange(0, N_zone, chunk_size):
yield self._getGrid(component, l_obs, f_obs, f_err, f_flag, z, z + chunk_size)
def decomp(cube, sampleId, args):
galaxyId = califa_id_from_cube(cube)
c = DecompContainer()
if not args.overwrite:
logger.info('Checking if the decomposition is already done for %s ...' % galaxyId)
try:
c.loadHDF5(args.db, sampleId, galaxyId)
logger.warn('Previous data found, skipping decomposition.')
return c
except Exception as e:
print e
logger.info('No previous data found, continuing decomposition.')
logger.info('Starting fit for %s...' % galaxyId)
dec = CALIFADecomposer(cube, grating=args.grating, nproc=args.nproc)
npix = dec.K.qMask.sum()
dec.minNPix = npix / 2
logger.info('Minimum number of pixels for fitting: %d' % dec.minNPix)
dec.useEstimatedVariance = args.estVar
dec.setSynthPSF(FWHM=args.psfFWHM, beta=args.psfBeta, size=args.psfSize)
logger.warn('Computing initial model using DE algorithm (takes a LOT of time).')
t1 = time.time()
if not path.exists(args.maskFile):
logger.error('Mask file %s not found.' % args.maskFile)
exit(1)
logger.info('Using mask file %s.' % args.maskFile)
masked_wl = load_line_mask(args.maskFile, dec.wl)
l1 = find_nearest_index(dec.wl, 4500.0)
l2 = dec.Nl_obs
cache_file = cube + '.initmodel'
if not path.exists(cache_file):
logger.info('Creating gray image for initial model.')
gray_image, gray_noise, _ = dec.getSpectraSlice(l1, l2, masked_wl)
else:
gray_image = None
gray_noise = None
initial_model = bd_initial_model(gray_image, gray_noise, dec.PSF, quiet=False, nproc=args.nproc,
cache_model_file=cache_file)
logger.debug('Refined initial model:\n%s\n' % initial_model)
logger.warn('Initial model time: %.2f\n' % (time.time() - t1))
t1 = time.time()
c.zones = np.ma.array(dec.K.qZones, mask=dec.K.qZones < 0)
c.initialParams = initial_model.getParams()
c.attrs = dict(PSF_FWHM=args.psfFWHM,
PSF_beta=args.psfBeta,
PSF_size=args.psfSize,
box_step=args.boxStep,
box_radius=args.boxRadius,
orig_file=cube,
mask_file=args.maskFile,
object_name=dec.K.galaxyName,
flux_unit=dec.flux_unit,
distance_Mpc=dec.K.distance_Mpc,
x0=dec.K.x0,
y0=dec.K.y0,
target_vd=dec.targetVd,
wl_FWHM=dec.wlFWHM)
models = dec.fitSpectra(step=50*args.boxStep, box_radius=25*args.boxStep,
initial_model=initial_model, mode=args.fitAlgorithm, masked_wl=masked_wl)
c.firstPassParams = np.array([m.getParams() for m in models], dtype=models[0].dtype)
logger.info('Done first pass modeling, time: %.2f' % (time.time() - t1))
t1 = time.time()
logger.info('Smoothing parameters.')
models = smooth_models(models, dec.wl, degree=1)
logger.info('Starting second pass modeling...')
models = dec.fitSpectra(step=args.boxStep, box_radius=args.boxRadius,
initial_model=models, mode=args.fitAlgorithm, insist=False, masked_wl=masked_wl)
logger.info('Done second pass modeling, time: %.2f' % (time.time() - t1))
t1 = time.time()
logger.info('Computing model spectra...')
c.total.f_obs = dec.flux[::args.boxStep]
c.total.f_err = dec.error[::args.boxStep]
c.total.f_flag = dec.flags[::args.boxStep]
c.total.mask = dec.K.qMask
c.total.wl = dec.wl[::args.boxStep]
c.bulge.f_obs, c.disk.f_obs = dec.getModelSpectra(models, args.nproc)
c.bulge.mask = dec.K.qMask
c.bulge.wl = dec.wl[::args.boxStep]
c.disk.mask = dec.K.qMask
c.disk.wl = dec.wl[::args.boxStep]
# TODO: better array and dtype handling.
c.fitParams = np.array([m.getParams() for m in models], dtype=models[0].dtype)
flag_bad_fit = c.fitParams['flag'][:, np.newaxis, np.newaxis] > 0.0
c.updateErrorsFlags(flag_bad_fit)
c.updateIntegratedSpec()
logger.info('Saving qbick planes...')
fname = path.join(args.zoneFileDir, '%s_%s-planes.fits' % (galaxyId, sampleId))
save_qbick_images(c.total, dec, fname, overwrite=args.overwrite)
fname = path.join(args.zoneFileDir, '%s_%s-bulge-planes.fits' % (galaxyId, sampleId))
save_qbick_images(c.bulge, dec, fname, overwrite=args.overwrite)
fname = path.join(args.zoneFileDir, '%s_%s-disk-planes.fits' % (galaxyId, sampleId))
save_qbick_images(c.disk, dec, fname, overwrite=args.overwrite)
logger.info('Saving to storage...')
c.writeHDF5(args.db, sampleId, galaxyId, args.overwrite)
logger.info('Storage complete, time: %.2f' % (time.time() - t1))
return c
