def survey_overlaps(tiledata): """ Returns True for fibers that have MWS_ANY bit set in DESI_TARGET and other DESI_TARGET bits set. """ is_assigned = fibers_assigned(tiledata) # Define as having MWS_ANY and any bits other than MWS_ANY is_mws = (tiledata['DESI_TARGET'] & desi_mask.mask('MWS_ANY')) != 0 is_other = (tiledata['DESI_TARGET'] & ~desi_mask.mask('MWS_ANY')) != 0 return (is_assigned & is_mws & is_other)
def test_numobs(self): t = self.targets # - No target bits set is an error with self.assertRaises(ValueError): calc_numobs(t) # - ELGs and QSOs get one/four observations t['DESI_TARGET'] = desi_mask.ELG self.assertTrue(np.all(calc_numobs(t) == 1)) t['DESI_TARGET'] = desi_mask.QSO self.assertTrue(np.all(calc_numobs(t) == 4)) # ADM LRG NUMOBS is defined using per-pass target bits # ADM the desi_mask.LRG reference tests the default, which # ADM should correspond to 2 observations t['DESI_TARGET'] = [ desi_mask.LRG, desi_mask.LRG_1PASS, desi_mask.LRG_2PASS, desi_mask.LRG_1PASS, desi_mask.LRG_2PASS ] nobs = calc_numobs(t) self.assertTrue(np.all(nobs == [2, 1, 2, 1, 2])) # - test astropy Table t = Table(t) nobs = calc_numobs(t) self.assertTrue(np.all(nobs == [2, 1, 2, 1, 2])) # - this is true even if other targeting bits are set t['DESI_TARGET'] |= desi_mask.mask('ELG|BGS_ANY') nobs = calc_numobs(t) self.assertTrue(np.all(nobs == [2, 1, 2, 1, 2]))
def print_efficiency_stats(truth, mtl_initial, zcat): print('Overall efficiency') tmp_init = join(mtl_initial, truth, keys='TARGETID') total = join(zcat, tmp_init, keys='TARGETID') true_types = ['LRG', 'ELG', 'QSO'] zcat_types = ['GALAXY', 'GALAXY', 'QSO'] for true_type, zcat_type in zip(true_types, zcat_types): i_initial = ((tmp_init['DESI_TARGET'] & desi_mask.mask(true_type)) != 0) & (tmp_init['TRUESPECTYPE'] == zcat_type) i_final = ((total['DESI_TARGET'] & desi_mask.mask(true_type)) != 0) & (total['SPECTYPE'] == zcat_type) n_t = 1.0*len(total['TARGETID'][i_final]) n_i = 1.0*len(tmp_init['TARGETID'][i_initial]) print("\t {} fraction : {}".format(true_type, n_t/n_i)) #print("\t TRUE:ZCAT\n\t {}\n".format(Counter(zip(total['DESI_TARGET'], total['TYPE'])))) return
def global_eff(targets, id_avail, zcat, target_class='QSO', zcat_spectype='QSO', z_max=None, z_min=None): ii_avail = np.in1d(targets['TARGETID'], id_avail) targets_avail = targets[ii_avail] if z_max is None and z_min is None: sub_zcat = zcat.copy() elif (z_min is not None) or (z_max is not None): if z_max is not None: sub_zcat = zcat[zcat['Z'] < z_max] if z_min is not None: sub_zcat = zcat[zcat['Z'] > z_min] else: print("Error") sub_zcat = None # input target consistent with target_class is_class = (targets_avail['DESI_TARGET'] & desi_mask.mask(target_class)) != 0 targets_avail_class = targets_avail[is_class] n_avail = len(targets_avail_class) # output in the redshift catalog consistent with truth_spectype sub_zcat_class = sub_zcat[sub_zcat['SPECTYPE'] == zcat_spectype] # keep the elements in the zcat that correspond to the correct input target class id_intersection = np.in1d(sub_zcat_class['TARGETID'], targets_avail_class['TARGETID']) sub_zcat_class = sub_zcat_class[id_intersection] n_assigned = len(sub_zcat_class) nobs = dict() for i in range(10): nobs[i] = np.count_nonzero(sub_zcat_class['NUMOBS'] == i) nobs[0] = (n_avail - n_assigned) return { 'target_class': target_class, 'zcat_class': zcat_spectype, 'eff': n_assigned / n_avail, 'n_avail': n_avail, 'n_assign': n_assigned, 'n_obs': nobs }
def isStdStar(desi_target, bright=None): """ Determines if target(s) are standard stars Args: desi_target: int or array of DESI_TARGET targeting bit mask(s) Optional: bright: if True, only bright time standards; if False, only darktime, otherwise both Returns bool or array of bool TODO: move out of scripts/stdstars.py """ from desitarget.targetmask import desi_mask yes = (desi_target & desi_mask.STD_WD) != 0 if bright is None: yes |= (desi_target & desi_mask.mask('STD_WD|STD_FAINT|STD_BRIGHT')) != 0 elif bright: yes |= (desi_target & desi_mask.mask('STD_WD|STD_BRIGHT')) != 0 else: yes |= (desi_target & desi_mask.mask('STD_WD|STD_FAINT')) != 0 return yes
def write_initial_truth_file(initial_truth_file): import desitarget.mock.mockmaker as mb from desitarget.targetmask import desi_mask, bgs_mask, mws_mask pixweight_file = "/project/projectdirs/desi/target/catalogs/dr8/0.31.1/pixweight/pixweight-dr8-0.31.1.fits" is_lya_qso = assign_lya_qso(initial_mtl_file, pixweight_file) targets = Table.read(initial_mtl_file) colnames = list(targets.dtype.names) print(colnames) nobj = len(targets) truth = mb.empty_truth_table(nobj=nobj)[0] print(truth.keys()) for k in colnames: if k in truth.keys(): print(k) truth[k][:] = targets[k][:] nothing = ' ' truth['TEMPLATESUBTYPE'] = np.repeat(nothing, nobj) masks = ['MWS_ANY', 'BGS_ANY', 'STD_FAINT', 'STD_BRIGHT','ELG', 'LRG', 'QSO', ] dict_truespectype = {'BGS_ANY':'GALAXY', 'ELG':'GALAXY', 'LRG':'GALAXY', 'QSO':'QSO', 'MWS_ANY':'STAR', 'STD_FAINT':'STAR', 'STD_BRIGHT':'STAR'} dict_truetemplatetype = {'BGS_ANY':'BGS', 'ELG':'ELG', 'LRG':'LRG', 'QSO':'QSO', 'MWS_ANY':'STAR', 'STD_FAINT':'STAR', 'STD_BRIGHT':'STAR'} dict_truez = {'BGS_ANY':0.2, 'ELG':1.5, 'LRG':0.7, 'QSO':2.0, 'MWS_ANY':0.0, 'STD_FAINT':0.0, 'STD_BRIGHT':0.0} for m in masks: istype = (targets['DESI_TARGET'] & desi_mask.mask(m))!=0 print(m, np.count_nonzero(istype)) truth['TRUESPECTYPE'][istype] = np.repeat(dict_truespectype[m], np.count_nonzero(istype)) truth['TEMPLATETYPE'][istype] = np.repeat(dict_truetemplatetype[m], np.count_nonzero(istype)) truth['MOCKID'][istype] = targets['TARGETID'][istype] truth['TRUEZ'][istype] = dict_truez[m] truth['TRUEZ'][is_lya_qso] = 3.0 # Check that all targets have been assigned to a class iii = truth['MOCKID']==0 assert np.count_nonzero(iii)==0 print('writing truth') truth.write(initial_truth_file, overwrite=True) print('done truth')
def merge_results_tile(out_dtype, copy_fba, params): """Merge results for one tile. This uses target catalog data which has been pre-staged to shared memory. This function should not be called directly, but only from the merge_results() function. Args: out_dtype (np.dtype): The output recarray dtype for the merged target HDU. This is the union of columns chosen from the input catalogs. copy_fba (bool): If True, copy the original raw fiberassign HDUs onto the end of the output file. params (tuple): The tile ID and input / output files. Set by multiprocessing call. Returns: None. """ (tile_id, infile, outfile) = params log = Logger.get() log.info("Reading raw tile data {}".format(infile)) tm = Timer() tm.start() inhead, fiber_data, targets_data, avail_data, gfa_targets = \ read_assignment_fits_tile((tile_id, infile)) # tm.stop() # tm.report(" read input data {}".format(tile_id)) # tm.clear() # tm.start() # Get the list of all targets we are considering for this tile. This # will be either just the assigned targets or all available targets # depending on how the user wrote the file. tile_tgids = np.copy(targets_data["TARGETID"]) tile_tgindx = {y: x for x, y in enumerate(tile_tgids)} # Extract just these targets from the full set of catalogs tile_targets_dtype = np.dtype(out_dtype.fields) tile_targets = np.zeros(len(tile_tgids), dtype=tile_targets_dtype) # Copy original data for field in tile_targets_dtype.names: if field in results_targets_columns: tile_targets[field] = targets_data[field] # tm.stop() # tm.report(" index input targets {}".format(tile_id)) # tm.clear() # tm.start() # Loop over input target files and copy data. Note: these are guaranteed # to be sorted by TARGETID, since that is done during staging to shared # memory. targetfiles = list(merge_results_tile_tgbuffers.keys()) for tf in targetfiles: tgview = np.frombuffer(merge_results_tile_tgbuffers[tf], dtype=merge_results_tile_tgdtypes[tf])\ .reshape(merge_results_tile_tgshapes[tf]) # Some columns may not exist in all target files (e.g. PRIORITY), # So we select the valid columns for this file and only copy those. # The ordering of the targets in the catalog is not guaranteed to be # sorted, and the output table is sorted by fiber ID, not target. So # must build an explicit mapping from target catalog rows to output # table rows. tgids = tgview["TARGETID"] inrows = np.where(np.isin(tgids, tile_tgids, assume_unique=True))[0] outrows = np.where(np.isin(tile_tgids, tgids, assume_unique=True))[0] tfcolsin = list() tfcolsout = list() for c in tgview.dtype.names: nm = c if c in merged_fiberassign_swap: nm = merged_fiberassign_swap[c] if nm in out_dtype.names: tfcolsin.append(c) tfcolsout.append(nm) # tm.stop() # tm.report(" indexing {} for {}".format(tf, tile_id)) # tm.clear() # tm.start() if len(outrows) > 0: for irw, orw in zip(inrows, outrows): for c, nm in zip(tfcolsin, tfcolsout): tile_targets[nm][orw] = tgview[c][irw] del tgids del inrows del outrows del tgview # tm.stop() # tm.report(" copy targets from {} for {}".format(tf, tile_id)) # tm.clear() # tm.start() skytargetfiles = list(merge_results_tile_skybuffers.keys()) for tf in skytargetfiles: skyview = np.frombuffer(merge_results_tile_skybuffers[tf], dtype=merge_results_tile_skydtypes[tf])\ .reshape(merge_results_tile_skyshapes[tf]) # Some columns may not exist in all target files (e.g. PRIORITY), # So we select the valid columns for this file and only copy those. # The ordering of the targets in the catalog is not guaranteed to be # sorted, and the output table is sorted by fiber ID, not target. So # must build an explicit mapping from target catalog rows to output # table rows. skyids = skyview["TARGETID"] inrows = np.where(np.isin(skyids, tile_tgids, assume_unique=True))[0] outrows = np.where(np.isin(tile_tgids, skyids, assume_unique=True))[0] tfcolsin = list() tfcolsout = list() for c in skyview.dtype.names: nm = c if c in merged_fiberassign_swap: nm = merged_fiberassign_swap[c] if nm in out_dtype.names: tfcolsin.append(c) tfcolsout.append(nm) if len(outrows) > 0: for irw, orw in zip(inrows, outrows): for c, nm in zip(tfcolsin, tfcolsout): tile_targets[nm][orw] = skyview[c][irw] del skyids del inrows del outrows del skyview # Now we have a reduced set of target data including only the targets # relevant for this tile, and with data merged from all the files. # Next, merge this with the assignment information. # Determine the rows of the assignment that are for science and sky # monitor positioners. science_rows = np.where(fiber_data["DEVICE_TYPE"].astype(str) == "POS")[0] sky_rows = np.where(fiber_data["DEVICE_TYPE"].astype(str) == "ETC")[0] # Construct output recarray outdata = np.zeros(len(fiber_data), dtype=out_dtype) # Build mapping from FTARGETS rows (sorted by target) to FASSIGN rows # (sorted by fiber). # Rows containing assigned fibers fassign_valid = np.where(fiber_data["TARGETID"] >= 0)[0] # Rows in target tables containing assigned targets These indices are # valid for both the original input FTARGETS data and also our per-tile # copy of the target catalog data. These indices are essentially random # access into the target table. target_rows = np.array( [tile_tgindx[x] for x in fiber_data["TARGETID"][fassign_valid]]) # tm.stop() # tm.report(" fiber / target index mapping {}".format(tile_id)) # tm.clear() # tm.start() # Copy original data and also determine which of our required columns # will come from external catalogs external_cols = list() for field in out_dtype.names: if field in results_assign_columns: # Copy assignment and fiber property columns directly. outdata[field] = fiber_data[field] else: if field in results_targets_columns: # This is a column we are copying from our raw output. if (len(target_rows) > 0): outdata[field][fassign_valid] = \ targets_data[field][target_rows] else: # This required column is coming from external catalogs external_cols.append(field) # tm.stop() # tm.report(" copy raw data to output {}".format(tile_id)) # tm.clear() # tm.start() # Now copy external target properties for the remaining columns. if (len(target_rows) > 0): # # Looping over rows and then columns is faster, likely because there # # are so many columns and the data is stored row-major. # for irw, orw in zip(target_rows, fassign_valid): # for c in external_cols: # realname = c # if c in merged_fiberassign_swap: # realname = merged_fiberassign_swap[c] # outdata[realname][orw] = tile_targets[c][irw] for c in external_cols: if c == "OBJTYPE": # FIXME: This column is redundant to doing a simple bitwise # operation on the target bit field, and it is specific to # the main survey. Personally I believe it should be # removed completely. -TK objtype = np.zeros(len(fassign_valid), dtype="S3") if "DESI_TARGET" in out_dtype.names: # This is a main survey file. objtype[:] = "TGT" is_sky = (tile_targets["DESI_TARGET"][target_rows] & desi_mask.SKY) != 0 objtype[is_sky] = "SKY" badmask = \ desi_mask.mask("BAD_SKY|NO_TARGET|IN_BRIGHT_OBJECT") is_bad = (tile_targets["DESI_TARGET"][target_rows] & badmask) != 0 objtype[is_bad] = "BAD" else: # This is some other survey objtype = ["NA" for x in range(len(fassign_valid))] outdata[c][fassign_valid] = objtype else: outdata[c][fassign_valid] = tile_targets[c][target_rows] # Special check for REF_EPOCH which isn't in MTL yet ismoving = (outdata['PMRA'] != 0) | (outdata['PMDEC'] != 0) if np.all(outdata['REF_EPOCH'] == 0.0) and np.any(ismoving): log.error('REF_EPOCH not set, using 2015.5') outdata['REF_EPOCH'][ismoving] = 2015.5 # tm.stop() # tm.report(" copy external data to output {}".format(tile_id)) # tm.clear() # tm.start() cols_to_keep = list() for c in outdata.dtype.names: if len(outdata[c].shape ) < 2: #Don't propagate 2D target columns into FIBERASSIGN HDU cols_to_keep.append(c) outdata = outdata[cols_to_keep] cols_to_keep = list() for c in tile_targets.dtype.names: if len(tile_targets[c].shape ) < 2: #Don't propagate 2D target columns into TARGETS HDU cols_to_keep.append(c) tile_targets = tile_targets[cols_to_keep] # Create the file if os.path.isfile(outfile): os.remove(outfile) fd = fitsio.FITS(outfile, "rw") # Write a heaader-only primary HDU fd.write(None, header=inhead, extname="PRIMARY") # Write the main FIBERASSIGN HDU- only the data for science positioners # Enforce sorting by FIBER log.info("Writing new data {}".format(outfile)) ii = np.argsort(outdata['FIBER'][science_rows]) fd.write(outdata[science_rows][ii], header=inhead, extname="FIBERASSIGN") # Now write out the sky monitor fibers. We extract the rows and columns # from the already-computed recarray. skymon_dtype = np.dtype([(x, y) for x, y in merged_skymon_columns.items()]) skymon = np.zeros(len(sky_rows), dtype=skymon_dtype) # Sky monitor fake FIBER column with values 0-19. The fake FIBER value in # the raw data is already based on increasing LOCATION value. skymon_fiber = np.arange(len(sky_rows), dtype=np.int32) for field in skymon_dtype.names: if field == "FIBER": skymon["FIBER"] = skymon_fiber else: skymon[field] = outdata[field][sky_rows] fd.write(skymon, header=inhead, extname="SKY_MONITOR") # Copy GFA data if it exists if gfa_targets is not None: fd.write(gfa_targets, header=inhead, extname="GFA_TARGETS") # Write the per-tile catalog information also. Sadly, this HDU is # expected to have the original column names. We swap them back, which # is fine since we are going to delete this data after writing anyway. backswap = {y: x for x, y in merged_fiberassign_swap.items()} curnames = np.copy(tile_targets.dtype.names) newnames = list() for nm in curnames: if nm in backswap: newnames.append(backswap[nm]) else: newnames.append(nm) tile_targets.dtype.names = newnames fd.write(tile_targets, header=inhead, extname="TARGETS") del tile_targets # Write the "POTENTIAL_ASSIGNMENTS" HDU potential_dtype = np.dtype([(x, y) for x, y in merged_potential_columns.items()]) potential = np.zeros(len(avail_data), dtype=potential_dtype) locfiber = { x: y for x, y in zip(fiber_data["LOCATION"], fiber_data["FIBER"]) } potential["LOCATION"] = avail_data["LOCATION"] potential["TARGETID"] = avail_data["TARGETID"] potential["FIBER"] = [locfiber[x] for x in avail_data["LOCATION"]] fd.write(potential, header=inhead, extname="POTENTIAL_ASSIGNMENTS") # Now copy the original HDUs if copy_fba: fd.write(fiber_data, header=inhead, extname="FASSIGN") fd.write(targets_data, header=inhead, extname="FTARGETS") fd.write(avail_data, header=inhead, extname="FAVAIL") # Close the file fd.close() # tm.stop() # tm.report(" write data to file {}".format(tile_id)) # tm.clear() # tm.start() # Try to encourage python to free some memory... del fd del avail_data del targets_data del fiber_data return
def fa_plot(axarr, i, j, tids, fao_fibs, fao_tiles, tiles, targets, ttypes=['QSO'], notin=True, s=7): ''' Plot the distribution of assigned and unassigned targets for a list of tiles. Input: tids -- Tile IDs to plot. num -- Index of Tile to plot in tids. fao_fibs -- Loaded fiberassign fiber-* files. fao_tiles -- Loaded fiberassign tile-* files. tiles -- (Associated) Nominal tile info. targets -- instance of the targets class. ttypes -- Target types to plot ['ELG', 'LRG', 'QSO', 'BGS'] notin -- Add markers for unassigned (more busy). ''' colordict = {'ELG': 'b', 'LRG': 'r', 'QSO': 'orange', 'BGS': 'y'} tile_radius = 1.65 if isinstance(axarr, list) | isinstance(axarr, np.ndarray): ax = axarr[i,j] else: ax = axarr ## Plot boundaries of all in tids. for count, tid in enumerate(tids): tileloc = np.where(tiles['TILEID'].quantity == tid)[0][0] ra, dec = tiles['RA'][tileloc], tiles['DEC'][tileloc] c = plt.Circle((ra, dec), tile_radius, facecolor='None', edgecolor='k') ax.add_artist(c) ## Plot for main tile. tid = tids[i] fao_fib = fao_fibs[i] fao_tile = fao_tiles[i] tileloc = np.where(tiles['TILEID'].quantity == tid)[0][0] prog = tiles['PROGRAM'][tileloc] ## Centre plot on first tile in tids. ctileloc = np.where(tiles['TILEID'].quantity == tids[0])[0][0] tmp = fao_tile['TARGETID'] not_assigned = (~np.in1d(tmp, fao_fib['TARGETID'])) assigned = ( np.in1d(tmp, fao_fib['TARGETID'])) dsorted = np.argsort(targets['TARGETID']) ypos = np.searchsorted(targets['TARGETID'][dsorted], tmp) inds = np.zeros_like(ypos) inds[tmp <= np.max(targets['TARGETID'])] = dsorted[ypos[tmp <= np.max(targets['TARGETID'])]] for ttype in ttypes: ## Enforce BGS on bright. MWS? if prog == 'BRIGHT': ttype = 'BGS' istype = (targets[inds]['DESI_TARGET'] & desi_mask.mask(ttype) != 0) ax.scatter(targets[inds]['RA'][assigned & istype & (tmp <= np.max(targets['TARGETID']))], targets[inds]['DEC'][assigned & istype & (tmp <= np.max(targets['TARGETID']))], s=s, edgecolor="none", c=colordict[ttype], zorder=10, label=ttype) if notin: ax.scatter(targets[inds]['RA'][not_assigned & istype & (tmp <= np.max(targets['TARGETID']))], targets[inds]['DEC'][not_assigned & istype & (tmp <= np.max(targets['TARGETID']))], s=s, edgecolor="none", c=colordict[ttype], marker="x", zorder=10, label='Unassigned', alpha=0.6) ax.set_xlim(tiles['RA'][ctileloc] - tile_radius, tiles['RA'][ctileloc] + tile_radius) ax.set_ylim(tiles['DEC'][ctileloc] - tile_radius, tiles['DEC'][ctileloc] + tile_radius) ax.legend(frameon=False, title='TILE %d: %s' % (tid, prog), loc=1) ax.set_aspect('equal', 'datalim') ax.invert_xaxis()
def make_global_DR8_truth(global_DR8_mtl_file, output_path='./', program='dark'): import desitarget.mock.mockmaker as mb from desitarget.targetmask import desi_mask, bgs_mask, mws_mask os.makedirs(output_path, exist_ok=True) global_DR8_truth_file = os.path.join( output_path, 'global_DR8_truth_{}.fits'.format(program)) if os.path.exists(global_DR8_truth_file): print("File {} already exists".format(global_DR8_truth_file)) return global_DR8_truth_file print('Started reading file {}'.format(global_DR8_mtl_file)) targets = Table.read(global_DR8_mtl_file) print('Finished reading file {}'.format(global_DR8_mtl_file)) # Find what targets will be associated to lya targets is_lya_qso = random_assign_lya_qso(targets) # Initialized truth Table colnames = list(targets.dtype.names) print(colnames) nobj = len(targets) truth = mb.empty_truth_table(nobj=nobj)[0] print(truth.keys()) for k in colnames: if k in truth.keys(): print(k) truth[k][:] = targets[k][:] nothing = ' ' truth['TEMPLATESUBTYPE'] = np.repeat(nothing, nobj) masks = [ 'MWS_ANY', 'BGS_ANY', 'STD_FAINT', 'STD_BRIGHT', 'ELG', 'LRG', 'QSO', ] dict_truespectype = { 'BGS_ANY': 'GALAXY', 'ELG': 'GALAXY', 'LRG': 'GALAXY', 'QSO': 'QSO', 'MWS_ANY': 'STAR', 'STD_FAINT': 'STAR', 'STD_BRIGHT': 'STAR' } dict_truetemplatetype = { 'BGS_ANY': 'BGS', 'ELG': 'ELG', 'LRG': 'LRG', 'QSO': 'QSO', 'MWS_ANY': 'STAR', 'STD_FAINT': 'STAR', 'STD_BRIGHT': 'STAR' } dict_truez = { 'BGS_ANY': 0.2, 'ELG': 1.5, 'LRG': 0.7, 'QSO': 2.0, 'MWS_ANY': 0.0, 'STD_FAINT': 0.0, 'STD_BRIGHT': 0.0 } for m in masks: istype = (targets['DESI_TARGET'] & desi_mask.mask(m)) != 0 print(m, np.count_nonzero(istype)) truth['TRUESPECTYPE'][istype] = np.repeat(dict_truespectype[m], np.count_nonzero(istype)) truth['TEMPLATETYPE'][istype] = np.repeat(dict_truetemplatetype[m], np.count_nonzero(istype)) truth['MOCKID'][istype] = targets['TARGETID'][istype] truth['TRUEZ'][istype] = dict_truez[m] truth['TRUEZ'][is_lya_qso] = 3.0 truth['RA'] = targets['RA'] truth['DEC'] = targets['DEC'] # Check that all targets have been assigned to a class iii = truth['MOCKID'] == 0 assert np.count_nonzero(iii) == 0 del targets print('Started writing to file {}'.format(global_DR8_truth_file)) truth.write(global_DR8_truth_file, overwrite=True) print('Finished writing to file {}'.format(global_DR8_truth_file)) del truth return global_DR8_truth_file
def setUpClass(cls): cls.ntiles = 4 tiles = desimodel.io.load_tiles() cls.tileids = tiles['TILEID'][0:cls.ntiles] cls.tilefiles = ['tile-{:05d}.fits'.format(i) for i in cls.tileids] cls.tilefiles_multiobs = [ 'multitile-{:05d}.fits'.format(i) for i in cls.tileids ] cls.nspec = n = 1000 targets = Table() targets['TARGETID'] = np.random.randint(0, 2**60, size=n) targets['DESI_TARGET'] = 2**np.random.randint(0, 3, size=n) targets['BGS_TARGET'] = np.zeros(n, dtype=int) targets['MWS_TARGET'] = np.zeros(n, dtype=int) isLRG = (targets['DESI_TARGET'] & desi_mask.LRG) != 0 isELG = (targets['DESI_TARGET'] & desi_mask.ELG) != 0 isQSO = (targets['DESI_TARGET'] & desi_mask.QSO) != 0 cls.targets = targets #- Make a few of them BGS and MWS iibright = np.random.choice(np.arange(n), size=6, replace=False) isBGS = iibright[0:3] isMWS = iibright[3:6] targets['DESI_TARGET'][isBGS] = desi_mask.BGS_ANY targets['BGS_TARGET'][isBGS] = bgs_mask.BGS_BRIGHT targets['DESI_TARGET'][isMWS] = desi_mask.MWS_ANY targets['MWS_TARGET'][isMWS] = mws_mask.MWS_MAIN #- Add some fake photometry; no attempt to get colors right flux = np.zeros((n, 6)) #- ugrizY; DESI has grz flux[isLRG, 1] = np.random.uniform(0, 1.0, np.count_nonzero(isLRG)) flux[isLRG, 2] = np.random.uniform(0, 5.0, np.count_nonzero(isLRG)) flux[isLRG, 4] = np.random.uniform(0, 5.0, np.count_nonzero(isLRG)) flux[isELG, 1] = np.random.uniform(0, 4.0, np.count_nonzero(isELG)) flux[isELG, 2] = np.random.uniform(0, 4.0, np.count_nonzero(isELG)) flux[isELG, 4] = np.random.uniform(0, 10.0, np.count_nonzero(isELG)) flux[isQSO, 1] = np.random.uniform(0, 4.0, np.count_nonzero(isQSO)) flux[isQSO, 2] = np.random.uniform(0, 4.0, np.count_nonzero(isQSO)) flux[isQSO, 4] = np.random.uniform(0, 6.0, np.count_nonzero(isQSO)) flux[isBGS, 1] = np.random.uniform(10, 600, np.count_nonzero(isBGS)) flux[isBGS, 2] = np.random.uniform(15, 1000, np.count_nonzero(isBGS)) flux[isBGS, 4] = np.random.uniform(10, 1400, np.count_nonzero(isBGS)) flux[isMWS, 1] = np.random.uniform(10, 150, np.count_nonzero(isMWS)) flux[isMWS, 2] = np.random.uniform(15, 350, np.count_nonzero(isMWS)) flux[isMWS, 4] = np.random.uniform(10, 1500, np.count_nonzero(isMWS)) targets['DECAM_FLUX'] = flux truth = Table() truth['TARGETID'] = targets['TARGETID'] truth['TRUEZ'] = np.random.uniform(0, 1.5, size=n) truth['TRUESPECTYPE'] = np.zeros(n, dtype=(str, 10)) truth['GMAG'] = np.random.uniform(18.0, 24.0, size=n) ii = (targets['DESI_TARGET'] & desi_mask.mask('LRG|ELG|BGS_ANY')) != 0 truth['TRUESPECTYPE'][ii] = 'GALAXY' ii = (targets['DESI_TARGET'] == desi_mask.QSO) truth['TRUESPECTYPE'][ii] = 'QSO' starmask = desi_mask.mask('MWS_ANY|STD_FSTAR|STD_WD|STD_BRIGHT') ii = (targets['DESI_TARGET'] & starmask) != 0 truth['TRUESPECTYPE'][ii] = 'STAR' #- Add some fake [OII] fluxes for the ELGs; include some that will fail isELG = (targets['DESI_TARGET'] & desi_mask.ELG) != 0 nELG = np.count_nonzero(isELG) truth['OIIFLUX'] = np.zeros(n, dtype=float) truth['OIIFLUX'][isELG] = np.random.normal(2e-17, 2e-17, size=nELG).clip(0) cls.truth = truth fiberassign = truth['TARGETID', ] fiberassign['RA'] = np.random.uniform(0, 5, size=n) fiberassign['DEC'] = np.random.uniform(0, 5, size=n) fiberassign.meta['EXTNAME'] = 'FIBER_ASSIGNMENTS' nx = cls.nspec // cls.ntiles cls.targets_in_tile = dict() for i, filename in enumerate(cls.tilefiles): subset = fiberassign[i * nx:(i + 1) * nx] subset.write(filename) cls.targets_in_tile[cls.tileids[i]] = subset['TARGETID'] hdulist = fits.open(filename, mode='update') hdr = hdulist[1].header hdr.set('TILEID', cls.tileids[i]) hdulist.close() #- Also create a test of tile files that have multiple observations nx = cls.nspec // cls.ntiles for i, filename in enumerate(cls.tilefiles_multiobs): subset = fiberassign[0:(i + 1) * nx] subset.write(filename) hdulist = fits.open(filename, mode='update') hdr = hdulist[1].header hdr.set('TILEID', cls.tileids[i]) hdulist.close()
dict_truespectype = { 'BGS_ANY': 'GALAXY', 'ELG': 'GALAXY', 'LRG': 'GALAXY', 'QSO': 'QSO', 'STD': 'STAR' } dict_truetemplatetype = { 'BGS_ANY': 'BGS', 'ELG': 'ELG', 'LRG': 'LRG', 'QSO': 'QSO', 'STD': 'STAR' } masks = { 'BGS_ANY': desi_mask.mask('BGS_ANY'), 'ELG': desi_mask.mask('ELG'), 'LRG': desi_mask.mask('LRG'), 'QSO': desi_mask.mask('QSO'), 'STD': std_mask } for m in masks.keys(): istype = (targets['DESI_TARGET'] & masks[m]) != 0 print(np.count_nonzero(istype)) truth['TRUESPECTYPE'][istype] = np.repeat(dict_truespectype[m], np.count_nonzero(istype)) truth['TEMPLATETYPE'][istype] = np.repeat(dict_truetemplatetype[m], np.count_nonzero(istype)) truth['MOCKID'][istype] = targets['TARGETID'][istype]
def setUpClass(cls): cls.ntiles = 4 tiles = desimodel.io.load_tiles() cls.tileids = tiles['TILEID'][0:cls.ntiles] cls.tilefiles = ['tile-{:05d}.fits'.format(i) for i in cls.tileids] cls.tilefiles_multiobs = ['multitile-{:05d}.fits'.format(i) for i in cls.tileids] cls.nspec = n = 1000 targets = Table() targets['TARGETID'] = np.random.randint(0,2**60, size=n) targets['DESI_TARGET'] = 2**np.random.randint(0,3,size=n) targets['BGS_TARGET'] = np.zeros(n, dtype=int) targets['MWS_TARGET'] = np.zeros(n, dtype=int) isLRG = (targets['DESI_TARGET'] & desi_mask.LRG) != 0 isELG = (targets['DESI_TARGET'] & desi_mask.ELG) != 0 isQSO = (targets['DESI_TARGET'] & desi_mask.QSO) != 0 cls.targets = targets #- Make a few of them BGS and MWS iibright = np.random.choice(np.arange(n), size=6, replace=False) isBGS = iibright[0:3] isMWS = iibright[3:6] targets['DESI_TARGET'][isBGS] = desi_mask.BGS_ANY targets['BGS_TARGET'][isBGS] = bgs_mask.BGS_BRIGHT targets['DESI_TARGET'][isMWS] = desi_mask.MWS_ANY try: #- desitarget >= 0.25.0 targets['MWS_TARGET'][isMWS] = mws_mask.MWS_BROAD except AttributeError: #- desitarget <= 0.24.0 targets['MWS_TARGET'][isMWS] = mws_mask.MWS_MAIN #- Add some fake photometry; no attempt to get colors right flux = np.zeros((n, 6)) #- ugrizY; DESI has grz flux[isLRG, 1] = np.random.uniform(0, 1.0, np.count_nonzero(isLRG)) flux[isLRG, 2] = np.random.uniform(0, 5.0, np.count_nonzero(isLRG)) flux[isLRG, 4] = np.random.uniform(0, 5.0, np.count_nonzero(isLRG)) flux[isELG, 1] = np.random.uniform(0, 4.0, np.count_nonzero(isELG)) flux[isELG, 2] = np.random.uniform(0, 4.0, np.count_nonzero(isELG)) flux[isELG, 4] = np.random.uniform(0, 10.0, np.count_nonzero(isELG)) flux[isQSO, 1] = np.random.uniform(0, 4.0, np.count_nonzero(isQSO)) flux[isQSO, 2] = np.random.uniform(0, 4.0, np.count_nonzero(isQSO)) flux[isQSO, 4] = np.random.uniform(0, 6.0, np.count_nonzero(isQSO)) # isBGS and isMWS are arrays of indices, not arrays of booleans flux[isBGS, 1] = np.random.uniform(10, 600, isBGS.size) flux[isBGS, 2] = np.random.uniform(15, 1000, isBGS.size) flux[isBGS, 4] = np.random.uniform(10, 1400, isBGS.size) flux[isMWS, 1] = np.random.uniform(10, 150, isMWS.size) flux[isMWS, 2] = np.random.uniform(15, 350, isMWS.size) flux[isMWS, 4] = np.random.uniform(10, 1500, isMWS.size) targets['DECAM_FLUX'] = flux truth = Table() truth['TARGETID'] = targets['TARGETID'] truth['TRUEZ'] = np.random.uniform(0, 1.5, size=n) truth['TRUESPECTYPE'] = np.zeros(n, dtype=(str, 10)) truth['GMAG'] = np.random.uniform(18.0, 24.0, size=n) ii = (targets['DESI_TARGET'] & desi_mask.mask('LRG|ELG|BGS_ANY')) != 0 truth['TRUESPECTYPE'][ii] = 'GALAXY' ii = (targets['DESI_TARGET'] == desi_mask.QSO) truth['TRUESPECTYPE'][ii] = 'QSO' starmask = desi_mask.mask('MWS_ANY|STD_FAINT|STD_WD|STD_BRIGHT') ii = (targets['DESI_TARGET'] & starmask) != 0 truth['TRUESPECTYPE'][ii] = 'STAR' #- Add some fake [OII] fluxes for the ELGs; include some that will fail isELG = (targets['DESI_TARGET'] & desi_mask.ELG) != 0 nELG = np.count_nonzero(isELG) truth['OIIFLUX'] = np.zeros(n, dtype=float) truth['OIIFLUX'][isELG] = np.random.normal(2e-17, 2e-17, size=nELG).clip(0) cls.truth = truth fiberassign = truth['TARGETID',] fiberassign['RA'] = np.random.uniform(0,5, size=n) fiberassign['DEC'] = np.random.uniform(0,5, size=n) fiberassign.meta['EXTNAME'] = 'FIBERASSIGN' nx = cls.nspec // cls.ntiles cls.targets_in_tile = dict() for i, filename in enumerate(cls.tilefiles): subset = fiberassign[i*nx:(i+1)*nx] subset.write(filename) cls.targets_in_tile[cls.tileids[i]] = subset['TARGETID'] hdulist = fits.open(filename, mode='update') hdr = hdulist[1].header hdr.set('TILEID', cls.tileids[i]) hdulist.close() #- Also create a test of tile files that have multiple observations nx = cls.nspec // cls.ntiles for i, filename in enumerate(cls.tilefiles_multiobs): subset = fiberassign[0:(i+1)*nx] subset.write(filename) hdulist = fits.open(filename, mode='update') hdr = hdulist[1].header hdr.set('TILEID', cls.tileids[i]) hdulist.close()
if __name__ == '__main__': compute = True ext = '_chi2' ## '_r_z' dchi2 = [-2.5, -2.0, -1.5, -1.0, -0.5, 0.0] snrs = [3., 4., 6., 9., 12., 20.] if compute: targets = glob.glob('/project/projectdirs/desi/target/catalogs/dr8/0.32.0/targets/main/resolve/dark/*.fits') ## elgs = Table(fits.open(targets[0])[1].data) elgs = Table([fits.open(targets[0])[1].data[x] for x in cols], names=cols) elgs = elgs[(elgs['DESI_TARGET'] & desi_mask.mask('ELG')) != 0] ## S/N should be prior to extinction correction. elgs['GSNR'] = np.sqrt(elgs['FLUX_IVAR_G']) * elgs['FLUX_G'] ## elgs['MW_TRANSMISSION_G'] elgs['RSNR'] = np.sqrt(elgs['FLUX_IVAR_R']) * elgs['FLUX_R'] ## elgs['MW_TRANSMISSION_R'] elgs['ZSNR'] = np.sqrt(elgs['FLUX_IVAR_Z']) * elgs['FLUX_Z'] ## elgs['MW_TRANSMISSION_Z'] ## elgs['RZSNR'] = np.sqrt(elgs['RSNR'] ** 2. + elgs['ZSNR'] ** 2.) elgs['SNR'] = np.sqrt(elgs['GSNR'] ** 2. + elgs['RSNR'] ** 2. + elgs['ZSNR'] ** 2.) elgs['BFIT'] = np.array([np.array(x).max() for x in elgs['DCHISQ']]) elgs['BFIT2'] = np.array([np.sort(np.array(x))[:-1].max() for x in elgs['DCHISQ']]) elgs['CHI2DIFF'] = np.clip(np.log10(elgs['BFIT'] - elgs['BFIT2']), a_min=-6., a_max=None)
if k in truth.keys(): print(k) truth[k][:] = targets[k][:] nothing = ' ' truth['TEMPLATESUBTYPE'] = np.repeat(nothing, nobj) masks = ['BGS_ANY', 'ELG', 'LRG', 'QSO', 'STD_FSTAR', 'STD_BRIGHT'] dict_truespectype = {'BGS_ANY':'GALAXY', 'ELG':'GALAXY', 'LRG':'GALAXY', 'QSO':'QSO', 'STD_FSTAR':'STAR', 'STD_BRIGHT':'STAR'} dict_truetemplatetype = {'BGS_ANY':'BGS', 'ELG':'ELG', 'LRG':'LRG', 'QSO':'QSO', 'STD_FSTAR':'STAR', 'STD_BRIGHT':'STAR'} for m in masks: istype = (targets['DESI_TARGET'] & desi_mask.mask(m))!=0 print(m, np.count_nonzero(istype)) truth['TRUESPECTYPE'][istype] = np.repeat(dict_truespectype[m], np.count_nonzero(istype)) truth['TEMPLATETYPE'][istype] = np.repeat(dict_truetemplatetype[m], np.count_nonzero(istype)) truth['MOCKID'][istype] = targets['TARGETID'][istype] n_unassigned = np.count_nonzero(truth['MOCKID']==0) print('unassigned', n_unassigned) mtl = desitarget.mtl.make_mtl(targets) mtl.meta['EXTNAME'] = 'MTL' isstd = (targets['DESI_TARGET'] & desi_mask.mask('STD_BRIGHT'))!=0 isstd |= (targets['DESI_TARGET'] & desi_mask.mask('STD_FSTAR'))!=0 print('standards', np.count_nonzero(isstd)) standards = mtl[isstd]
from astropy.table import Table from desitarget.targetmask import desi_mask, bgs_mask, mws_mask import numpy as np import os main_path = "/global/cscratch1/sd/forero/DR5FiberAssign/" main_path = "/Users/forero/github/SandboxDESI/decals/" truth = Table.read(os.path.join(main_path, 'targets', 'truth.fits')) mtl = Table.read(os.path.join(main_path, 'targets', 'mtl.fits')) zcat = Table.read(os.path.join(main_path, 'zcat', 'zcat.fits')) isbgs = (mtl['DESI_TARGET'] & desi_mask.mask('BGS_ANY')) != 0 islrg = (mtl['DESI_TARGET'] & desi_mask.mask('LRG')) != 0 n_in = np.count_nonzero(isbgs|islrg) print('total number of points in {}'.format(n_in)) print('initializing small truth') small_truth = mtl[['TARGETID','RA','DEC']][isbgs|islrg] small_truth['TEMPLATETYPE'] = truth['TEMPLATETYPE'][isbgs|islrg] small_truth['NUMOBS'] = np.zeros(n_in, dtype=int) print('making small zcat') ii = np.in1d(zcat['TARGETID'], small_truth['TARGETID']) small_zcat = zcat['TARGETID', 'NUMOBS'][ii] print('checking integrity') ii = np.in1d(small_truth['TARGETID'], small_zcat['TARGETID']) if not (small_truth['TARGETID'][ii] == small_zcat['TARGETID']).all(): print('We have problems with the IDs')
from astropy.table import Table from desitarget.targetmask import desi_mask, bgs_mask, mws_mask import numpy as np mtl = Table.read('mtl.fits') zcat = Table.read("zcat.fits") print("Efficiencies N_in N_out N_in/N_out") for objtype in ['BGS_ANY', 'ELG', 'LRG', 'QSO', 'STD_FSTAR', 'STD_BRIGHT']: ii = (mtl['DESI_TARGET'] & desi_mask.mask(objtype)) != 0 jj = np.in1d(mtl['TARGETID'][ii], zcat['TARGETID']) n_in = np.count_nonzero(ii) n_out = np.count_nonzero(jj) print('{:10} {} {} {:.2f}'.format(objtype, n_in, n_out, n_out/n_in))
if k in truth.keys(): print(k) truth[k][:] = targetdata[k][:] nothing = ' ' truth['TEMPLATESUBTYPE'] = np.repeat(nothing, nobj) masks = ['BGS_ANY', 'ELG', 'LRG', 'QSO', 'STD_FSTAR', 'STD_BRIGHT'] dict_truespectype = {'BGS_ANY':'GALAXY', 'ELG':'GALAXY', 'LRG':'GALAXY', 'QSO':'QSO', 'STD_FSTAR':'STAR', 'STD_BRIGHT':'STAR', 'STD':'STAR'} dict_truetemplatetype = {'BGS_ANY':'BGS', 'ELG':'ELG', 'LRG':'LRG', 'QSO':'QSO', 'STD_FSTAR':'STAR', 'STD_BRIGHT':'STAR', 'STD':'STAR'} for m in masks: if m in desi_mask.names(): istype = (targetdata['DESI_TARGET'] & desi_mask.mask(m))!=0 print(m, np.count_nonzero(istype)) truth['TRUESPECTYPE'][istype] = np.repeat(dict_truespectype[m], np.count_nonzero(istype)) truth['TEMPLATETYPE'][istype] = np.repeat(dict_truetemplatetype[m], np.count_nonzero(istype)) truth['MOCKID'][istype] = targetdata['TARGETID'][istype] print('writing truth') truth.write(truthfile, overwrite=True) print('done truth') # Running quicksurvey cmd = "quicksurvey -T {}".format(datadir) cmd += " -f fiberassign " cmd += " -E /global/project/projectdirs/desi/datachallenge/surveysim2017/baseline_1m/exposures.fits" cmd += " -D fiberassign_dates_baseline_1m.txt" print(cmd)
def parse_assign(optlist=None): """Parse assignment options. This parses either sys.argv or a list of strings passed in. If passing an option list, you can create that more easily using the :func:`option_list` function. Args: optlist (list, optional): Optional list of arguments to parse instead of using sys.argv. Returns: (namespace): an ArgumentParser namespace. """ log = Logger.get() parser = argparse.ArgumentParser() parser.add_argument("--targets", type=str, required=True, nargs="+", help="Input file with targets of any type. This " "argument can be specified multiple times (for " "example if standards / skies / science targets are " "in different files). By default, the " "'--mask_column' (default DESI_TARGET)" "column and bitfield values defined in desitarget " "are used to determine the type of each target. " "Each filename may be optionally followed by comma " "and then one of the strings 'science', 'standard', " "'sky' or 'safe' to force all targets in that file " "to be treated as a fixed target type.") parser.add_argument("--sky", type=str, required=False, nargs="+", help="Input file with sky or 'bad sky' targets. " "This option exists in order to treat main-survey" " sky target files as valid for other survey types." " If you are running a main survey assignment, you" " can just pass the sky file to the --targets list.") parser.add_argument("--gfafile", type=str, required=False, default=None, help="Optional GFA targets FITS file") parser.add_argument("--footprint", type=str, required=False, default=None, help="Optional FITS file defining the footprint. If" " not specified, the default footprint from desimodel" " is used.") parser.add_argument("--tiles", type=str, required=False, default=None, help="Optional text file containing a subset of the" " tile IDs to use in the footprint, one ID per line." " Default uses all tiles in the footprint.") parser.add_argument("--positioners", type=str, required=False, default=None, help="Optional FITS file describing the fiber " "positioner locations. Default uses the file from " "desimodel.") parser.add_argument("--status", type=str, required=False, default=None, help="Optional fiber status file in astropy ECSV " "format. Default treats all fibers as good.") parser.add_argument("--rundate", type=str, required=False, default=None, help="Optional date to simulate for this run of " "fiber assignment, used with the fiber status file " "to determine which fibers currently have problems. " "Default uses the current date. Format is " "YYYY-MM-DDTHH:mm:ss in UTC time.") parser.add_argument("--dir", type=str, required=False, default=None, help="Output directory.") parser.add_argument("--prefix", type=str, required=False, default="fiberassign_", help="Prefix of each file (before the <tile>.fits).") parser.add_argument("--split", required=False, default=False, action="store_true", help="Split output into tile prefix directories.") parser.add_argument("--standards_per_petal", type=int, required=False, default=10, help="Required number of standards per" " petal") parser.add_argument("--sky_per_petal", type=int, required=False, default=40, help="Required number of sky targets per" " petal") parser.add_argument("--write_all_targets", required=False, default=False, action="store_true", help="When writing target properties, write data " "for all available targets, not just those which are " "assigned. This is convenient, but increases the " "write time and the file size.") parser.add_argument("--overwrite", required=False, default=False, action="store_true", help="Overwrite any pre-existing output files") parser.add_argument("--mask_column", required=False, default=None, help="FITS column to use for applying target " "masks") parser.add_argument("--sciencemask", required=False, default=None, help="Default DESI_TARGET mask to use for science " "targets") parser.add_argument("--stdmask", required=False, default=None, help="Default DESI_TARGET mask to use for stdstar " "targets") parser.add_argument("--skymask", required=False, default=None, help="Default DESI_TARGET mask to use for sky targets") parser.add_argument("--safemask", required=False, default=None, help="Default DESI_TARGET mask to use for safe " "backup targets") parser.add_argument("--excludemask", required=False, default=None, help="Default DESI_TARGET mask to exclude from " "any assignments") parser.add_argument("--by_tile", required=False, default=False, action="store_true", help="Do assignment one tile at a time. This disables" " redistribution.") args = None if optlist is None: args = parser.parse_args() else: args = parser.parse_args(optlist) if args.sky is None: args.sky = list() # FIXME: The code below is only valid for the main survey. However, # determining the survey type from the first target file requires # reading it, which is expensive. Do we really need to support strings # like this? # Allow sciencemask, stdmask, etc. to be int or string if (args.sciencemask is not None) and isinstance(args.sciencemask, str): args.sciencemask = desi_mask.mask(args.sciencemask.replace(",", "|")) if (args.stdmask is not None) and isinstance(args.stdmask, str): args.stdmask = desi_mask.mask(args.stdmask.replace(",", "|")) if (args.skymask is not None) and isinstance(args.skymask, str): args.skymask = desi_mask.mask(args.skymask.replace(",", "|")) if (args.safemask is not None) and isinstance(args.safemask, str): args.safemask = desi_mask.mask(args.safemask.replace(",", "|")) if (args.excludemask is not None) and isinstance(args.excludemask, str): args.excludemask = desi_mask.mask(args.excludemask.replace(",", "|")) # Set output directory if args.dir is None: if args.rundate is None: raise RuntimeError( "You must specify the output directory or the rundate") args.dir = "out_fiberassign_{}".format(args.rundate) return args
'LRG': 'GALAXY', 'QSO': 'QSO', 'STD_FSTAR': 'STAR', 'STD_BRIGHT': 'STAR' } dict_truetemplatetype = { 'BGS_ANY': 'BGS', 'ELG': 'ELG', 'LRG': 'LRG', 'QSO': 'QSO', 'STD_FSTAR': 'STAR', 'STD_BRIGHT': 'STAR' } for m in masks: istype = (targets['DESI_TARGET'] & desi_mask.mask(m)) != 0 print(m, np.count_nonzero(istype)) truth['TRUESPECTYPE'][istype] = np.repeat(dict_truespectype[m], np.count_nonzero(istype)) truth['TEMPLATETYPE'][istype] = np.repeat(dict_truetemplatetype[m], np.count_nonzero(istype)) truth['MOCKID'][istype] = targets['TARGETID'][istype] del targets print('writing truth') truth.write(truthfile, overwrite=True) print('done truth') #generate sky data from desitarget.mock.sky import random_sky from desitarget.targetmask import desi_mask, bgs_mask, mws_mask, obsmask, obsconditions
print('Unable to retrieve {}.'.format(fname)) continue ## dat = Table( _fits[1].data ) ## ['FIBER', 'DESI_TARGET', 'BGS_TARGET', 'SV1_DESI_TARGET', 'SV1_BGS_TARGET'] ## print(dat.columns) if applyto == 'assign': ## Remove skies. isin = np.ones(len(dat), dtype=bool) for x in ds_dtypes: isin = isin & ((dat['DESI_TARGET'] & desi_mask.mask(x)) == 0) skies = dat[~isin] dat = dat[isin] ## dat.sort('FIBER') ## ttypes = ['faint', 'bright', 'faint_ext', 'lowq', 'fibmag'] dat['GFLUX'] = dat['FLUX_G'] / dat['MW_TRANSMISSION_G'] dat['RFLUX'] = dat['FLUX_R'] / dat['MW_TRANSMISSION_R'] dat['ZFLUX'] = dat['FLUX_Z'] / dat['MW_TRANSMISSION_Z'] dat['RFFLUX'] = dat['FIBERFLUX_R'] / dat['MW_TRANSMISSION_R']