def calc_zeff(data_z, data_zerr, table_z_max=2.0, nz=101, z_min=0.6, z_max=0.8, \ interp_flag=True, **cosmology) : import numpy as np from scipy.integrate import quad assert table_z_max > z_max, 'To avoid extrapolation, table_z_max must be larger \ than z_max: table_z_max={}, z_max={}'.format(table_z_max, z_max) ## Get the redshift distribution phi = phi_interpolator(data_z, data_zerr, table_z_max, nz) if interp_flag : ## In this case, get the distance and Hubble splines xi = distance_interpolator(table_z_max, nz, **cosmology) H = Hubble_interpolator(table_z_max, nz, **cosmology) ## Calculate the numerator and denominator zeff_num = quad(zeff_numerator_integrand, z_min, z_max, args=(H, xi, phi, \ interp_flag))[0] zeff_denom = quad(zeff_denominator_integrand, z_min, z_max, args=(H, xi, phi, \ interp_flag))[0] else : ## Here we need to set up the cosmology instead from astropy.cosmology import w0waCDM cosmo = w0waCDM(100.*cosmology['h0'], cosmology['omega_m'], \ 1.-cosmology['omega_k']-cosmology['omega_m'], w0=cosmology['w'], \ wa=cosmology['wa']) ## Calculate the numerator and denominator zeff_num = quad(zeff_numerator_integrand, z_min, z_max, args=(cosmo.H, \ cosmo.comoving_distance, phi, interp_flag))[0] zeff_denom = quad(zeff_denominator_integrand, z_min, z_max, args=(cosmo.H, \ cosmo.comoving_distance, phi, interp_flag))[0] ## Now we just return zeff = zeff_num/zeff_denom return zeff_num/zeff_denom
def llhood_jlad_wzcdm(model_param, ndim, nparam): om, w0, wa, a, b, MB, DM, od, g = [model_param[i] for i in range(9)] h0 = 70 A = [] for i in range(0, 50): At = 10**(od) * attenuation(om, h0, z50[i], w0, wa, g) A.append(At) A_inter = interp1d(z50, A) DUST = A_inter(jla.zcmb.values) dist_th = w0waCDM(h0, om, 1 - om, w0, wa).luminosity_distance(jla.zcmb.values).value mod_th = 5 * np.log10(dist_th) + 25 hub_res = jla.mb.values + a * jla.x1.values - b * jla.color.values - MB - mod_th - DUST hub_res[jla.hm.values >= 10.] += DM C = mu_cov(a, b) iC = np.linalg.inv(C) chisq = np.dot(hub_res.T, np.dot(iC, hub_res)) if cmb == 1: T = cmb_chisq(om, h0, w0, wa) chisq += T return -0.5 * chisq
def __init__(self,fp=None,pool=None,length_unit=1.0*kpc,mass_unit=1.0e10*Msun,velocity_unit=1.0*km/s,header_kwargs=dict()): self.pool = pool self._length_unit = length_unit.to(cm).value self._mass_unit = mass_unit.to(g).value self._velocity_unit = velocity_unit.to(cm/s).value if fp is not None: self.fp = fp #Load the header self._header = self.getHeader(**header_kwargs) #Check that header has been loaded correctly self._check_header() #Hubble parameter h = self._header["h"] #Define the Mpc/h, and kpc/h units for convenience if h>0.0: self.kpc_over_h = def_unit("kpc/h",kpc/self._header["h"]) self.Mpc_over_h = def_unit("Mpc/h",Mpc/self._header["h"]) #Scale box to kpc/h self._header["box_size"] *= self.kpc_over_h #Convert to Mpc/h self._header["box_size"] = self._header["box_size"].to(self.Mpc_over_h) #Read in the comoving distance if "comoving_distance" in self._header: self._header["comoving_distance"] = (self._header["comoving_distance"] / 1.0e3) * self.Mpc_over_h else: self._header["box_size"] *= kpc logging.debug("Warning! Hubble parameter h is zero!!") #Scale masses to correct units if h>0.0: self._header["masses"] *= (self._mass_unit / self._header["h"]) self._header["masses"] = (self._header["masses"]*g).to(Msun) #Scale Hubble parameter to correct units self._header["H0"] = self._header["h"] * 100 * km / (s*Mpc) #Update the dictionary with the number of particles per side self._header["num_particles_total_side"] = int(np.round(self._header["num_particles_total"]**(1/3))) #Once all the info is available, add a wCDM instance as attribute to facilitate the cosmological calculations if h>0.0: self.cosmology = w0waCDM(H0=self._header["H0"],Om0=self._header["Om0"],Ode0=self._header["Ode0"],w0=self._header["w0"],wa=self._header["wa"]) #Set particle number limits that this instance will handle self.setLimits()
def test_assign_cosmo(): """ Test to make sure it reassigns the cosmology """ from resspect import cosmo_metric_utils as cmu cosmo = w0waCDM(70, 0.3, 0.7, -0.9, 0.0) updated_cosmo = cmu.assign_cosmo(cosmo, model=[72, 0.29, 0.71, -1, 0.0]) assert int(updated_cosmo.H0.value) == int(72) assert hasattr(updated_cosmo, 'distmod') assert isinstance(updated_cosmo, w0waCDM)
def getHeader(self, h=0.72, w0=-1., wa=0.): #Create header dictionary header = dict() header["h"] = h header["w0"] = w0 header["wa"] = wa #Read the redshift from the filename header["redshift"] = float( re.search(r"\.z([0-9\.]+)\.", self.fp.name).groups()[0]) header["scale_factor"] = 1. / (1. + header["redshift"]) #Look for the log file that contains all the information we need in the header task_number = int( re.search(r"\.([0-9]{4})\.", self.fp.name).groups()[0]) logfile = re.sub(r"\.[0-9]{4}\..*", ".{0:02d}.log".format(task_number), self.fp.name) #Read the log file and fill the header with open(logfile, "r") as logfp: ahflog = logfp.read() #Cosmological parameters and box size Om0, Ode0, box_size = re.search( r"simu\.omega0\s*:\s*([0-9\.]+)\nsimu\.lambda0\s*:\s*([0-9\.]+)\nsimu\.boxsize\s*:\s*([0-9\.]+)", ahflog).groups() header["Om0"] = float(Om0) header["Ode0"] = float(Ode0) header["box_size"] = float(box_size) * 1.0e3 #These are not important header["masses"] = np.zeros(6) header["num_particles_file"] = 1. header["num_particles_total"] = 1. header["num_files"] = 1 #Finally compute the comoving distance header["comoving_distance"] = w0waCDM( H0=h * 100, Om0=header["Om0"], Ode0=header["Ode0"], w0=header["w0"], wa=header["wa"]).comoving_distance(header["redshift"]).to( u.kpc).value / h #Return to user return header
def set_cosmology(self, cosmo_dict): """Settig cosmological parameters Parameters ---------- cosmo_dict : dict dictionary of cosmological parameters. cosmo_dict needs to include, Omega_de0, Omega_K0, w0, wa, h. Omega_m0 is computed internally by Omega_m0 = 1.0 - Omega_de0 - Omega_K0 """ Omega_de0 = cosmo_dict['Omega_de0'] Omega_m0 = 1.0 - cosmo_dict['Omega_de0'] - cosmo_dict['Omega_K0'] w0 = cosmo_dict['w0'] wa = cosmo_dict['wa'] H0 = 100.0 * cosmo_dict['h'] self.cosmo = w0waCDM(H0, Omega_m0, Omega_de0, w0=w0, wa=wa)
def llhood_pbc_wzcdm(model_param, ndim, nparam): om, h0, w0, wa, MB = [model_param[i] for i in range(5)] dist_th = w0waCDM(h0, om, 1 - om, w0, wa).luminosity_distance(pb.zcmb.values).value mod_th = 5 * np.log10(dist_th) + 25 hub_res = pb.mb.values - mod_th - MB chisq = np.dot(hub_res.T, np.dot(pb_icm, hub_res)) if cmb == 1: T = cmb_chisq(om, h0, w0, wa) chisq += T return -0.5 * chisq
def distance_interpolator(z_max=2.0, nz=101, **cosmology) : import numpy as np from scipy.interpolate import UnivariateSpline from astropy.cosmology import w0waCDM ## This is setting up our cosmology cosmo = w0waCDM(100.*cosmology['h0'], cosmology['omega_m'], \ 1.-cosmology['omega_k']-cosmology['omega_m'], w0=cosmology['w'], wa=cosmology['wa']) ## Set up a grid of redshifts at which to evaluate the distance to set up the spline table_z = np.linspace(0.0, z_max, num=nz) table_r = cosmo.comoving_distance(table_z).value ## Create and return the spline object. Note that a cubic spline works better than ## a linear spline here distance = UnivariateSpline(table_z, table_r, s=0) return distance
def swift_cosmology_to_astropy(cosmo: dict, units) -> Cosmology: """ Parameters ---------- cosmo: dict Cosmology dictionary ready straight out of the SWIFT snapshot. units: SWIFTUnits The SWIFT Units instance associated with this snapshot. Returns ------- Cosmology An instance of ``astropy.cosmology.Cosmology`` filled with the correct parameters. """ H0 = unyt.unyt_quantity(cosmo["H0 [internal units]"][0], units=1.0 / units.time) Omega_b = cosmo["Omega_b"][0] Omega_lambda = cosmo["Omega_lambda"][0] Omega_r = cosmo["Omega_r"][0] Omega_m = cosmo["Omega_m"][0] w_0 = cosmo["w_0"][0] w_a = cosmo["w_a"][0] # SWIFT provides Omega_r, but we need a consistent Tcmb0 for astropy. # This is an exact inversion of the procedure performed in astropy. critical_density_0 = astropy_units.Quantity( critdens_const * H0.to("1/s").value**2, astropy_units.g / astropy_units.cm**3, ) Tcmb0 = (Omega_r * critical_density_0.value / a_B_c2)**(1.0 / 4.0) return w0waCDM( H0=H0.to_astropy(), Om0=Omega_m, Ode0=Omega_lambda, w0=w_0, wa=w_a, Tcmb0=Tcmb0, Ob0=Omega_b, )
def setHeaderInfo(self,Om0=0.26,Ode0=0.74,w0=-1.0,wa=0.0,h=0.72,redshift=100.0,box_size=15.0*u.Mpc/0.72,flag_cooling=0,flag_sfr=0,flag_feedback=0,flag_stellarage=0,flag_metals=0,flag_entropy_instead_u=0,masses=np.array([0,1.03e10,0,0,0,0])*u.Msun,num_particles_file_of_type=None,npartTotalHighWord=np.zeros(6,dtype=np.uint32)): """ Sets the header info in the snapshot to write """ if num_particles_file_of_type is None: num_particles_file_of_type = np.array([0,1,0,0,0,0],dtype=np.int32) * self.positions.shape[0] assert num_particles_file_of_type.sum()==self.positions.shape[0],"The total number of particles must match!!" assert box_size.unit.physical_type=="length" assert masses.unit.physical_type=="mass" #Create the header self._header = Gadget2Header() #Fill in self._header["Om0"] = Om0 self._header["Ode0"] = Ode0 self._header["w0"] = w0 self._header["wa"] = wa self._header["h"] = h self._header["H0"] = 100.0*h*u.km/(u.s*u.Mpc) self._header["redshift"] = redshift self._header["scale_factor"] = 1.0 / (1.0 + redshift) self._header["box_size"] = box_size self._header["flag_cooling"] = flag_cooling self._header["flag_sfr"] = flag_sfr self._header["flag_feedback"] = flag_feedback self._header["flag_stellarage"] = flag_stellarage self._header["flag_metals"] = flag_metals self._header["flag_entropy_instead_u"] = flag_entropy_instead_u self._header["masses"] = masses self._header["num_particles_file_of_type"] = num_particles_file_of_type self._header["num_particles_file"] = num_particles_file_of_type.sum() self._header["num_particles_total_of_type"] = num_particles_file_of_type self._header["num_particles_total"] = num_particles_file_of_type.sum() self._header["npartTotalHighWord"] = npartTotalHighWord #Define the kpc/h and Mpc/h units for convenience self.kpc_over_h = u.def_unit("kpc/h",u.kpc/self._header["h"]) self.Mpc_over_h = u.def_unit("Mpc/h",u.Mpc/self._header["h"]) #Compute the comoving distance according to the model cosmo = w0waCDM(H0=100.0*h,Om0=Om0,Ode0=Ode0,w0=w0,wa=wa) self._header["comoving_distance"] = cosmo.comoving_distance(redshift).to(self.Mpc_over_h)
def cosmo(self, kwargs): """ :param kwargs: keyword arguments of parameters (can include others not used for the cosmology) :return: astropy.cosmology instance """ if self._cosmology == "FLCDM": cosmo = FlatLambdaCDM(H0=kwargs['h0'], Om0=kwargs['om']) elif self._cosmology == "FwCDM": cosmo = FlatwCDM(H0=kwargs['h0'], Om0=kwargs['om'], w0=kwargs['w']) elif self._cosmology == "w0waCDM": cosmo = w0waCDM(H0=kwargs['h0'], Om0=kwargs['om'], Ode0=1.0 - kwargs['om'], w0=kwargs['w0'], wa=kwargs['wa']) elif self._cosmology == "oLCDM": cosmo = LambdaCDM(H0=kwargs['h0'], Om0=kwargs['om'], Ode0=1.0 - kwargs['om'] - kwargs['ok']) else: raise ValueError("Cosmology %s is not supported" % self._cosmology) return cosmo
def log_prob_ddt(theta, lenses, cosmology): """ Compute the likelihood of the given cosmological parameters against the modeled angular diameter distances of the lenses. param theta: list of loat, folded cosmological parameters. param lenses: list of lens objects (currently either GLEELens or LenstronomyLens). param cosmology: string, keyword indicating the choice of cosmology to work with. """ lp = log_prior(theta, cosmology) if not np.isfinite(lp): return -np.inf else: logprob = lp if cosmology == "FLCDM": h0, om = theta cosmo = FlatLambdaCDM(H0=h0, Om0=om) elif cosmology == "ULCDM": h0 = theta[0] cosmo = FlatLambdaCDM(H0=h0, Om0=0.3) elif cosmology == "FwCDM": h0, om, w = theta cosmo = FlatwCDM(H0=h0, Om0=om, w0=w) elif cosmology == "w0waCDM": h0, om, w0, wa = theta cosmo = w0waCDM(H0=h0, Om0=om, Ode0=1.0 - om, w0=w0, wa=wa) elif cosmology == "oLCDM": h0, om, ok = theta # assert we are not in a crazy cosmological situation that prevents computing the angular distance integral if np.any([ ok * (1.0 + lens.zsource)**2 + om * (1.0 + lens.zsource)**3 + (1.0 - om - ok) <= 0 for lens in lenses ]): return -np.inf else: cosmo = LambdaCDM(H0=h0, Om0=om, Ode0=1.0 - om - ok) else: raise ValueError("I don't know the cosmology %s" % cosmology) for lens in lenses: logprob += log_like_add(lens=lens, cosmo=cosmo) return logprob
def llhood_jlac_wzcdm(model_param, ndim, nparam): om, w0, wa, a, b, MB, DM = [model_param[i] for i in range(7)] h0 = 70 dist_th = w0waCDM(h0, om, 1 - om, w0, wa).luminosity_distance(jla.zcmb.values).value mod_th = 5 * np.log10(dist_th) + 25 hub_res = jla.mb.values + a * jla.x1.values - b * jla.color.values - MB - mod_th hub_res[jla.hm.values >= 10.] += DM C = mu_cov(a, b) iC = np.linalg.inv(C) chisq = np.dot(hub_res.T, np.dot(iC, hub_res)) if cmb == 1: T = cmb_chisq(om, h0, w0, wa) chisq += T return -0.5 * chisq
def llhood_pbd_wzcdm(model_param, ndim, nparam): om, h0, w0, wa, MB, od, g = [model_param[i] for i in range(7)] A = [] for i in range(0, len(pb.zcmb.values)): At = 10**(od) * attenuation(om, h0, pb.zcmb.values[i], w0, wa, g) A.append(At) #A_inter = interp1d(z50, A) #DUST = A_inter(pb.zcmb.values) dist_th = w0waCDM(h0, om, 1 - om, w0, wa).luminosity_distance(pb.zcmb.values).value mod_th = 5 * np.log10(dist_th) + 25 hub_res = pb.mb.values - mod_th - MB - A chisq = np.dot(hub_res.T, np.dot(pb_icm, hub_res)) if cmb == 1: T = cmb_chisq(om, h0, w0, wa) chisq += T return -0.5 * chisq
def getHeader(self,h=0.72,w0=-1.,wa=0.): #Create header dictionary header = dict() header["h"] = h header["w0"] = w0 header["wa"] = wa #Read the redshift from the filename header["redshift"] = float(re.search(r"\.z([0-9\.]+)\.",self.fp.name).groups()[0]) header["scale_factor"] = 1./(1.+header["redshift"]) #Look for the log file that contains all the information we need in the header task_number = int(re.search(r"\.([0-9]{4})\.",self.fp.name).groups()[0]) logfile = re.sub(r"\.[0-9]{4}\..*",".{0:02d}.log".format(task_number),self.fp.name) #Read the log file and fill the header with open(logfile,"r") as logfp: ahflog = logfp.read() #Cosmological parameters and box size Om0,Ode0,box_size = re.search(r"simu\.omega0\s*:\s*([0-9\.]+)\nsimu\.lambda0\s*:\s*([0-9\.]+)\nsimu\.boxsize\s*:\s*([0-9\.]+)",ahflog).groups() header["Om0"] = float(Om0) header["Ode0"] = float(Ode0) header["box_size"] = float(box_size)*1.0e3 #These are not important header["masses"] = np.zeros(6) header["num_particles_file"] = 1. header["num_particles_total"] = 1. header["num_files"] = 1 #Finally compute the comoving distance header["comoving_distance"] = w0waCDM(H0=h*100,Om0=header["Om0"],Ode0=header["Ode0"],w0=header["w0"],wa=header["wa"]).comoving_distance(header["redshift"]).to(u.kpc).value / h #Return to user return header
def fish_deriv_m(redshift, model, step, screen=False): """Calculates the derivatives and the base function at given redshifts. Parameters ---------- redshift: float or list Redshift where derivatives will be calculated. model: list List of cosmological model parameters. Order is [H0, Om, Ode, w0, wa]. step: list List of steps the cosmological model parameter will take when determining the derivative. If a given entry is zero, that parameter will be kept constant. Length must match the number of parameters in "model" variable. screen: bool (optional) Print debug options to screen. Default is False. Returns ------- m: list List of theoretical distance modulus (mu) at a given redshift from the base cosmology. m_deriv: list [len(redshift), len(model)] List of parameter derivatives of the likelihood function at given redshifts. """ Ob0=0.022 Om0=model[1] Ode0 =model[2] cosmo = w0waCDM(model[0], Ob0, Om0, Ode0, model[3],model[4]) cosmo=assign_cosmo(cosmo, model) m = [] m_deriv = [] c = const.c.to('km/s') base_theory = cosmo.distmod(redshift) m = base_theory.value step_inds = np.where(step)[0] # look for non-zero step indices deriv = np.zeros((len(base_theory), len(model))) if (step_inds.size==0): print('No steps taken, abort') exit else: if screen: print('\n') print('Computing Fisher derivatives...') for i, stepp in enumerate(step_inds): if screen: print('we are stepping in :', model[stepp], ' with step size', step[stepp]) cosmo = assign_cosmo(cosmo, model) theory = np.zeros((len(base_theory),2)) for count,j in enumerate([-1,1]): tempmodel = list(model) tempmodel[stepp] = model[stepp] + j*step[stepp] c = const.c.to('km/s') cosmo = assign_cosmo(cosmo, tempmodel) tmp = cosmo.distmod(redshift) theory[:,count] = tmp deriv[:,stepp] = (theory[:,1] - theory[:,0])/(2.*step[stepp]) m_deriv = deriv return m, m_deriv
def readFITS(cls,filename,init_cosmology=True): #Read the FITS file with the plane information (if there are two HDU's the second one is the imaginary part) if fitsio is not None: hdu = fitsio(filename) else: hdu = fits.open(filename) if len(hdu)>2: raise ValueError("There are more than 2 HDUs, file format unknown") if fitsio is not None: header = hdu[0].read_header() else: header = hdu[0].header #Retrieve the info from the header (handle old FITS header format too) try: hubble = header["H0"] * (u.km/(u.s*u.Mpc)) h = header["h"] except: hubble = header["H_0"] * (u.km/(u.s*u.Mpc)) h = hubble.value / 100 Om0 = header["OMEGA_M"] Ode0 = header["OMEGA_L"] try: w0 = header["W0"] wa = header["WA"] except: w0 = header["W_0"] wa = header["W_A"] redshift = header["Z"] comoving_distance = (header["CHI"] / h) * u.Mpc if "SIDE" in header.keys(): angle = header["SIDE"] * u.Mpc / h elif "ANGLE" in header.keys(): angle = header["ANGLE"] * u.deg else: angle = ((header["RES_X"] * header["NAXIS1"] / header["CHI"]) * u.rad).to(u.deg) #Build the cosmology object if options directs if init_cosmology: cosmology = w0waCDM(H0=hubble,Om0=Om0,Ode0=Ode0,w0=w0,wa=wa) else: cosmology = None #Read the number of particles, if present try: num_particles = header["NPART"] except: num_particles = None #Read the units if present try: unit_string = header["UNIT"] name,exponent = re.match(r"([a-zA-Z]+)([0-9])?",unit_string).groups() unit = getattr(u,name) if exponent is not None: unit **= exponent except AttributeError: unit = u.dimensionless_unscaled except (ValueError,KeyError): unit = u.rad**2 #Instantiate the new PotentialPlane instance if fitsio is not None: if len(hdu)==1: new_plane = cls(hdu[0].read(),angle=angle,redshift=redshift,comoving_distance=comoving_distance,cosmology=cosmology,unit=unit,num_particles=num_particles,filename=filename) else: new_plane = cls(hdu[1].read() + 1.0j*hdu[1].read(),angle=angle,redshift=redshift,comoving_distance=comoving_distance,cosmology=cosmology,unit=unit,num_particles=num_particles,filename=filename) else: if len(hdu)==1: new_plane = cls(hdu[0].data.astype(np.float64),angle=angle,redshift=redshift,comoving_distance=comoving_distance,cosmology=cosmology,unit=unit,num_particles=num_particles,filename=filename) else: new_plane = cls((hdu[0].data + 1.0j*hdu[1].data).astype(np.complex128),angle=angle,redshift=redshift,comoving_distance=comoving_distance,cosmology=cosmology,unit=unit,num_particles=num_particles,filename=filename) #Close the FITS file and return hdu.close() return new_plane
def __init__(self, metricName='SNSimulation', mjdCol='observationStartMJD', RACol='fieldRA', DecCol='fieldDec', filterCol='filter', m5Col='fiveSigmaDepth', exptimeCol='visitExposureTime', nightCol='night', obsidCol='observationId', nexpCol='numExposures', vistimeCol='visitTime', seeingEffCol='seeingFwhmEff', airmassCol='airmass', skyCol='sky', moonCol='moonPhase', seeingGeomCol='seeingFwhmGeom', uniqueBlocks=False, config=None, x0_norm=None, **kwargs): self.mjdCol = mjdCol self.m5Col = m5Col self.filterCol = filterCol self.RACol = RACol self.DecCol = DecCol self.exptimeCol = exptimeCol self.seasonCol = 'season' self.nightCol = nightCol self.obsidCol = obsidCol self.nexpCol = nexpCol self.vistimeCol = vistimeCol self.seeingEffCol = seeingEffCol self.seeingGeomCol = seeingGeomCol self.airmassCol = airmassCol self.skyCol = skyCol self.moonCol = moonCol cols = [ self.RACol, self.DecCol, self.nightCol, self.m5Col, self.filterCol, self.mjdCol, self.obsidCol, self.nexpCol, self.vistimeCol, self.exptimeCol, self.seeingEffCol, self.seeingGeomCol, self.nightCol, self.airmassCol, self.moonCol ] # self.airmassCol, self.skyCol, self.moonCol] self.stacker = None coadd = config['Observations']['coadd'] if coadd: # cols += ['sn_coadd'] self.stacker = CoaddStacker( mjdCol=self.mjdCol, RACol=self.RACol, DecCol=self.DecCol, m5Col=self.m5Col, nightCol=self.nightCol, filterCol=self.filterCol, numExposuresCol=self.nexpCol, visitTimeCol=self.vistimeCol, visitExposureTimeCol='visitExposureTime') super(SNSimulation, self).__init__(col=cols, metricName=metricName, **kwargs) # bands considered self.filterNames = 'ugrizy' # grab config file self.config = config # healpix nside and area self.nside = config['Pixelisation']['nside'] self.area = hp.nside2pixarea(self.nside, degrees=True) # prodid self.prodid = config['ProductionID'] # load cosmology cosmo_par = config['Cosmology'] self.cosmology = w0waCDM(H0=cosmo_par['H0'], Om0=cosmo_par['Omega_m'], Ode0=cosmo_par['Omega_l'], w0=cosmo_par['w0'], wa=cosmo_par['wa']) # load telescope tel_par = config['Instrument'] self.telescope = Telescope(name=tel_par['name'], throughput_dir=tel_par['throughput_dir'], atmos_dir=tel_par['atmos_dir'], atmos=tel_par['atmos'], aerosol=tel_par['aerosol'], airmass=tel_par['airmass']) # sn parameters self.sn_parameters = config['SN parameters'] self.gen_par = SimuParameters( self.sn_parameters, cosmo_par, mjdCol=self.mjdCol, area=self.area, dirFiles=self.sn_parameters['x1_color']['dirFile'], web_path=config['Web path']) # this is for output save_status = config['Output']['save'] self.save_status = save_status self.outdir = config['Output']['directory'] # number of procs to run simu here self.nprocs = config['Multiprocessing']['nproc'] # if saving activated, prepare output dirs """ if self.save_status: self.prepareSave(outdir, prodid) """ # simulator parameter self.simu_config = config['Simulator'] # LC display in "real-time" self.display_lc = config['Display_LC']['display'] self.time_display = config['Display_LC']['time'] # fieldtype, season self.field_type = config['Observations']['fieldtype'] self.season = config['Observations']['season'] self.type = 'simulation' # get the x0_norm values to be put on a 2D(x1,color) griddata self.x0_grid = x0_norm # SALT2DIR self.salt2Dir = self.sn_parameters['salt2Dir'] # hdf5 index self.index_hdf5 = 100 # load reference LC if simulator is sn_fast self.reference_lc = None self.gamma = None self.mag_to_flux = None self.dustcorr = None web_path = config['Web path'] self.error_model = self.simu_config['error_model'] if 'sn_fast' in self.simu_config['name']: templateDir = self.simu_config['Template Dir'] gammaDir = self.simu_config['Gamma Dir'] gammaFile = self.simu_config['Gamma File'] dustDir = self.simu_config['DustCorr Dir'] # x1 and color are unique for this simulator x1 = self.sn_parameters['x1']['min'] color = self.sn_parameters['color']['min'] bluecutoff = self.sn_parameters['blue_cutoff'] redcutoff = self.sn_parameters['red_cutoff'] # Loading reference file lcname = 'LC_{}_{}_{}_{}_ebvofMW_0.0_vstack.hdf5'.format( x1, color, bluecutoff, redcutoff) self.reference_lc = GetReference(templateDir, lcname, gammaDir, gammaFile, web_path, self.telescope) dustFile = 'Dust_{}_{}_{}_{}.hdf5'.format(x1, color, bluecutoff, redcutoff) self.dustcorr = LoadDust(dustDir, dustFile, web_path).dustcorr else: gammas = LoadGamma('grizy', self.simu_config['Gamma Dir'], self.simu_config['Gamma File'], web_path, self.telescope) self.gamma = gammas.gamma self.mag_to_flux = gammas.mag_to_flux if self.error_model: SALT2Dir = 'SALT2.Guy10_UV2IR' check_get_dir(web_path, SALT2Dir, SALT2Dir) self.nprocdict = {} self.simu_out = {} self.lc_out = {} self.SNID = {} self.sn_meta = {}
num_z_points = 100 redshift_max = 3 redshift_min = 0 redshifts = np.linspace(redshift_min, redshift_max, num=num_z_points) # h, Om, Oa, w param1 = np.array([1, 1.0, 0.0, 0 ]) param2 = np.array([1, 0.25, 0.75, -1 ]) param3 = np.array([1, 0.25, 0.75, -0.8]) param4 = np.array([1, 0.25, 0.75, -1.2]) hval = 1.0 paramALL = np.array([param1, param2, param3, param4]) cosmo1 = w0waCDM(H0=100.*hval*param1[0], Om0=param1[1], Ode0=param1[2] ) cosmo2 = w0waCDM(H0=100.*hval*param2[0], Om0=param2[1], Ode0=param2[2], w0=param2[3]) cosmo3 = w0waCDM(H0=100.*hval*param3[0], Om0=param3[1], Ode0=param3[2], w0=param3[3]) cosmo4 = w0waCDM(H0=100.*hval*param4[0], Om0=param4[1], Ode0=param4[2], w0=param4[3]) """ test_z = 0.5 dc = cosmo1.comoving_distance(test_z) print("Test value for dc = ", dc) """ #Units: Mpc dcmpc1 = cosmo1.comoving_distance(redshifts) dcmpc2 = cosmo2.comoving_distance(redshifts) dcmpc3 = cosmo3.comoving_distance(redshifts) dcmpc4 = cosmo4.comoving_distance(redshifts)
def get_dist_w0(z, err_per=0): model = w0waCDM(H0=68*u.km/u.s/u.Mpc, Om0=0.28, Ode0=0.73, w0=-0.9, wa=0.2) dist = model.angular_diameter_distance(z).value error = (err_per*dist)*np.random.normal(0,1,np.shape(z)) return dist+error
def __init__(self, H0=73.0, Om0=0.25, Ok0=None, w0=None, wa=None): """ Initialize the cosmology wrapper with the parameters specified (e.g. does not account for massive neutrinos) param [in] H0 is the Hubble parameter at the present epoch in km/s/Mpc param [in] Om0 is the current matter density paramter (fraction of critical density) param [in] Ok0 is the current curvature density parameter param [in] w0 is the current dark energy equation of state w0 paramter param[in] wa is the current dark energy equation of state wa paramter The total dark energy equation of state as a function of z is w = w0 + wa z/(1+z) Currently, this wrapper class expects you to specify either a LambdaCDM (flat or non-flat) cosmology or a w0, wa (flat or non-flat) cosmology. The default cosmology is taken as the cosmology used in the Millennium Simulation (Springel et al 2005, Nature 435, 629 or arXiv:astro-ph/0504097) Om0 = 0.25 Ob0 = 0.045 (baryons; not currently used in this code) H0 = 73.0 Ok0 = 0.0, (implying Ode0 approx 0.75) w0 = -1.0 wa = 0.0 where Om0 + Ok0 + Ode0 + Ogamma0 + Onu0 = 1.0 sigma_8 = 0.9 (rms mass flucutation in an 8 h^-1 Mpc sphere; not currently used in this code) ns = 1 (index of the initial spectrum of linear mas perturbations; not currently used in this code) """ self.activeCosmology = None if w0 is not None and wa is None: wa = 0.0 isCosmologicalConstant = False if (w0 is None and wa is None) or (w0==-1.0 and wa==0.0): isCosmologicalConstant = True isFlat = False if Ok0 is None or (numpy.abs(Ok0) < flatnessthresh): isFlat = True if isCosmologicalConstant and isFlat: universe = cosmology.FlatLambdaCDM(H0=H0, Om0=Om0) elif isCosmologicalConstant: tmpmodel = cosmology.FlatLambdaCDM(H0=H0, Om0=Om0) Ode0 = 1.0 - Om0 - tmpmodel.Ogamma0 - tmpmodel.Onu0 - Ok0 universe = cosmology.LambdaCDM(H0=H0, Om0=Om0, Ode0=Ode0) elif isFlat: universe = cosmology.Flatw0waCDM(H0=H0, Om0=Om0, w0=w0, wa=wa) else: tmpmodel = cosmology.Flatw0waCDM(H0=H0, Om0=Om0, w0=w0, wa=wa) Ode0 = 1.0 - Om0 - tmpmodel.Ogamma0 - tmpmodel.Onu0 - Ok0 universe = cosmology.w0waCDM(H0=H0, Om0=Om0, Ode0=Ode0, w0=w0, wa=wa) self.setCurrent(universe)
print "Beginning" t0 = ti.time() for jj in np.arange(len(o_m_array)): o_m = o_m_array[jj] o_x = 1. - o_m for ii in np.arange(len(redshift_range)): dist_mods_functions[ii] = dist_mod_marg(redshift_range[ii], o_m, w0, wa) print "Functions done in", ti.time() - t0, "seconds" print dist_mods_functions[-10:] - dist_mods_functions[-11:-1] t0 = ti.time() for ii in np.arange(len(o_m_array)): cpl = cosmo.w0waCDM(H0=hubble_const, Om0=o_m_array[ii], Ode0=o_x, w0=w0, wa=wa) dist_mods_astropy = cpl.distmod(redshift_range) print "Astropy done in", ti.time() - t0, "seconds" print dist_mods_astropy[-10:] - dist_mods_astropy[-11:-1] print(dist_mods_functions[:10] - dist_mods_functions[1:11] ) - np.array(dist_mods_astropy[:10] - dist_mods_astropy[1:11]) '''Here we test the performance of functions against astropy for n=3 nCPL''' ''' import Flatn3CPL import time as ti redshift_range = np.linspace(0.001, 10, 30) dist_mods_functions = np.zeros(len(redshift_range))
z_min = 0.0 #min redshift z_max = 3.0 #max redshift num_z = 100 z_array = np.linspace(z_min, z_max, num=num_z) hval = 1.0 """ ------------------- -***COSMOLOGIES***- ------------------- """ cosmo1 = w0waCDM(H0=100.*hval, Om0=1.0, Ode0=0.0 ) cosmo2 = w0waCDM(H0=100.*hval, Om0=0.25, Ode0=0.75, w0=-1) cosmo3 = w0waCDM(H0=100.*hval, Om0=0.25, Ode0=0.75, w0=-0.8) cosmo4 = w0waCDM(H0=100.*hval, Om0=0.25, Ode0=0.75, w0=-1.2) """ ------------------------- -***COMOVING DISTANCE***- ------------------------- """ comoving_d1_Mpc = cosmo1.comoving_distance(z_array) comoving_d2_Mpc = cosmo2.comoving_distance(z_array) comoving_d3_Mpc = cosmo3.comoving_distance(z_array) comoving_d4_Mpc = cosmo4.comoving_distance(z_array)
def cosmology(self, H0, Omega_m, Omega_l, w0, wa): cosmo = w0waCDM(H0=H0, Om0=Omega_m, Ode0=Omega_l, w0=w0, wa=wa) return cosmo
def column_deriv_m(redshift, mu_err, model, step): """Calculate a column derivative of your model. Define a matrix P such that P_ik = 1/sigma_i del(M(i, params)/del(param_k) and M=model. This column matrix holds k constant. Parameters ---------- redshift: float or list Redshift. mu_err: float or list Error in distance modulus. model: list List of cosmological model parameters. Order is [H0, om, ol, w0, wa]. step: list List of steps the cosmological model paramter will take when determining the derivative. If a given entry is zero, that parameter will be kept constant. Length must match the number of parameters in "model" variable. Returns ------- m: list List of theoretical distance modulus (mu) at a given redshift from the base cosmology. m_deriv: list List of derivatives for one parameter of the likelihood function at given redshifts. """ Ob0=0.022 Om0=model[1] Ode0 =model[2] cosmo = w0waCDM(model[0], Ob0, Om0, Ode0, model[3],model[4]) cosmo=assign_cosmo(cosmo, model) m = [] m_deriv = [] c = const.c.to('km/s') base_theory = cosmo.distmod(redshift) m = base_theory.value step_inds = np.where(step)[0] # look for non-zero step indices deriv = np.zeros(len(model)) if (step_inds.size==0): print('No steps taken, abort') exit else: for i, stepp in enumerate(step_inds): cosmo = assign_cosmo(cosmo, model) theory = np.zeros((1,2)) for count,j in enumerate([-1,1]): tempmodel = list(model) tempmodel[stepp] = model[stepp] + j*step[stepp] c = const.c.to('km/s') cosmo = assign_cosmo(cosmo, tempmodel) tmp = cosmo.distmod(redshift) theory[:,count] = tmp.value deriv[stepp] = (theory[:,1] - theory[:,0])/(2.*step[stepp]) m_deriv = 1.0/mu_err * deriv return m, m_deriv
# w0waCDM: cm cosmoconstants = {'H0':67.8, 'Om': 0.308, 'w0':-0.9, 'wa':0.2} cosmo = Cosmo() DL1 = cosmo.luminosity_distance(redshifts=redshifts, model='w0waCDM', units='cm', **cosmoconstants) cosmo = w0waCDM(H0=cosmoconstants['H0'], Om0=cosmoconstants['Om'], Ode0=1-cosmoconstants['Om'], w0=cosmoconstants['w0'], wa=cosmoconstants['wa']) DL2 = np.asarray(cosmo.luminosity_distance(redshifts)*u.Mpc.to(u.cm)) [print('%.6E %.6E %s'%(i,j, i==j)) for i,j in zip(DL1, DL2)] print(rms(abs(np.log10(DL1) - np.log10(DL2)))) pltLims = (np.min([DL1.min(), DL2.min()]), np.min([DL1.max(), DL2.max()])) plt.clf() plt.figure(figsize=(8,7)) plt.plot(DL1, DL2, 'r.') plt.plot(DL1, 1*DL1+0, 'k-', alpha=0.5) plt.xlim(*pltLims) plt.ylim(*pltLims) plt.show()
def __init__(self): self.cosmo = w0waCDM(70.0, 0.3, 0.7)
### The r_parallel grid that we will want to use r_par = np.logspace(np.log(min_sep), np.log(max_sep), num=nbins + 1, base=np.e) ## Redshift-distance conversion spline ### First, get the cosmology config1 = ConfigParser.RawConfigParser() config1.read(cosmology) cos_param_sec = 'cosmological_parameters' h0 = config1.getfloat(cos_param_sec, 'h0') omega_m = config1.getfloat(cos_param_sec, 'omega_m') omega_k = config1.getfloat(cos_param_sec, 'omega_k') omega_L = 1.0 - omega_m - omega_k w0 = config1.getfloat(cos_param_sec, 'w') wa = config1.getfloat(cos_param_sec, 'wa') ### Now set up the astropy cosmology object if w0 != -1.0 or wa != 0.0: cosmo = w0waCDM(100 * h0, omega_m, omega_L, w0=w0, wa=wa) else: cosmo = FlatLambdaCDM(100 * h0, omega_m) ### Finally, get distances at a grid of redshfits and use a spline to interpolate table_z, delta_z = np.linspace(0.0, 2.0, num=101, retstep=True) table_r = cosmo.comoving_distance(table_z).value dist = UnivariateSpline(table_z, table_r, s=0) invdist = UnivariateSpline(table_r, table_z, s=0) # Define output file paths save_dir = os.path.join( save_base, 'pc_nbins{}_smin{}_smax{}_b{}_ncen{}_z{}min{}_z{}max{}_nz{}_scatter{}'. format(nbins, min_sep, max_sep, b, ncen, zbf, zmin, zbf, zmax, nz, args.sigmaz)) if not os.path.exists(save_dir):