def test3(): comm_map = MPI.COMM_WORLD for obs, tod in ((obs1,tod1), (obs2,tod2)): masking = MaskOperator(tod.mask) proj = obs.get_projection_operator(downsampling=True, npixels_per_sample=6, header=header_ref_global, commin=comm_map) model = masking * proj m = mapper_rls(tod, model, tol=tol, maxiter=maxiter, solver=solver, hyper=hyper) yield check_map_local, m
def pipeline_rls(filenames, output_file, keywords, verbose=False): """ Perform regularized least-square inversion of a simple model (tod mask and projection). Processing steps are as follows : - define PacsObservation instance - get Time Ordered Data (get_tod) - define projection - perform inversion on model - save file Arguments --------- filenames: list of strings List of data filenames. output_file : string Name of the output fits file. keywords: dict Dictionary containing options for all steps as dictionary. verbose: boolean (default False) Set verbosity. Returns ------- Returns nothing. Save result as a fits file. """ from scipy.sparse.linalg import cgs import tamasis as tm # verbosity keywords["mapper_rls"]["verbose"] = verbose # define observation obs_keys = keywords.get("PacsObservation", {}) obs = tm.PacsObservation(filenames, **obs_keys) # get data tod_keys = keywords.get("get_tod", {}) tod = obs.get_tod(**tod_keys) # define projector proj_keys = keywords.get("Projection", {}) projection = tm.Projection(obs, **proj_keys) # define mask masking_tod = tm.Masking(tod.mask) # define full model model = masking_tod * projection # perform map-making inversion mapper_keys = keywords.get("mapper_rls", {}) map_rls = tm.mapper_rls(tod, model, solver=cgs, **mapper_keys) # save map_rls.save(output_file)
def test1(): comm_map = MPI.COMM_SELF for obs, tod in ((obs1, tod1), (obs2, tod2)): masking = MaskOperator(tod.mask) proj = obs.get_projection_operator(downsampling=True, npixels_per_sample=6, header=header_ref_global, commin=comm_map) model = masking * proj m = mapper_rls(tod, model, tol=tol, maxiter=maxiter, solver=solver, hyper=hyper) yield check_map_global, m
obs.pointing.chop[:] = 0 tod = obs.get_tod(subtraction_mean=True) projection = obs.get_projection_operator(resolution=3.2, downsampling=True, npixels_per_sample=6) masking_tod = MaskOperator(tod.mask) model = masking_tod * projection # iterative map, taking all map pixels class Callback(): def __init__(self): self.niterations = 0 def __call__(self, x): self.niterations += 1 map_rls = mapper_rls(tod, model, hyper=1., tol=1.e-4, profile=profile, callback=None if tamasis.var.verbose else Callback(), solver=cgs) if profile is None: print 'Elapsed time: ' + str(map_rls.header['TIME']) def test(): assert map_rls.header['NITER'] < 49 ref = Map(data_dir + 'frames_blue_map_rls_cgs_tol1e-6.fits') ref.derived_units = map_rls.derived_units cov = ref.coverage > 80 assert all_eq(ref[cov], map_rls[cov], 1.e-1) cov = ref.coverage > 125 assert all_eq(ref[cov], map_rls[cov], 1.e-2)
def pipeline_wrls(filenames, output_file, keywords, verbose=False): """ Perform regularized least-square inversion of state of the art PACS model. The PACS model includes tod mask, compression, response, projection and noise covariance (invntt). Processing steps are as follows : - define PacsObservation instance - mask first scanlines to avoid drift - get Time Ordered Data (get_tod) - 2nd level deglitching (with standard projector and tod median filtering with a narrow window) - median filtering - define projection - perform inversion on model - save file Arguments --------- filenames: list of strings List of data filenames. output_file : string Name of the output fits file. keywords: dict Dictionary containing options for all steps as dictionary. verbose: boolean (default False) Set verbosity. Returns ------- Returns nothing. Save result as a fits file. """ from scipy.sparse.linalg import cgs import tamasis as tm # verbosity keywords["mapper_rls"]["verbose"] = verbose # define observation obs = tm.PacsObservation(filenames, **keywords["PacsObservation"]) # extra masking tm.step_scanline_masking(obs, **keywords["scanline_masking"]) # get data tod = obs.get_tod(**keywords["get_tod"]) # deglitching tm.step_deglitching(obs, tod, **keywords["deglitching"]) # median filtering tod = tm.filter_median(tod, **keywords["filter_median"]) # define projector projection = tm.Projection(obs, **keywords["Projection"]) # build instrument model response = tm.ResponseTruncatedExponential(obs.pack( obs.instrument.detector.time_constant) / obs.SAMPLING_PERIOD) compression = tm.CompressionAverage(obs.slice.compression_factor) masking = tm.Masking(tod.mask) model = masking * compression * response * projection # set tod masked values to zero tod = masking(tod) # N^-1 operator invntt = tm.InvNtt(obs) # perform map-making inversion map_rls = tm.mapper_rls(tod, model, invntt=invntt, solver=cgs, **keywords["mapper_rls"]) # save map_rls.save(output_file)
def pipeline_wrls(filenames, output_file, keywords, verbose=False): """ Perform regularized least-square inversion of state of the art PACS model. The PACS model includes tod mask, compression, response, projection and noise covariance (invntt). Processing steps are as follows : - define PacsObservation instance - mask first scanlines to avoid drift - get Time Ordered Data (get_tod) - 2nd level deglitching (with standard projector and tod median filtering with a narrow window) - median filtering - define projection - perform inversion on model - save file Arguments --------- filenames: list of strings List of data filenames. output_file : string Name of the output fits file. keywords: dict Dictionary containing options for all steps as dictionary. verbose: boolean (default False) Set verbosity. Returns ------- Returns nothing. Save result as a fits file. """ from scipy.sparse.linalg import cgs import tamasis as tm # verbosity keywords["mapper_rls"]["verbose"] = verbose # define observation obs = tm.PacsObservation(filenames, **keywords["PacsObservation"]) # extra masking tm.step_scanline_masking(obs, **keywords["scanline_masking"]) # get data tod = obs.get_tod(**keywords["get_tod"]) # deglitching tm.step_deglitching(obs, tod, **keywords["deglitching"]) # median filtering tod = tm.filter_median(tod, **keywords["filter_median"]) # define projector projection = obs.get_projection_operator(**keywords["Projection"]) # build instrument model response = tm.ResponseTruncatedExponentialOperator( obs.pack(obs.instrument.detector.time_constant) / obs.instrument.SAMPLING_PERIOD) compression = tm.CompressionAverageOperator(obs.slice.compression_factor) masking = tm.MaskOperator(tod.mask) model = masking * compression * response * projection # set tod masked values to zero tod = masking(tod) # N^-1 operator invntt = tm.InvNttOperator(obs) # perform map-making inversion map_rls = tm.mapper_rls(tod, model, invntt=invntt, solver=cgs, **keywords["mapper_rls"]) # save map_rls.save(output_file)
tamasis.var.verbose = True profile = None#'test_rls.png' data_dir = os.path.dirname(__file__) + '/data/' # reference map (no communication) header_ref_global = create_fitsheader((97,108), cdelt=3.2/3600, crval=(245.998427916727,61.5147650744551)) comm_tod = MPI.COMM_SELF comm_map = MPI.COMM_SELF obs_ref = PacsObservation(data_dir + 'frames_blue.fits', comm=comm_tod) obs_ref.pointing.chop = 0 tod_ref = obs_ref.get_tod() model_ref = MaskOperator(tod_ref.mask) * obs_ref.get_projection_operator( downsampling=True, npixels_per_sample=6, commin=comm_map, header=header_ref_global) map_ref_global = mapper_rls(tod_ref, model_ref, tol=tol, maxiter=maxiter, solver=solver, hyper=hyper) header_ref_global = map_ref_global.header cov_ref_global = map_ref_global.coverage mask_ref_global = map_ref_global.coverage == 0 tolocal = MPIDistributionGlobalOperator(map_ref_global.shape, attrin={'header':header_ref_global}) map_ref_local = tolocal(map_ref_global) cov_ref_local = tolocal(map_ref_global.coverage) mask_ref_local = tolocal(mask_ref_global) if rank == 0: map_ref_global.save('map_ref_global_v4.fits', comm=MPI.COMM_SELF) def check_map_global(m): assert_all_eq(m.magnitude, map_ref_global.magnitude, mtol) assert_all_eq(m.coverage, cov_ref_global, mtol)
# reference map (no communication) header_ref_global = create_fitsheader( (97, 108), cdelt=3.2 / 3600, crval=(245.998427916727, 61.5147650744551)) comm_tod = MPI.COMM_SELF comm_map = MPI.COMM_SELF obs_ref = PacsObservation(data_dir + 'frames_blue.fits', comm=comm_tod) obs_ref.pointing.chop = 0 tod_ref = obs_ref.get_tod() model_ref = MaskOperator(tod_ref.mask) * obs_ref.get_projection_operator( downsampling=True, npixels_per_sample=6, commin=comm_map, header=header_ref_global) map_ref_global = mapper_rls(tod_ref, model_ref, tol=tol, maxiter=maxiter, solver=solver, hyper=hyper) header_ref_global = map_ref_global.header cov_ref_global = map_ref_global.coverage mask_ref_global = map_ref_global.coverage == 0 tolocal = MPIDistributionGlobalOperator(map_ref_global.shape, attrin={'header': header_ref_global}) map_ref_local = tolocal(map_ref_global) cov_ref_local = tolocal(map_ref_global.coverage) mask_ref_local = tolocal(mask_ref_global) if rank == 0: map_ref_global.save('map_ref_global_v4.fits', comm=MPI.COMM_SELF)
model = masking_tod * projection # iterative map, taking all map pixels class Callback(): def __init__(self): self.niterations = 0 def __call__(self, x): self.niterations += 1 map_rls = mapper_rls(tod, model, hyper=1., tol=1.e-4, profile=profile, callback=None if tamasis.var.verbose else Callback(), solver=cgs) if profile is None: print 'Elapsed time: ' + str(map_rls.header['TIME']) def test(): assert map_rls.header['NITER'] < 49 ref = Map(data_dir + 'frames_blue_map_rls_cgs_tol1e-6.fits') ref.derived_units = map_rls.derived_units cov = ref.coverage > 80 assert all_eq(ref[cov], map_rls[cov], 1.e-1) cov = ref.coverage > 125