def get_e2iphi_mat(self, cache_only=False): """ Built such that it should hit the pbs barrier only if the matrix is not already cached. """ fname = self.lib_dir + '/e2iphimat.npy' if os.path.exists(fname): return None if cache_only else np.load(fname, mmap_mode='r') if not os.path.exists(fname) and pbs.rank == 0: print 'ell_mat:caching e2iphi in ', fname np.save(fname, np.exp(2j * np.arctan2(self.get_ky_mat(), self.get_kx_mat()))) pbs.barrier() return None if cache_only else np.load(fname, mmap_mode='r')
def get_sim_qumap(self, idx): if self.cache_sims and not os.path.exists(self.lib_dir + '/sim_qumap_%05d.npy' % idx): if pbs.rank == 0: np.save(self.lib_dir + '/sim_qumap_%05d.npy' % idx, np.array(self._build_sim_qumap(idx))) pbs.barrier() if self.cache_sims: return np.load(self.lib_dir + '/sim_qumap_%05d.npy' % idx, mmap_mode='r') else: return self._build_sim_qumap(idx)
def get_ellmat(self, ellmax=None): """ Returns the matrix containing the multipole ell assigned to k = (kx,ky) """ if ellmax is None: return np.load(self.lib_dir + '/ellmat.npy', mmap_mode='r') else: fname = self.lib_dir + '/ellmat_ellmax%s.npy' % ellmax if os.path.exists(fname): return np.load(fname, mmap_mode='r') if pbs.rank == 0: print 'ell_mat:caching ells in ', fname np.save(fname, self.get_ellmat()[np.where(self.get_ellmat() <= ellmax)]) pbs.barrier() return np.load(fname, mmap_mode='r')
def __init__(self, lib_dir, lib_datalm, lib_lencmb, cl_transf, TQUcovfname, pix_pha=None, cache_sims=True): """ Library for sims with pixel to pixel independent noise with specified noise variance maps. :param lib_dir: :param lib_datalm: ffs_alm library for the data maps. :param lib_lencmb: library of lensed cmb sims :param cl_transf: transfer function cl (identical for T Q U) :param TQUcov: (npix,npix,3,3) shaped array, TQU covariance matrix :param pix_pha: random for phases for the noise maps :param cache_sims: does cache ims on disk if set """ assert np.load(TQUcovfname).shape == (3, 3, lib_datalm.shape[0], lib_datalm.shape[1]) self.lencmbs = lib_lencmb self.lib_datalm = lib_datalm self.lib_skyalm = lib_lencmb.lib_skyalm self.cl_transf = np.zeros(self.lib_skyalm.ellmax + 1, dtype=float, order='C') self.cl_transf[:min(len(self.cl_transf), len(cl_transf))] = cl_transf[:min(len(self.cl_transf), len(cl_transf))] self.lib_dir = lib_dir self.cache_sims = cache_sims self.TQUcovfname = TQUcovfname if not os.path.exists(lib_dir) and pbs.rank == 0: os.makedirs(lib_dir) pbs.barrier() if pix_pha is None: self.pix_pha = ffs_phas.pix_lib_phas(lib_dir + '/pix_pha', 3, lib_datalm.shape) else: self.pix_pha = pix_pha assert pix_pha.shape == self.lib_datalm.shape, (pix_pha.shape, self.lib_datalm.shape) assert pix_pha.nfields == 3, (pix_pha.nfields, 3) if (np.array([not os.path.exists(lib_dir + '/rmat%s.npy' % a) for a in ['TT', 'TQ', 'TU', 'QQ', 'QU', 'UU']]).any()) and pbs.rank == 0: # FIXME : triangularise this TQUcov = np.load(TQUcovfname) rmat = np.zeros((3, 3, self.lib_datalm.shape[0], self.lib_datalm.shape[1]), dtype=float) for _i, i in misc.misc_utils.enumerate_progress(range(self.lib_datalm.shape[0]), 'building root matrix'): for j in range(self.lib_datalm.shape[1]): t, v = np.linalg.eigh(TQUcov[:, :, i, j], UPLO='U') assert np.all(t >= 0.), (i, j, t) # Matrix not positive semidefinite rmat[:, :, i, j] = np.dot(v, np.dot(np.diag(np.sqrt(t)), v.T)) for (i, j), lab in zip([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (2, 2)], ['TT', 'TQ', 'TU', 'QQ', 'QU', 'UU']): _sav = rmat[i, j, :, :] np.save(lib_dir + '/rmat%s.npy' % lab, _sav if _sav.any() else np.array([0.])) if not os.path.exists(lib_dir + '/sim_hash.pk') and pbs.rank == 0: pk.dump(self.hashdict(), open(lib_dir + '/sim_hash.pk', 'w')) pbs.barrier() hash_check(self.hashdict(), pk.load(open(lib_dir + '/sim_hash.pk', 'r')))
def __init__(self, lib_dir, get_state_func=np.random.get_state, nsims_max=None): if not os.path.exists(lib_dir) and pbs.rank == 0: os.makedirs(lib_dir) self.nmax = nsims_max if pbs.rank == 0 and not os.path.exists(lib_dir + '/sim_hash.pk'): pk.dump(self.hashdict(), open(lib_dir + '/sim_hash.pk', 'w')) pbs.barrier() hash = pk.load(open(lib_dir + '/sim_hash.pk', 'r')) hash_check(hash, self.hashdict(), ignore=['lib_dir']) self._rng_db = rng_db(lib_dir + '/rngdb.db', idtype='INTEGER') self._get_rng_state = get_state_func
def __init__(self, fname, idtype="INTEGER"): if not os.path.exists(fname) and pbs.rank == 0: con = sqlite3.connect(fname, detect_types=sqlite3.PARSE_DECLTYPES, timeout=3600) cur = con.cursor() cur.execute( "create table rngdb (id %s PRIMARY KEY, " "type STRING, pos INTEGER, has_gauss INTEGER,cached_gaussian REAL, keys array)" % idtype) con.commit() pbs.barrier() self.con = sqlite3.connect(fname, timeout=3600., detect_types=sqlite3.PARSE_DECLTYPES)
def __init__(self, sims_cmb_len, cl_ttransf, cl_ptransf, nside=2048, lib_dir=None): self.sims_cmb_len = sims_cmb_len self.cl_ttransf = cl_ttransf self.cl_ptransf = cl_ptransf self.nside = nside if lib_dir is not None: if pbs.rank == 0 and not os.path.exists(lib_dir + '/sim_hash.pk'): pk.dump(self.hashdict(), open(lib_dir + '/sim_hash.pk', 'w')) pbs.barrier() sims_generic.hash_check( self.hashdict(), pk.load(open(lib_dir + '/sim_hash.pk', 'r')))
def get_phasemat(self, ellmax=None): """ Returns the matrix containing the phase k = 'k' e^i phi """ if ellmax is None: fname = self.lib_dir + '/phasemat.npy' if os.path.exists(fname): return np.load(fname, mmap_mode='r') if not os.path.exists(fname) and pbs.rank == 0: print 'ell_mat:caching phases in ', fname np.save(fname, np.arctan2(self.get_ky_mat(), self.get_kx_mat())) pbs.barrier() return np.load(fname, mmap_mode='r') else: fname = self.lib_dir + '/phase_ellmax%s.npy' % ellmax if not os.path.exists(fname) and pbs.rank == 0: print 'ell_mat:caching phases in ', fname np.save(fname, np.arctan2(self.get_ky_mat(), self.get_kx_mat())[np.where(self.get_ellmat() <= ellmax)]) pbs.barrier() return np.load(fname, mmap_mode='r')
def __init__(self, lib_dir, lib_datalm, lib_lencmb, cl_transf, cache_sims=False): self.lencmbs = lib_lencmb self.lib_datalm = lib_datalm self.lib_skyalm = lib_lencmb.lib_skyalm self.cl_transf = np.zeros(self.lib_skyalm.ellmax + 1, dtype=float) self.cl_transf[:min(len(self.cl_transf), len(cl_transf))] = cl_transf[:min(len(self.cl_transf), len(cl_transf))] self.lib_dir = lib_dir self.cache_sims = cache_sims if self.cache_sims : assert lib_dir is not None if not os.path.exists(lib_dir) and pbs.rank == 0: os.makedirs(lib_dir) pbs.barrier() if not os.path.exists(lib_dir + '/sim_hash.pk') and pbs.rank == 0: pk.dump(self.hashdict(), open(lib_dir + '/sim_hash.pk', 'w')) pbs.barrier() hash_check(self.hashdict(), pk.load(open(lib_dir + '/sim_hash.pk', 'r')))
def __init__(self, ellmat, filt_func=lambda ell: ell > 0, num_threads=4, flags_init=('FFTW_MEASURE', )): super(ffs_alm_pyFFTW, self).__init__(ellmat, filt_func=filt_func) # FIXME : This can be tricky in in hybrid MPI-OPENMP # Builds FFTW Wisdom : wisdom_fname = self.ell_mat.lib_dir + '/FFTW_wisdom_%s_%s.npy' % ( num_threads, ''.join(flags_init)) if not os.path.exists(wisdom_fname): print "++ ffs_alm_pyFFTW :: building and caching FFTW wisdom, this might take a little while..." if pbs.rank == 0: inpt = pyfftw.empty_aligned(self.ell_mat.shape, dtype='float64') oupt = pyfftw.empty_aligned(self.ell_mat.rshape, dtype='complex128') fft = pyfftw.FFTW(inpt, oupt, axes=(0, 1), direction='FFTW_FORWARD', flags=flags_init, threads=num_threads) ifft = pyfftw.FFTW(oupt, inpt, axes=(0, 1), direction='FFTW_BACKWARD', flags=flags_init, threads=num_threads) wisdom = pyfftw.export_wisdom() np.save(wisdom_fname, wisdom) del inpt, oupt, fft, ifft pbs.barrier() pyfftw.import_wisdom(np.load(wisdom_fname)) # print "++ ffs_alm_pyFFTW :: loaded widsom ", wisdom_fname self.flags = ( 'FFTW_WISDOM_ONLY', ) # This will make the code crash if arrays are not properly aligned. # self.flags = ('FFTW_MEASURE',) self.threads = num_threads
def __init__(self, lib_dir, lib_skyalm, cls_unl, lib_pha=None, use_Pool=0, cache_lens=False): if not os.path.exists(lib_dir) and pbs.rank == 0: os.makedirs(lib_dir) pbs.barrier() self.lib_skyalm = lib_skyalm fields = get_fields(cls_unl) if lib_pha is None and pbs.rank == 0: lib_pha = fs.sims.ffs_phas.ffs_lib_phas(lib_dir + '/phas', len(fields), lib_skyalm) else: # Check that the lib_alms are compatible : assert lib_pha.lib_alm == lib_skyalm pbs.barrier() self.unlcmbs = sim_cmb_unl(cls_unl, lib_pha) self.Pool = use_Pool self.cache_lens = cache_lens if not os.path.exists(lib_dir + '/sim_hash.pk') and pbs.rank == 0: pk.dump(self.hashdict(), open(lib_dir + '/sim_hash.pk', 'w')) pbs.barrier() fs.sims.sims_generic.hash_check( self.hashdict(), pk.load(open(lib_dir + '/sim_hash.pk', 'r'))) self.lib_dir = lib_dir self.fields = fields
def __init__(self, lib_dir, lmax, cls_unl, dlmax=1024, nside_lens=2048, lib_pha=None): #FIXME : add aberration and modulation if not os.path.exists(lib_dir) and pbs.rank == 0: os.makedirs(lib_dir) pbs.barrier() self.lmax = lmax self.dlmax = dlmax fields = get_fields(cls_unl) assert 'o' not in fields, 'Check lenscurv.py if everything is implemented. Should be easy.' if lib_pha is None and pbs.rank == 0: lib_pha = phas.lib_phas(lib_dir + '/phas', len(fields), lmax + dlmax) else: # Check that the lib_alms are compatible : assert lib_pha.lmax == lmax + dlmax pbs.barrier() self.nside_lens = nside_lens self.unlcmbs = sims_cmb_unl(cls_unl, lib_pha) self.lib_dir = lib_dir self.fields = get_fields(cls_unl) if pbs.rank == 0 and not os.path.exists(lib_dir + '/sim_hash.pk'): pk.dump(self.hashdict(), open(lib_dir + '/sim_hash.pk', 'w')) pbs.barrier() sims_generic.hash_check(self.hashdict(), pk.load(open(lib_dir + '/sim_hash.pk', 'r')))
def build_pha(self, iter): """ Sets up sim libraries for the MF evaluation :param iter: :return: """ if self.nsims == 0: return None phas_pix = fs.sims.ffs_phas.pix_lib_phas( self.lib_dir + '/%s_sky_noise_iter%s' % (self.type, iter * (not self.same_seeds)), len(self.type), self.cov.lib_datalm.shape, nsims_max=self.nsims) phas_cmb = None # dont need it so far if self.PBSRANK == 0: for lib, lab in zip([phas_pix, phas_cmb], ['phas pix', 'phas_cmb']): if not lib is None and not lib.is_full(): print "++ run iterator regenerating %s phases mf_sims rank %s..." % ( lab, self.PBSRANK) for idx in np.arange(self.nsims): lib.get_sim(idx, phas_only=True) pbs.barrier() return phas_pix, phas_cmb
def __init__(self, lib_dir, lib_alm, cls_len, cl_transf, cls_noise): self.lib_alm = lib_alm self.cls_len = cls_len self.cls_noise = cls_noise self.cl_transf = np.zeros(self.lib_alm.ellmax + 1, dtype=float) self.cl_transf[:min(len(self.cl_transf), len(cl_transf))] = cl_transf[:min(len(self.cl_transf), len(cl_transf))] self.lib_dir = lib_dir if not os.path.exists(lib_dir) and pbs.rank == 0: os.makedirs(lib_dir) pbs.barrier() if not os.path.exists(lib_dir + '/Pmats') and pbs.rank == 0: os.makedirs(lib_dir + '/Pmats') pbs.barrier() if not os.path.exists(lib_dir + '/MFMC_hash.pk') and pbs.rank == 0: pk.dump(self.hashdict(), open(lib_dir + '/MFMC_hash.pk', 'w')) pbs.barrier() fs.sims.sims_generic.hash_check(self.hashdict(), pk.load(open(lib_dir + '/MFMC_hash.pk', 'r')))
def __init__(self, lib_dir, type, cov, dat_maps, lib_qlm, Plm0, H0, cpp_prior, use_Pool_lens=0, use_Pool_inverse=0, chain_descr=None, opfilt=None, soltn0=None, no_deglensing=False, NR_method=100, tidy=10, verbose=True, maxcgiter=150, PBSSIZE=None, PBSRANK=None, **kwargs): """ Normalisation of gradients etc are now complex-like, not real and imag. qlm_norm is the normalization of the qlms. H0 the starting Hessian estimate. (cl array, ~ 1 / N0) """ assert type in _types self.PBSSIZE = pbs.size if PBSSIZE is None else PBSSIZE self.PBSRANK = pbs.rank if PBSRANK is None else PBSRANK assert self.PBSRANK < self.PBSSIZE, (self.PBSRANK, self.PBSSIZE) self.barrier = (lambda: 0) if self.PBSSIZE == 1 else pbs.barrier self.type = type self.lib_dir = lib_dir self.dat_maps = dat_maps self.chain_descr = chain_descr self.opfilt = opfilt assert self.chain_descr is not None assert opfilt is not None # lib_noise = getattr(par, 'lib_noise_%s' % type) # lib_cmb_unl = getattr(par, 'lib_cmb_unl_%s' % type) self.cl_pp = cpp_prior self.lib_qlm = lib_qlm self.lsides = cov.lib_skyalm.lsides assert cov.lib_skyalm.lsides == lib_qlm.lsides self.lmax_qlm = self.lib_qlm.ellmax self.NR_method = NR_method self.tidy = tidy self.maxiter = maxcgiter self.verbose = verbose self.nodeglensing = no_deglensing if self.verbose: print " I see t", cov.Nlev_uKamin('t') print " I see q", cov.Nlev_uKamin('q') print " I see u", cov.Nlev_uKamin('u') # Defining a trial newton step length : def newton_step_length(iter, norm_incr): # FIXME # Just trying if half the step is better for S4 QU if cov.Nlev_uKamin('t') > 2.1: return 1. if cov.Nlev_uKamin('t') <= 2.1: return 0.5 return 0.5 self.newton_step_length = newton_step_length self.soltn0 = soltn0 # Default tolerance function(iter,key) # FIXME Put tolerance and maxiter in chain descrt # def tol_func(iter, key, **kwargs): # return 1e-3 # self.tol_func = tol_func f_id = fs.ffs_deflect.ffs_deflect.ffs_id_displacement( cov.lib_skyalm.shape, cov.lib_skyalm.lsides) if not hasattr(cov, 'f') or not hasattr(cov, 'fi'): self.cov = cov.turn2wlfilt(f_id, f_id) else: cov.set_ffi(f_id, f_id) self.cov = cov if self.PBSRANK == 0: if not os.path.exists(self.lib_dir): os.makedirs(self.lib_dir) pbs.barrier() print 'ffs iterator : This is %s trying to setup %s' % (self.PBSRANK, lib_dir) # Lensed covariance matrix library : # We will redefine the displacement at each iteration step self.use_Pool = use_Pool_lens self.use_Pool_inverse = use_Pool_inverse if self.PBSRANK == 0: # FIXME : hash and hashcheck if not os.path.exists(self.lib_dir): os.makedirs(self.lib_dir) if not os.path.exists(self.lib_dir + '/MAPlms'): os.makedirs(self.lib_dir + '/MAPlms') if not os.path.exists(self.lib_dir + '/cghistories'): os.makedirs(self.lib_dir + '/cghistories') # pre_calculation of qlm_norms with rank 0: if self.PBSRANK == 0 and \ (not os.path.exists(self.lib_dir + '/qlm_%s_H0.dat' % ('P')) or not os.path.exists(self.lib_dir + '/%shi_plm_it%03d.npy' % ('P', 0))): print '++ ffs_%s_iterator: Caching qlm_norms and N0s' % type, self.lib_dir # Caching qlm norm that we will use as zeroth order curvature : (with lensed weights) # Prior curvature : # Gaussian priors prior_pp = cl_inverse(self.cl_pp[0:self.lmax_qlm + 1]) prior_pp[0] *= 0.5 curv_pp = H0 + prior_pp # isotropic estimate of the posterior curvature at the starting point self.cache_cl(self.lib_dir + '/qlm_%s_H0.dat' % ('P'), cl_inverse(curv_pp)) print " cached %s" % self.lib_dir + '/qlm_%s_H0.dat' % ('P') fname_P = self.lib_dir + '/%shi_plm_it%03d.npy' % ('P', 0) self.cache_qlm(fname_P, self.load_qlm(Plm0)) self.barrier() if not os.path.exists(self.lib_dir + '/Hessian') and self.PBSRANK == 0: os.makedirs(self.lib_dir + '/Hessian') # We store here the rank 2 updates to the Hessian according to the BFGS iterations. if not os.path.exists(self.lib_dir + '/history_increment.txt') and self.PBSRANK == 0: with open(self.lib_dir + '/history_increment.txt', 'w') as file: file.write( '# Iteration step \n' + '# Exec. time in sec.\n' + '# Increment norm (normalized to starting point displacement norm) \n' + '# Total gradient norm (all grad. norms normalized to initial total gradient norm)\n' + '# Quad. gradient norm\n' + '# Det. gradient norm\n' + '# Pri. gradient norm\n' + '# Newton step length\n') file.close() if self.PBSRANK == 0: print '++ ffs_%s masked iterator : setup OK' % type self.barrier()
def __init__(self, lib_dir, lib_datalm, lib_lencmb, cl_transf, nTpix, nQpix, nUpix, pix_pha=None, cache_sims=True): """ Library for sims with pixel to pixel independent noise with specified noise variance maps. :param lib_dir: :param lib_datalm: ffs_alm library for the data maps. :param lib_lencmb: library of lensed cmb sims :param cl_transf: transfer function cl (identical for T Q U) :param nTpix: pixel noise rms noise in T (either scalar or a map of the right shape, or a path to the map) :param nQpix: pixel noise rms noise in Q :param nUpix: pixel noise rms noise in U :param pix_pha: random for phases for the noise maps :param cache_sims: does cache ims on disk if set """ self.lencmbs = lib_lencmb self.lib_datalm = lib_datalm self.lib_skyalm = lib_lencmb.lib_skyalm self.cl_transf = np.zeros(self.lib_skyalm.ellmax + 1, dtype=float) self.cl_transf[:min(len(self.cl_transf), len( cl_transf))] = cl_transf[:min(len(self.cl_transf), len(cl_transf))] self.lib_dir = lib_dir self.cache_sims = cache_sims if not os.path.exists(lib_dir) and pbs.rank == 0: os.makedirs(lib_dir) pbs.barrier() if pix_pha is None: self.pix_pha = ffs_phas.pix_lib_phas(lib_dir + '/pix_pha', 3, lib_datalm.shape) else: self.pix_pha = pix_pha assert pix_pha.shape == self.lib_datalm.shape, ( pix_pha.shape, self.lib_datalm.shape) assert pix_pha.nfields == 3, (pix_pha.nfields, 3) if not isinstance(nTpix, str): if not os.path.exists(lib_dir + '/nTpix.npy') and pbs.rank == 0: np.save(lib_dir + '/nTpix.npy', nTpix) pbs.barrier() self.nTpix = lib_dir + '/nTpix.npy' else: assert os.path.exists(nTpix), nTpix self.nTpix = nTpix if not isinstance(nQpix, str): if not os.path.exists(lib_dir + '/nQpix.npy') and pbs.rank == 0: np.save(lib_dir + '/nQpix.npy', nQpix) pbs.barrier() self.nQpix = lib_dir + '/nQpix.npy' else: assert os.path.exists(nQpix), nQpix self.nQpix = nQpix if not isinstance(nUpix, str): if not os.path.exists(lib_dir + '/nUpix.npy') and pbs.rank == 0: np.save(lib_dir + '/nUpix.npy', nUpix) pbs.barrier() self.nUpix = lib_dir + '/nUpix.npy' else: assert os.path.exists(nUpix), nUpix self.nUpix = nUpix # Check noise maps inputs for _noise in [self._loadTnoise, self._loadQnoise, self._loadUnoise]: assert _noise().size == 1 or _noise( ).shape == self.lib_datalm.shape, (_noise().size, self.lib_datalm.shape) if not os.path.exists(lib_dir + '/sim_hash.pk') and pbs.rank == 0: pk.dump(self.hashdict(), open(lib_dir + '/sim_hash.pk', 'w')) pbs.barrier() hash_check(self.hashdict(), pk.load(open(lib_dir + '/sim_hash.pk', 'r')))
def calc_gradPlikPdet(self, iter, key, callback='default_callback'): """ Caches the det term for iter via MC sims, together with the data one, for maximal //isation. """ assert key.lower() in ['p', 'o'], key # potential or curl potential. fname_detterm = self.lib_dir + '/qlm_grad%sdet_it%03d.npy' % ( key.upper(), iter - 1) fname_likterm = self.lib_dir + '/qlm_grad%slik_it%03d.npy' % ( key.upper(), iter - 1) if os.path.exists(fname_detterm) and os.path.exists(fname_likterm): return 0 assert self.is_previous_iter_done(iter, key) pix_pha, cmb_pha = self.build_pha(iter) if self.PBSRANK == 0 and not os.path.exists(self.lib_dir + '/mf_it%03d' % (iter - 1)): os.makedirs(self.lib_dir + '/mf_it%03d' % (iter - 1)) pbs.barrier() # Caching gradients for the mc_sims_mf sims , plus the dat map. # The gradient of the det term is the data averaged lik term, with the opposite sign. jobs = [] try: self.load_qlm(fname_likterm) except: jobs.append(-1) # data map for idx in range(self.nsims): # sims if not os.path.exists(self.lib_dir + '/mf_it%03d/g%s_%04d.npy' % (iter - 1, key.lower(), idx)): jobs.append(idx) else: try: # just checking if file is OK. self.load_qlm(self.lib_dir + '/mf_it%03d/g%s_%04d.npy' % (iter - 1, key.lower(), idx)) except: jobs.append(idx) self.opfilt._type = self.type # By setting the chain outside the main loop we avoid potential MPI barriers # in degrading the lib_alm libraries: mchain = fs.qcinv.multigrid.multigrid_chain( self.opfilt, self.type, self.chain_descr, self.cov, no_deglensing=self.nodeglensing) for i in range(self.PBSRANK, len(jobs), self.PBSSIZE): idx = jobs[i] print "rank %s, doing mc det. gradients idx %s, job %s in %s at iter level %s:" \ % (self.PBSRANK, idx, i, len(jobs), iter) ti = time.time() if idx >= 0: # sim grad_fname = self.lib_dir + '/mf_it%03d/g%s_%04d.npy' % ( iter - 1, key.lower(), idx) self.cov.set_ffi(self.load_f(iter - 1, key), self.load_finv(iter - 1, key)) MFest = ql.MFestimator(self.cov, self.opfilt, mchain, self.lib_qlm, pix_pha=pix_pha, cmb_pha=cmb_pha, use_Pool=self.use_Pool) grad = MFest.get_MFqlms(self.type, self.MFkey, idx)[{ 'p': 0, 'o': 1 }[key.lower()]] if self.subtract_phi0: isofilt = self.cov.turn2isofilt() chain_descr_iso = fs.qcinv.chain_samples.get_isomgchain( self.cov.lib_skyalm.ellmax, self.cov.lib_datalm.shape, iter_max=self.maxiter) mchain_iso = fs.qcinv.multigrid.multigrid_chain( self.opfilt, self.type, chain_descr_iso, isofilt, no_deglensing=self.nodeglensing) MFest = ql.MFestimator(isofilt, self.opfilt, mchain_iso, self.lib_qlm, pix_pha=pix_pha, cmb_pha=cmb_pha, use_Pool=self.use_Pool) grad -= MFest.get_MFqlms(self.type, self.MFkey, idx)[{ 'p': 0, 'o': 1 }[key.lower()]] self.cache_qlm(grad_fname, grad, pbs_rank=self.PBSRANK) else: # This is the data. # FIXME : The solution input is not working properly sometimes. We give it up for now. # FIXME don't manage to find the right d0 to input for a given sol ?!! self.cov.set_ffi(self.load_f(iter - 1, key), self.load_finv(iter - 1, key)) soltn = self.load_soltn(iter, key).copy() * 0. mchain.solve(soltn, self.get_datmaps(), finiop='MLIK') self.cache_TEBmap(soltn, iter - 1, key) TQUMlik = self.opfilt.soltn2TQUMlik(soltn, self.cov) ResTQUMlik = self.Mlik2ResTQUMlik(TQUMlik, iter, key) grad = -ql.get_qlms_wl(self.type, self.cov.lib_skyalm, TQUMlik, ResTQUMlik, self.lib_qlm, use_Pool=self.use_Pool, f=self.load_f(iter - 1, key))[{ 'p': 0, 'o': 1 }[key.lower()]] self.cache_qlm(fname_likterm, grad, pbs_rank=self.PBSRANK) print "%s it. %s sim %s, rank %s cg status " % (key.lower(), iter, idx, self.PBSRANK) # It does not help to cache both grad_O and grad_P as they do not follow the trajectory in plm space. # Saves some info about current iteration : if idx == -1: # Saves some info about iteration times etc. with open(self.lib_dir + '/cghistories/history_dat.txt', 'a') as file: file.write('%04d %.3f \n' % (iter, time.time() - ti)) file.close() else: with open( self.lib_dir + '/cghistories/history_sim%04d.txt' % idx, 'a') as file: file.write('%04d %.3f \n' % (iter, time.time() - ti)) file.close() pbs.barrier() if self.PBSRANK == 0: # Collecting terms and caching det term. # We also cache arrays formed from independent sims for tests. print "rank 0, collecting mc det. %s gradients :" % key.lower() det_term = np.zeros(self.lib_qlm.alm_size, dtype=complex) for i in range(self.nsims): fname = self.lib_dir + '/mf_it%03d/g%s_%04d.npy' % ( iter - 1, key.lower(), i) det_term = (det_term * i + self.load_qlm(fname)) / (i + 1.) self.cache_qlm(fname_detterm, det_term, pbs_rank=0) det_term *= 0. fname_detterm1 = fname_detterm.replace('.npy', 'MF1.npy') assert 'MF1' in fname_detterm1 for i in np.arange(self.nsims)[0::2]: fname = self.lib_dir + '/mf_it%03d/g%s_%04d.npy' % ( iter - 1, key.lower(), i) det_term = (det_term * i + self.load_qlm(fname)) / (i + 1.) self.cache_qlm(fname_detterm1, det_term, pbs_rank=0) det_term *= 0. fname_detterm2 = fname_detterm.replace('.npy', 'MF2.npy') assert 'MF2' in fname_detterm2 for i in np.arange(self.nsims)[1::2]: fname = self.lib_dir + '/mf_it%03d/g%s_%04d.npy' % ( iter - 1, key.lower(), i) det_term = (det_term * i + self.load_qlm(fname)) / (i + 1.) self.cache_qlm(fname_detterm2, det_term, pbs_rank=0) # Erase some temp files if requested to do so : if self.tidy > 1: # We erase as well the gradient determinant term that were stored on disk : files_to_remove = \ [self.lib_dir + '/mf_it%03d/g%s_%04d.npy' % (iter - 1, key.lower(), i) for i in range(self.nsims)] print 'rank %s removing %s maps in ' % ( self.PBSRANK, len(files_to_remove) ), self.lib_dir + '/mf_it%03d/' % (iter - 1) for file in files_to_remove: os.remove(file) pbs.barrier()
def iterate(self, iter, key, cache_only=False, callback='default_callback'): """ Performs an iteration, by collecting the gradients at level iter, and the lower level potential, saving then the iter + 1 potential map. """ assert key.lower() in ['p', 'o'], key # potential or curl potential. plm_fname = self.lib_dir + '/%s_plm_it%03d.npy' % ({ 'p': 'Phi', 'o': 'Om' }[key.lower()], iter) if os.path.exists(plm_fname): return None if cache_only else self.load_qlm(plm_fname) assert self.is_previous_iter_done(iter, key), 'previous iteration not done' # Calculation in // of lik and det term : ti = time.time() if self.PBSRANK == 0: # Single processes routines : self.calc_ffinv(iter - 1, key) self.get_gradPpri(iter, key, cache_only=True) pbs.barrier() # Calculation of the likelihood term, involving the det term over MCs : irrelevant = self.calc_gradPlikPdet(iter, key) pbs.barrier() # Everything should be on disk now. if self.PBSRANK == 0: incr, steplength = self.build_incr( iter, key, self.load_total_grad(iter - 1, key)) self.cache_qlm(plm_fname, self.get_Plm(iter - 1, key) + incr, pbs_rank=0) # Saves some info about increment norm and exec. time : norm_inc = self.calc_norm(incr) / self.calc_norm( self.get_Plm(0, key)) norms = [self.calc_norm(self.load_gradquad(iter - 1, key))] norms.append(self.calc_norm(self.load_graddet(iter - 1, key))) norms.append(self.calc_norm(self.load_gradpri(iter - 1, key))) norm_grad = self.calc_norm(self.load_total_grad(iter - 1, key)) norm_grad_0 = self.calc_norm(self.load_total_grad(0, key)) for i in [0, 1, 2]: norms[i] = norms[i] / norm_grad_0 with open(self.lib_dir + '/history_increment.txt', 'a') as file: file.write( '%03d %.1f %.6f %.6f %.6f %.6f %.6f %.12f \n' % (iter, time.time() - ti, norm_inc, norm_grad / norm_grad_0, norms[0], norms[1], norms[2], steplength)) file.close() if self.tidy > 2: # Erasing dx,dy and det magn (12GB for full sky at 0.74 amin per iteration) f1, f2 = self.getfnames_f(key, iter - 1) f3, f4 = self.getfnames_finv(key, iter - 1) for _f in [f1, f2, f3, f4]: if os.path.exists(_f): os.remove(_f) if self.verbose: print " removed :", _f if os.path.exists(self.lib_dir + '/f_%04d_libdir' % (iter - 1)): shutil.rmtree(self.lib_dir + '/f_%04d_libdir' % (iter - 1)) if self.verbose: print "Removed :", self.lib_dir + '/f_%04d_libdir' % ( iter - 1) if os.path.exists(self.lib_dir + '/finv_%04d_libdir' % (iter - 1)): shutil.rmtree(self.lib_dir + '/finv_%04d_libdir' % (iter - 1)) if self.verbose: print "Removed :", self.lib_dir + '/finv_%04d_libdir' % ( iter - 1) pbs.barrier() return None if cache_only else self.load_qlm(plm_fname)