def container_setup(density=mass_hydrogen_cgs, current_redshift=0): # Set solver parameters my_chemistry = chemistry_data() my_chemistry.use_grackle = 1 my_chemistry.with_radiative_cooling = 0 my_chemistry.primordial_chemistry = 1 my_chemistry.metal_cooling = 0 my_chemistry.UVbackground = 0 my_chemistry.use_volumetric_heating_rate = 1 # Set units my_chemistry.comoving_coordinates = 1 my_chemistry.a_units = 1.0 my_chemistry.a_value = 1.0 / (1.0 + current_redshift) / \ my_chemistry.a_units my_chemistry.density_units = mass_hydrogen_cgs * \ (1 + current_redshift)**3 my_chemistry.length_units = cm_per_mpc # 1 Mpc in cm my_chemistry.time_units = sec_per_Myr # 1 Gyr in s my_chemistry.velocity_units = my_chemistry.a_units * \ (my_chemistry.length_units / my_chemistry.a_value) / \ my_chemistry.time_units # Call convenience function for setting up a fluid container. # This container holds the solver parameters, units, and fields. temperature = np.logspace(1, 6, 51) fc = setup_fluid_container(my_chemistry, density=density, temperature=temperature, converge=True) fc["volumetric_heating_rate"][:] = 1.e-24 # erg/s/cm^3 return fc
def test_tabulated_mmw_metal_dependence(): """ Make sure that increasing the metal mass fraction of a gas increases the mean molecular weight, when run in tabulated mode. """ grackle_dir = os.path.dirname( os.path.dirname( os.path.dirname(os.path.dirname(os.path.abspath(__file__))))) data_file_path = bytearray( os.sep.join([grackle_dir, "input", "CloudyData_UVB=HM2012.h5"]), 'utf-8') my_random_state = np.random.RandomState(723466) density_units = random_logscale(-28, -26, random_state=my_random_state) length_units = random_logscale(0, 2, random_state=my_random_state) time_units = random_logscale(0, 2, random_state=my_random_state) velocity_units = length_units / time_units current_redshift = 0. mmw_vals = [] for metal_mass_frac in [0., 0.02041]: # proper units my_chem = chemistry_data() my_chem.use_grackle = 1 my_chem.with_radiative_cooling = 0 my_chem.primordial_chemistry = 0 my_chem.metal_cooling = 1 my_chem.UVbackground = 1 my_chem.grackle_data_file = data_file_path my_chem.comoving_coordinates = 0 my_chem.a_units = 1.0 my_chem.a_value = 1.0 / (1.0 + current_redshift) / my_chem.a_units my_chem.density_units = density_units my_chem.length_units = length_units my_chem.time_units = time_units my_chem.velocity_units = velocity_units fc = setup_fluid_container(my_chem, converge=False, metal_mass_fraction=metal_mass_frac) fc.calculate_mean_molecular_weight() mmw_vals.append(fc['mu']) mmw_no_metals, mmw_with_metals = mmw_vals assert_array_less( mmw_no_metals, mmw_with_metals, ("The mmw didn't increase when the metal fraction of the gas was " "increased (for primordial_chemisty=0)"))
def plot_stuff(my_chemistry, density=1.6737352238051868e-24, plot_object=pyplot, **plot_args): print(my_chemistry.grackle_data_file) # Call convenience function for setting up a fluid container. # This container holds the solver parameters, units, and fields. temperature = np.logspace(1, 9, 200) fc = setup_fluid_container(my_chemistry, temperature=temperature, density=density, converge=True) print(my_chemistry.grackle_data_file) fc.calculate_temperature() fc.calculate_cooling_time() print(my_chemistry.grackle_data_file) density_proper = fc["density"] / \ (my_chemistry.a_units * my_chemistry.a_value)**(3*my_chemistry.comoving_coordinates) cooling_rate = fc.cooling_units * fc["energy"] / \ np.abs(fc["cooling_time"]) / density_proper data = {} t_sort = np.argsort(fc["temperature"]) for field in fc.density_fields: data[field] = yt.YTArray( fc[field][t_sort] * my_chemistry.density_units, "g/cm**3") data["energy"] = yt.YTArray(fc["energy"][t_sort], "erg/g") data["temperature"] = yt.YTArray(fc["temperature"][t_sort], "K") data["pressure"] = yt.YTArray(fc["pressure"][t_sort], "dyne/cm**2") data["cooling_time"] = yt.YTArray(fc["cooling_time"][t_sort], "s") data["cooling_rate"] = yt.YTArray(cooling_rate[t_sort], "erg*cm**3/s") plot_object.loglog(data["temperature"], data["cooling_rate"], **plot_args) plot_object.xlabel('T [K]') plot_object.ylabel('$\\Lambda$ [erg s$^{-1}$ cm$^{3}$]') # save data arrays as a yt dataset if 'PRIMORDIAL_CHEM' in os.environ: ds_name = 'cooling_rate.pc%s.h5' % os.environ['PRIMORDIAL_CHEM'] im_name = 'cooling_rate.pc%s.png' % os.environ['PRIMORDIAL_CHEM'] else: ds_name = 'cooling_rate.h5' im_name = 'cooling_rate.png' plot_object.savefig(im_name) print(im_name) return data
# Set units my_chemistry.comoving_coordinates = 0 # proper units my_chemistry.a_units = 1.0 my_chemistry.a_value = 1.0 / (1.0 + current_redshift) / \ my_chemistry.a_units my_chemistry.density_units = mass_hydrogen_cgs # rho = 1.0 is 1.67e-24 g my_chemistry.length_units = cm_per_mpc # 1 Mpc in cm my_chemistry.time_units = sec_per_Myr # 1 Gyr in s my_chemistry.set_velocity_units() # Call convenience function for setting up a fluid container. # This container holds the solver parameters, units, and fields. temperature = np.logspace(1, 9, 200) fc = setup_fluid_container(my_chemistry, temperature=temperature, converge=True) fc["specific_heating_rate"][:] = 0. fc["volumetric_heating_rate"][:] = 0. fc.calculate_temperature() fc.calculate_cooling_time() density_proper = fc["density"] / \ (my_chemistry.a_units * my_chemistry.a_value)**(3*my_chemistry.comoving_coordinates) cooling_rate = fc.chemistry_data.cooling_units * fc["energy"] / \ np.abs(fc["cooling_time"]) / density_proper data = {}
def test_proper_comoving_units_tabular(): """ Make sure proper and comoving units systems give the same answer with tabular cooling. """ grackle_dir = os.path.dirname( os.path.dirname( os.path.dirname(os.path.dirname(os.path.abspath(__file__))))) data_file_path = bytearray( os.sep.join([grackle_dir, "input", "CloudyData_UVB=HM2012.h5"]), 'utf-8') my_random_state = np.random.RandomState(19650909) for current_redshift in [0., 1., 3., 6., 9.]: # comoving units chem_c = chemistry_data() chem_c.use_grackle = 1 chem_c.with_radiative_cooling = 0 chem_c.primordial_chemistry = 0 chem_c.metal_cooling = 1 chem_c.UVbackground = 1 chem_c.grackle_data_file = data_file_path set_cosmology_units(chem_c, current_redshift=current_redshift, initial_redshift=99.) fc_c = setup_fluid_container(chem_c, converge=False) fc_c.calculate_temperature() fc_c.calculate_cooling_time() t_sort_c = np.argsort(fc_c["temperature"]) t_cool_c = fc_c["cooling_time"][t_sort_c] * chem_c.time_units # proper units chem_p = chemistry_data() chem_p.use_grackle = 1 chem_p.with_radiative_cooling = 0 chem_p.primordial_chemistry = 0 chem_p.metal_cooling = 1 chem_p.UVbackground = 1 chem_p.grackle_data_file = data_file_path chem_p.comoving_coordinates = 0 chem_p.a_units = 1.0 chem_p.a_value = 1.0 / (1.0 + current_redshift) / chem_p.a_units # Set the proper units to be of similar magnitude to the # comoving system to help the solver be more efficient. chem_p.density_units = random_logscale(-2, 2, random_state=my_random_state) * \ chem_c.density_units / (1 + current_redshift)**3 chem_p.length_units = random_logscale(-2, 2, random_state=my_random_state) * \ chem_c.length_units * (1 + current_redshift) chem_p.time_units = random_logscale(-2, 2, random_state=my_random_state) * \ chem_c.time_units chem_p.velocity_units = chem_p.length_units / chem_p.time_units fc_p = setup_fluid_container(chem_p, converge=False) fc_p.calculate_temperature() fc_p.calculate_cooling_time() t_sort_p = np.argsort(fc_p["temperature"]) t_cool_p = fc_p["cooling_time"][t_sort_p] * chem_p.time_units comp = "\nDU1: %e, LU1: %e, TU1: %e - DU2: %e, LU2: %e, TU2L %e." % \ (chem_p.density_units, chem_p.length_units, chem_p.time_units, chem_c.density_units, chem_c.length_units, chem_c.time_units) assert_rel_equal( t_cool_p, t_cool_c, 4, (("Proper and comoving tabular cooling times disagree for " + "z = %f with min/max = %f/%f.\n") % (current_redshift, (t_cool_p / t_cool_c).min(), (t_cool_p / t_cool_c).max()) + comp))
def test_proper_units(): """ Make sure two different proper units systems give the same answer. """ grackle_dir = os.path.dirname( os.path.dirname( os.path.dirname(os.path.dirname(os.path.abspath(__file__))))) data_file_path = bytearray( os.sep.join([grackle_dir, "input", "CloudyData_UVB=HM2012.h5"]), 'utf-8') my_random_state = np.random.RandomState(20150725) for current_redshift in [0., 1., 3.]: # proper units chem_1 = chemistry_data() chem_1.use_grackle = 1 chem_1.with_radiative_cooling = 0 chem_1.primordial_chemistry = 1 chem_1.metal_cooling = 1 chem_1.UVbackground = 1 chem_1.grackle_data_file = data_file_path chem_1.comoving_coordinates = 0 chem_1.a_units = 1.0 chem_1.a_value = 1.0 / (1.0 + current_redshift) / chem_1.a_units chem_1.density_units = random_logscale(-1, 1, random_state=my_random_state) chem_1.length_units = random_logscale(0, 2, random_state=my_random_state) chem_1.time_units = random_logscale(0, 2, random_state=my_random_state) chem_1.velocity_units = chem_1.length_units / chem_1.time_units fc_1 = setup_fluid_container(chem_1, converge=False) fc_1.calculate_temperature() fc_1.calculate_cooling_time() t_sort_1 = np.argsort(fc_1["temperature"]) t_cool_1 = fc_1["cooling_time"][t_sort_1] * chem_1.time_units # proper units chem_2 = chemistry_data() chem_2.use_grackle = 1 chem_2.with_radiative_cooling = 0 chem_2.primordial_chemistry = 1 chem_2.metal_cooling = 1 chem_2.UVbackground = 1 chem_2.grackle_data_file = data_file_path chem_2.comoving_coordinates = 0 chem_2.a_units = 1.0 chem_2.a_value = 1.0 / (1.0 + current_redshift) / chem_2.a_units chem_2.density_units = random_logscale(-28, -26, random_state=my_random_state) chem_2.length_units = random_logscale(0, 2, random_state=my_random_state) chem_2.time_units = random_logscale(0, 2, random_state=my_random_state) chem_2.velocity_units = chem_2.length_units / chem_2.time_units fc_2 = setup_fluid_container(chem_2, converge=False) fc_2.calculate_temperature() fc_2.calculate_cooling_time() t_sort_2 = np.argsort(fc_2["temperature"]) t_cool_2 = fc_2["cooling_time"][t_sort_2] * chem_2.time_units comp = "\nDU1: %e, LU1: %e, TU1: %e - DU2: %e, LU2: %e, TU2L %e." % \ (chem_1.density_units, chem_1.length_units, chem_1.time_units, chem_2.density_units, chem_2.length_units, chem_2.time_units) assert_rel_equal( t_cool_1, t_cool_2, 4, (("Different proper unit system cooling times disagree for " + "z = %f with min/max = %f/%f.") % (current_redshift, (t_cool_1 / t_cool_2).min(), (t_cool_1 / t_cool_2).max()) + comp))
def test_equilibrium(): """ Test ionization equilibrium for a primordial gas against the analytical solution using the same rates. This test takes a long time because the iteration to convergence near T = 1e4 K is slow. """ my_chem = chemistry_data() my_chem.use_grackle = 1 my_chem.with_radiative_cooling = 0 my_chem.primordial_chemistry = 1 my_chem.metal_cooling = 0 my_chem.UVbackground = 0 my_chem.comoving_coordinates = 0 my_chem.a_units = 1.0 my_chem.a_value = 1.0 my_chem.density_units = mass_hydrogen_cgs my_chem.length_units = 1.0 my_chem.time_units = 1.0 my_chem.velocity_units = my_chem.length_units / my_chem.time_units fc = setup_fluid_container(my_chem, temperature=np.logspace(4.5, 9, 200), converge=True, tolerance=1e-6, max_iterations=np.inf) fc.calculate_temperature() fc.calculate_cooling_time() t_sort = np.argsort(fc["temperature"]) t_cool = fc["cooling_time"][t_sort] * my_chem.time_units my_T = fc["temperature"][t_sort] my_nH = fc.calculate_hydrogen_number_density().mean() cooling_rate_eq = -1 * total_cooling(my_T, my_nH) / my_nH**2 cooling_rate_g = fc["energy"][t_sort] / t_cool * fc["density"] * \ my_chem.density_units / my_nH**2 # Make a cooling rate figure fontsize = 14 axes = pyplot.axes() axes.loglog(my_T, -1 * cooling_rate_eq, color='black', alpha=0.7, linestyle="--", linewidth=1.5) axes.loglog(my_T, -1 * cooling_rate_g, color='black', alpha=0.7, linestyle="-", linewidth=1) axes.xaxis.set_label_text('T [K]', fontsize=fontsize) axes.yaxis.set_label_text( r'$-\Lambda$ / n${_{\rm H}}^{2}$ [erg s$^{-1}$ cm$^{3}$]', fontsize=fontsize) axes.set_xlim(1e4, 1e9) axes.set_ylim(1e-26, 2e-22) tick_labels = axes.xaxis.get_ticklabels() + \ axes.yaxis.get_ticklabels() for tick_label in tick_labels: tick_label.set_size(fontsize) pyplot.savefig('cooling.png') pyplot.clf() # Make an ionization balance figure nH_eq = nHI(my_T, my_nH) + nHII(my_T, my_nH) nH_g = fc["HI"] + fc["HII"] fHI_eq = nHI(my_T, my_nH) / nH_eq fHI_g = fc["HI"] / nH_g fHII_eq = nHII(my_T, my_nH) / nH_eq fHII_g = fc["HII"] / nH_g nHe_eq = nHeI(my_T, my_nH) + nHeII(my_T, my_nH) + nHeIII(my_T, my_nH) nHe_g = fc["HeI"] + fc["HeII"] + fc["HeIII"] fHeI_eq = nHeI(my_T, my_nH) / nHe_eq fHeI_g = fc["HeI"] / nHe_g fHeII_eq = nHeII(my_T, my_nH) / nHe_eq fHeII_g = fc["HeII"] / nHe_g fHeIII_eq = nHeIII(my_T, my_nH) / nHe_eq fHeIII_g = fc["HeIII"] / nHe_g # Plot H ions axes = pyplot.axes() axes.loglog(my_T, fHI_eq, color="#B82E00", alpha=0.7, linestyle="--", linewidth=1.5) axes.loglog(my_T, fHII_eq, color="#B88A00", alpha=0.7, linestyle="--", linewidth=1.5) axes.loglog(my_T, fHI_g, label="HI", color="#B82E00", alpha=0.7, linestyle="-", linewidth=1.) axes.loglog(my_T, fHII_g, label="HII", color="#B88A00", alpha=0.7, linestyle="-", linewidth=1.) # Plot He ions axes.loglog(my_T, fHeI_eq, color="#002EB8", alpha=0.7, linestyle="--", linewidth=1.5) axes.loglog(my_T, fHeII_eq, color="#008AB8", alpha=0.7, linestyle="--", linewidth=1.5) axes.loglog(my_T, fHeIII_eq, color="#00B88A", alpha=0.7, linestyle="--", linewidth=1.5) axes.loglog(my_T, fHeI_g, label="HeI", color="#002EB8", alpha=0.7, linestyle="-", linewidth=1.) axes.loglog(my_T, fHeII_g, label="HeII", color="#008AB8", alpha=0.7, linestyle="-", linewidth=1.) axes.loglog(my_T, fHeIII_g, label="HeIII", color="#00B88A", alpha=0.7, linestyle="-", linewidth=1.) axes.xaxis.set_label_text('T [K]', fontsize=fontsize) axes.yaxis.set_label_text('fraction', fontsize=fontsize) axes.set_xlim(1e4, 1e9) axes.set_ylim(1e-10, 1) tick_labels = axes.xaxis.get_ticklabels() + \ axes.yaxis.get_ticklabels() for tick_label in tick_labels: tick_label.set_size(fontsize) axes.legend(loc='best', prop=dict(size=fontsize)) pyplot.savefig('fractions.png') test_precision = 1 # test the cooling rates cool_ratio = cooling_rate_eq / cooling_rate_g assert_rel_equal( cooling_rate_eq, cooling_rate_g, test_precision, "Equilibrium cooling rates disagree with min/max = %f/%f." % (cool_ratio.min(), cool_ratio.max())) # test the ionization balance assert_rel_equal( fHI_eq, fHI_g, test_precision, "HI fractions disagree with min/max = %f/%f." % ((fHI_eq / fHI_g).min(), (fHI_eq / fHI_g).max())) assert_rel_equal( fHII_eq, fHII_g, test_precision, "HII fractions disagree with min/max = %f/%f." % ((fHII_eq / fHII_g).min(), (fHII_eq / fHII_g).max())) assert_rel_equal( fHeI_eq, fHeI_g, test_precision, "HeI fractions disagree with min/max = %f/%f." % ((fHeI_eq / fHeI_g).min(), (fHeI_eq / fHeI_g).max())) assert_rel_equal( fHeII_eq, fHeII_g, test_precision, "HeII fractions disagree with min/max = %f/%f." % ((fHeII_eq / fHeII_g).min(), (fHeII_eq / fHeII_g).max())) assert_rel_equal( fHeIII_eq, fHeIII_g, test_precision, "HeIII fractions disagree with min/max = %f/%f." % ((fHeIII_eq / fHeIII_g).min(), (fHeIII_eq / fHeIII_g).max()))