def centroid_loop(channel, cw=5.0, cs=1.0, write_log=True, filter_turnarounds=3, filter_dipole=True, add_dipole = True, az_filter=True, scan_cut_adu=5., scan_cut_net=1.5, mce_filter=True, group=1, sim=False, add_noise=True, net=170., pol=False): """ Creates a specified number of spider maps for a specified channel. Each map has a specified centroid offset. Can also produce simulated equaivalent. Arguments --------- channel : string Channel name in the mux representation. cw : float, optional Range of azimuth and elevation centroid offsets in arcminutes. Default: 5.0 cs : float, optional Size of steps dividing up the range specified by cw. Default: 1.0 write_log : bool, optional Provide debugging info in log file. Default: True filter_turnarounds: bool or int, optional If int, apply a polynomial filter of this order between turnarounds. If True, apply the default filter of order 1. Default: False filter_dipole : bool, optional If True, include a dipole template in the fit. Default: True add_dipole : bool Set to True if simulated data should include dipole Can also modify the add_dipole attribute after construction. Default: True az_filter : bool, optional If True, filter in the az spatial domain. If 'False', the filtering will be done in the time domain. Default: True. scan_cut_adu : float, optional Noise level (ADU) above which the entire region between turnarounds is flagged. The noise is estimated as the stdev of the unflagged samples within the scan, after detrending. The more stringent of scan_cut_adu and scan_cut_net is applied. Non-positive values (or None) disables the cut. Default: 5. scan_cut_net : float, optional Noise level relative to channel NET above which the entire region between turnarounds is flagged. The noise is estimated as the stdev of the unflagged samples within the scan, after detrending. The more stringent of scan_cut_adu and scan_cut_net is applied. Non-positive values (or None) disables the cut. Default: 1.5. mce_filter : bool, optional Applies the MCE filter to the simulated data. This uses the default MCE filter params. Default: False. group : int, optional Number of channels to process at once. If MPI is enabled, channels are grouped by the number of available OMP threads per MPI process. Otherewise, if not supplied, then all channels are loaded into memory serially. Default: 1. sim : bool, optional if True: only generate rescanned Planck maps (sims) instead of SPIDER maps. Default: False. add_noise : bool, optional Set to True if simulated data should include white noise. Default: True. net : float or string, optional Noise equivalent temperature in uK*rt(s). Used for simulating white noise. Either the value to use or a bolotable name. Default: 170. pol : bool, optional If True, output maps are polarized. Will break current code. Will perhaps be implemented later on. Default: False. """ t0 = time.time() # Optional string for saving results. if sim: estr = '_sim' else: estr = '' # Initalising logging. bdir = base_dir+ana_dir logging.basicConfig(filename=bdir+'logs/'+channel+'.log',level=logging.DEBUG) # Initialising directory. dir_to_use = bdir+'maps/'+channel+'/' if not os.path.exists(dir_to_use): os.makedirs(dir_to_use) # Initiate map object and calibration. M = _sa.UnifileMap(default_latest=True, pol=pol) M.bolotable M.update_cal(table='cal_hfi_04') M.init_point(reset=True,ctime=True,event=event) # Initiate Simulation object. S = _sa.UnifileSim( default_latest=True, verbose=False, add_dipole=add_dipole, add_white_noise=add_noise, net=net, interp_pix=False, mce_filter=mce_filter) # Reading in the source map for S. if sim: f = int(channel[1]) if _np.mod(f,2) == 1: pname = 'hfi_143_2048_equatorial_28arcmin.fits' else: pname = 'hfi_100_2048_equatorial_41arcmin.fits' source_coord = 'C' source_map = _sam.read_map(pmap_dir+pname) S.init_source(source_map,pol=pol,coord=source_coord) # Copying M's pointing pointers into S's pointing pointers. M.copy_point(S) # Check if there is good calibration for this channel. C = _sa.base.BoloTable('cal_hfi_04') c = C[channel]['cal'] print 'cal is %5.2f' %c if _np.isnan(c): print 'Calibration is nan, trying to see if arbitrary value works' logging.info('calibration is nan for channel'+str(channel)) M.update_cal(cal=-1000.0,channels=channel) scan_cut_adu = None scan_cut_net = None filter_dipole = False # Map making parameters. init_dict = {'nside':256,'coord':'C','pol':False,'reset':True} # Define centroid offsets. centroid_range = _np.arange(-cw, cw + cs, cs) # Creating maps. t1 = time.time() logging.info('Initiating map, {:5.3f} '.format(t1-t0)) try: az_off, el_off = M.get_offsets(channels=channel,pol=False) for eli, el in enumerate(centroid_range): for azi, az in enumerate(centroid_range): n = _ot.azel2n(eli, azi, len(centroid_range)) print channel, n logging.info('Az ({:d}) = {:5.3f} arcmin'.format(n,az)) logging.info('El ({:d}) = {:5.3f} arcmin'.format(n,el)) t2 = time.time() if sim: S.update_offsets(channels=channel, az=az_off+az*1./60, el=el_off+el*1./60) S.reset_dest() vec, proj = S.init_dest(**init_dict) sopts = S.hwp_partition(event=event) else: M.update_offsets(channels=channel, az=az_off+az*1./60, el=el_off+el*1./60) M.reset_dest() vec, proj = M.init_dest(**init_dict) sopts = M.hwp_partition(event=event) t3 = time.time() logging.info('Updating pointing ({:d}):'.format(n) + \ '{:5.3f}'.format(t3-t2)) logging.info('Before:' + channel + ':n = {:d}, '.format(n)+ 'ctime = {:d}'.format(int(time.time()))) # Populating map. if sim: for sopt in sopts: vec, proj = S.from_tod( channel, filter_turnarounds = filter_turnarounds, filter_dipole = filter_dipole, scan_cut_adu = scan_cut_adu, scan_cut_net = scan_cut_net, group=group, az_filter=az_filter, **sopt) else: for sopt in sopts: vec, proj = M.from_tod( channel, filter_turnarounds = filter_turnarounds, filter_dipole = filter_dipole, scan_cut_adu = scan_cut_adu, scan_cut_net = scan_cut_net, group=group, az_filter=az_filter, **sopt) t4 = time.time() logging.info('After:' + channel + ':n = {:d}, delta_t = {:5.2f} sec'.format( n,t4-t3)+', ctime = {:d}'.format(int(time.time()))) # Create the map and writing it to disk. map_real = _ot.maps2map(vec, proj) hits = _np.copy(proj) hits[hits == 0] = _hp.UNSEEN logging.info('Writing to disk') logging.info(dir_to_use+'map'+str(n)+'.fits') _sam.write_map(dir_to_use+'map'+str(n)+estr+'.fits', map_real, partial = True) _sam.write_map(dir_to_use+'hits'+str(n)+estr+'.fits', hits, partial = True) t5 = time.time() logging.info('Parsing and writing map ({:d}):'.format(n) + \ '{:5.3f}'.format(t5-t4)) except Exception,e: print str(e) print e.message print 'unable to make map for '+channel return -1
def nominal_loop(channel, filter_turnarounds=3, filter_dipole=True, add_dipole=True, az_filter=True, scan_cut_adu=5., scan_cut_net=1.5, mce_filter=True, group=1): """ Creates a rescanned planck map with nominal centroids Arguments --------- channel : string Channel name in the mux representation. filter_turnarounds: bool or int, optional If int, apply a polynomial filter of this order between turnarounds. If True, apply the default filter of order 1. Default: False filter_dipole : bool, optional If True, include a dipole template in the fit. Default: True add_dipole : bool Set to True if simulated data should include dipole Can also modify the add_dipole attribute after construction. Default: True az_filter : bool, optional If True, filter in the az spatial domain. If 'False', the filtering will be done in the time domain. Default: True. scan_cut_adu : float, optional Noise level (ADU) above which the entire region between turnarounds is flagged. The noise is estimated as the stdev of the unflagged samples within the scan, after detrending. The more stringent of scan_cut_adu and scan_cut_net is applied. Non-positive values (or None) disables the cut. Default: 5. scan_cut_net : float, optional Noise level relative to channel NET above which the entire region between turnarounds is flagged. The noise is estimated as the stdev of the unflagged samples within the scan, after detrending. The more stringent of scan_cut_adu and scan_cut_net is applied. Non-positive values (or None) disables the cut. Default: 1.5. mce_filter : bool, optional Applies the MCE filter to the simulated data. This uses the default MCE filter params. Default: False. group : int, optional Number of channels to process at once. If MPI is enabled, channels are grouped by the number of available OMP threads per MPI process. Otherewise, if not supplied, then all channels are loaded into memory serially. Default: 1. """ # Path to directory. bdir = base_dir+ana_dir mdir = bdir+'maps/' f = int(channel[1]) logging.basicConfig(filename=bdir+'logs/'+channel+'.log',level=logging.DEBUG) logging.info('Initiating UnifileSim object') if _np.mod(f,2) == 1: pname = 'hfi_143_2048_equatorial_28arcmin.fits' else: pname = 'hfi_100_2048_equatorial_41arcmin.fits' source_coord = 'C' source_map = _sam.read_map(pmap_dir+pname) # Initialising sim object. S = _sa.UnifileSim(default_latest=True, verbose=False, add_dipole=add_dipole, add_from_map=True, add_white_noise=False, source_map=source_map, pol=False, source_coord=source_coord, interp_pix=True, mce_filter=mce_filter) S.bolotable S.update_cal(table='cal_hfi_04') # Check if there is good calibration for this channel. C = _sa.base.BoloTable('cal_hfi_04') c = C[channel]['cal'] print 'cal is %5.2f' %c if _np.isnan(c): print 'Calibration is nan, trying to see if arbitrary value works' logging.info('calibration is nan for channel'+str(channel)) S.update_cal(cal=-1000.0,channels=channel) scan_cut_adu = None scan_cut_net = None filter_dipole = False logging.info('Initialized UnifileSim object') # Region dependent plotting cuts. init_dict = {'nside':256,'coord':'C','pol':False,'reset':True} if 'rcw38' in event: region = 'rcw38'; minm = -1000; maxm = 5000 else: region = 'cmb'; minm = -400; maxm = 400 S.init_point(region=region, reset=True, ctime=True) simvec, simproj = S.init_dest(**init_dict) sopts = S.hwp_partition(event=event) # Populating map. try: for sopt in sopts: simvec, simproj = S.from_tod( channel, filter_turnarounds=filter_turnarounds, filter_dipole=filter_dipole, scan_cut_adu = scan_cut_adu, scan_cut_net = scan_cut_net, group=group, az_filter=az_filter, **sopt) # Creating map. planck_map = _ot.maps2map(simvec, simproj) hits_map = simproj.copy() hits_map[hits_map == 0] = _hp.UNSEEN apo_map = _at.gen_apomask(hits_map) # Writing to disk. if not os.path.exists(mdir+channel+'/'): os.makedirs(mdir+channel+'/') _sam.write_map(mdir+channel+'/'+'map_nominal.fits', planck_map, partial = True) _sam.write_map(mdir+channel+'/'+'hits_nominal.fits', hits_map, partial = True) _sam.write_map(mdir+channel+'/'+'apo_nominal.fits', apo_map, partial = True) except Exception,e: print str(e) print 'unable to make map for '+channel return -1