def registration_dust_masses( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Registers the masses in dust within apertures """ unit = unit_system.mass # Capture aperture size match_string = "Aperture_([a-zA-Z]*)_aperture_total_gas_([0-9]*)_kpc" regex = cached_regex(match_string) match = regex.match(field_path) if match: long_species = match.group(1) aperture_size = match.group(2) try: short_species = { "GraphiteMasses": "graphite", "SilicatesMasses": "silicates", }[long_species] except KeyError: raise RegistrationDoesNotMatchError full_name = f"{short_species} Dust Mass ({aperture_size} kpc)" snake_case = f"{short_species}_mass_{aperture_size}_kpc" return unit, full_name, snake_case else: raise RegistrationDoesNotMatchError
def registration_snii_thermal_feedback_densities( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ SNII thermal feedback density registrations. """ if (not field_path[:14] == "DensitiesAtLastSupernovaEvent" and field_path[-4:] == "gas"): raise RegistrationDoesNotMatchError unit = unit_system.mass / unit_system.length**3 # Need to do a regex search (average, min, max) match_string = "DensitiesAtLastSupernovaEvent_([a-z]+)_gas" regex = cached_regex(match_string) match = regex.match(field_path) if match: minmax = match.group(1) full_name = f"SNII Thermal Feedback Density ({minmax})" snake_case = minmax.lower() return unit, full_name, snake_case else: raise RegistrationDoesNotMatchError return
def registration_black_hole_masses( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Sub-grid black hole property registrations. """ if not field_path[:13] == "SubgridMasses" and field_path[-2:] == "bh": raise RegistrationDoesNotMatchError unit = unit_system.mass # Need to do a regex search # Capture group 1: average, min, max. # Capture group 2: optional _solar_mass part - backwards compat. match_string = "SubgridMasses_([a-z]+)(_solar_mass|)_bh" regex = cached_regex(match_string) match = regex.match(field_path) if match: minmax = match.group(1) full_name = f"Subgrid Black Hole Mass ({minmax})" snake_case = minmax.lower() return unit, full_name, snake_case else: raise RegistrationDoesNotMatchError return
def registration_stellar_birth_densities( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Stellar birth density registrations. """ if not field_path[:14] == "BirthDensities" and field_path[-4:] == "star": raise RegistrationDoesNotMatchError unit = unit_system.mass / unit_system.length**3 # Need to do a regex search (average, min, max) match_string = "BirthDensities_([a-z]+)_star" regex = cached_regex(match_string) match = regex.match(field_path) if match: minmax = match.group(1) full_name = f"Stellar Birth Density ({minmax})" snake_case = minmax.lower() return unit, full_name, snake_case else: raise RegistrationDoesNotMatchError return
def registration_eigenvectors( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Registers eigenvector quantities (those beginning with eig). """ if not field_path[:3] == "eig": raise RegistrationDoesNotMatchError unit = unit_system.length # Need to do a regex search # Capture group 1: xy, etc. # Capture group 2: gas/star. match_string = "eig_([a-z][a-z])_?([a-z]*)?" regex = cached_regex(match_string) match = regex.match(field_path) if match: coordinate = match.group(1) ptype = match.group(2) full_name = f"$\\hat{{r}}_{{{{\\rm v}}, {coordinate.lower()}}}$" if ptype: full_name += f" ({ptype})" else: raise RegistrationDoesNotMatchError return unit, full_name, field_path.lower()
def registration_hydrogen_phase_fractions( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Registers the phase fractions for hydrogen. """ if field_path[:8] != "Hydrogen": raise RegistrationDoesNotMatchError unit = unyt.dimensionless # Need to do a regex search # Capture group 1: ionized # Capture group 2: massweighted # Capture group 3: units # Capture group 4: particle type match_string = "Hydrogen([a-zA-Z]+)Fractions_([a-zA-Z]+)_([a-zA-Z]+)_?([a-z]*)" regex = cached_regex(match_string) match = regex.match(field_path) if match: ionized = match.group(1) mass_weighted = match.group(2) extracted_units = match.group(3) ptype = match.group(4) full_name = f"Hydrogen {ionized} Fraction" snake_case = ionized.lower() return unit, full_name, snake_case else: raise RegistrationDoesNotMatchError
def registration_stellar_luminosities( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Registers the luminosities within apertures """ unit = unyt.dimensionless # Capture aperture size match_string = ( "Aperture_Luminosities_index_([0-9]?)_aperture_total_star_([0-9]*)_kpc" ) regex = cached_regex(match_string) match = regex.match(field_path) if match: bands = ["u", "g", "r", "i", "z", "Y", "J", "H", "K"] band = bands[int(match.group(1))] aperture_size = match.group(2) full_name = f"{band}-Band Luminosity ({aperture_size} kpc)" snake_case = f"{band}_luminosity_{aperture_size}_kpc" return unit, full_name, snake_case else: raise RegistrationDoesNotMatchError
def registration_veldisp( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Registers velocity dispersion quantities (those beginning with veldisp). """ if not field_path[:7] == "veldisp": raise RegistrationDoesNotMatchError unit = unit_system.velocity # Need to do a regex search # Capture group 1: xy, etc. # Capture group 2: gas/star. match_string = "veldisp_([a-z][a-z])_?([a-z]*)?" regex = cached_regex(match_string) match = regex.match(field_path) if match: coordinate = match.group(1) ptype = match.group(2) full_name = f"$\sigma_{{{{\\rm v}}, {coordinate.lower()}}}$" if ptype: full_name += f" ({ptype})" else: raise RegistrationDoesNotMatchError return unit, full_name, field_path.lower()
def registration_angular_momentum( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Registers values starting with L, those that represent angular momenta. """ if not field_path[0] == "L": raise RegistrationDoesNotMatchError # All are angular momenta, so have same units. unit = unit_system.length * unit_system.velocity # Capture group 1: axis (x, y, z) # Capture group 2: radius within this was calculated, e.g. 200crit # Capture group 3: excluding or not excluding # Capture group 4: particle type # Capture group 5: star forming? match_string = "L([a-z])_?([A-Z]*[0-9]+[a-z]*)?_?(excl)?_?([a-z]*)_?([a-z]*)" regex = cached_regex(match_string) match = regex.match(field_path) if match: axis = match.group(1) radius = match.group(2) excluding = match.group(3) ptype = match.group(4) star_forming = match.group(5) full_name = "$L_{" if axis: full_name += axis if radius: full_name += f", {{\\rm {radius}}}" full_name += "}$" if ptype: full_name += " (" if excluding: full_name += "Excl. " cap_ptype = ptype[0].upper() + ptype[1:] full_name += cap_ptype if star_forming: full_name += f", {star_forming.upper()}" full_name += ")" else: raise RegistrationDoesNotMatchError return unit, full_name, field_path.lower()
def registration_log_element_ratios_times_masses( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Registers the log10(Fe/H) times mass and log10(O/H) times mass within apertures for two particle floor values """ unit = unit_system.mass # Capture aperture size match_string = ( "Aperture_([a-zA-Z]*)Masses(Lo|Hi)Floor_aperture_total_([a-zA-Z]*)_([0-9]*)_kpc" ) regex = cached_regex(match_string) match = regex.match(field_path) if match: long_species = match.group(1) floor_type = match.group(2) part_type = match.group(3) aperture_size = match.group(4) try: short_species = { "LogOxygenOverHydrogen": "O_over_H", "LogIronOverHydrogen": "Fe_over_H", }[long_species] element_name = { "LogOxygenOverHydrogen": "Oxygen", "LogIronOverHydrogen": "Iron", }[long_species] fraction_name = { "LogOxygenOverHydrogen": "O/H", "LogIronOverHydrogen": "Fe/H", }[long_species] short_floortype = { "Lo": "lowfloor", "Hi": "highfloor", }[floor_type] floor_value = { "Lo": "-4", "Hi": "-3", }[floor_type] except KeyError: raise RegistrationDoesNotMatchError full_name = ( f"Log10 {element_name} Abundance Weighted {part_type.capitalize()} Mass ({fraction_name}) " f"$\times M_{{\\rm gas}}$, from particle values floored at [{fraction_name}]$\\gtreq {floor_value}$ " f"({aperture_size} kpc)") snake_case = f"log_{short_species}_times_{part_type}_mass_{short_floortype}_{aperture_size}_kpc" return unit, full_name, snake_case else: raise RegistrationDoesNotMatchError
def registration_radii( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Registration for all radii quantities (start with R_) """ # First, two special cases. if field_path == "Rvir": full_name = "$R_{\\rm vir}$" elif field_path == "Rmax": full_name = "$R_{\\rm max}$" elif field_path[:2] != "R_": raise RegistrationDoesNotMatchError unit = unit_system.length # Capture group 1: Characteristic scale # Capture group 2: Excluding? # Capture group 3: particle type # Capture group 4: star forming? match_string = "R_([a-zA-Z0-9]*)_?(excl)?_?([a-z]*)?_?(sf|nsf)?" regex = cached_regex(match_string) match = regex.match(field_path) if match: radius = match.group(1) excluding = match.group(2) ptype = match.group(3) star_forming = match.group(4) full_name = "$R" if radius: full_name += f"_{{\\rm {radius}}}" full_name += "$" if ptype: full_name += " (" if excluding: full_name += "Excl. " cap_ptype = ptype[0].upper() + ptype[1:] full_name += cap_ptype if star_forming: full_name += f", {star_forming.upper()}" full_name += ")" return unit, full_name, field_path.lower()
def registration_velocities( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Registers velocity quantities (those starting with V). """ if not field_path[0] == "V": raise RegistrationDoesNotMatchError unit = unit_system.velocity if field_path == "Vmax": # Special case, handle here full_name = "$V_{\\rm max}$" else: # Need to do a regex search # Capture group 1: X, Y, Z # Capture group 2: mbp or minpot? Could be empty. # Capture group 4: gas/star. match_string = "V(X|Y|Z)c([a-z]*)?(_([a-z]*))?" regex = cached_regex(match_string) match = regex.match(field_path) if match: coordinate = match.group(1) ptype = match.group(4) misc = match.group(2) full_name = f"$V_{coordinate.lower()}$" if ptype: full_name += f" ({ptype})" if misc: if misc == "mbp": full_name = f"Most bound particle {full_name}" elif misc == "minpot": full_name = f"Minimum potential {full_name}" else: full_name = f"{misc} {full_name}" else: full_name = "CoM " + full_name else: raise RegistrationDoesNotMatchError return unit, full_name, field_path.lower()
def registration_gas_hydrogen_species_masses( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Registers the masses in hydrogen species within apertures. """ unit = unit_system.mass # Capture aperture size match_string = "Aperture_([a-zA-Z]*)_aperture_total_gas_([0-9]*)_kpc" regex = cached_regex(match_string) match = regex.match(field_path) if match: long_species = match.group(1) aperture_size = match.group(2) try: short_species = { "AtomicHydrogenMasses": "HI", "IonisedHydrogenMasses": "HII", "MolecularHydrogenMasses": "H2", }[long_species] full_name_species = { "AtomicHydrogenMasses": "HI", "IonisedHydrogenMasses": "HII", "MolecularHydrogenMasses": "H$_2$", }[long_species] math_name_species = { "AtomicHydrogenMasses": "$M_{\\rm HI}$", "IonisedHydrogenMasses": "$M_{\\rm HII}$", "MolecularHydrogenMasses": "$M_{\\rm H_2}$", }[long_species] except KeyError: raise RegistrationDoesNotMatchError full_name = ( f"{full_name_species} Gas Mass {math_name_species} ({aperture_size} kpc)" ) snake_case = f"{short_species}_mass_{aperture_size}_kpc" return unit, full_name, snake_case else: raise RegistrationDoesNotMatchError
def registration_element_mass_fractions( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Registers the element mass fraction properties. Hopefully this is changed in the future as this is a mess. """ if not field_path[:20] == "ElementMassFractions": raise RegistrationDoesNotMatchError unit = unit_system.metallicity # Need to do a regex search # Capture group 1,2: index number - if not present default to 0 # Capture group 3: mass weighted? # Capture group 4: units # Capture group 5: particle typr match_string = ( "ElementMassFractions(_index_)?([0-9]*)_([a-zA-Z]+)_([a-zA-Z]+)_?([a-z]*)" ) regex = cached_regex(match_string) match = regex.match(field_path) snake_case = "element" if match: index = match.group(2) if match.group(2) else 0 mass_weighted = match.group(3) extracted_units = match.group(4) ptype = match.group(5) full_name = f"Element {index} Mass Fraction" snake_case = f"{snake_case}_{index}" if ptype: cap_ptype = ptype[0].upper() + ptype[1:] full_name = f"{cap_ptype} {full_name}" snake_case += f"_{ptype}" else: raise RegistrationDoesNotMatchError return unit, full_name, snake_case
def registration_lin_element_ratios_times_masses( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Registers the Fe/H times mass and O/H times mass within apertures for two particle floor values """ unit = unit_system.mass # Capture aperture size match_string = "Aperture_([a-zA-Z]*)Masses_aperture_total_([a-zA-Z]*)_([0-9]*)_kpc" regex = cached_regex(match_string) match = regex.match(field_path) if match: long_species = match.group(1) part_type = match.group(2) aperture_size = match.group(3) try: short_species = { "TotalOxygenOverHydrogen": "O_over_H_total", "OxygenOverHydrogen": "O_over_H", "IronOverHydrogen": "Fe_over_H", }[long_species] element_name = { "TotalOxygenOverHydrogen": "Oxygen", "OxygenOverHydrogen": "Oxygen", "IronOverHydrogen": "Iron", }[long_species] fraction_name = { "TotalOxygenOverHydrogen": "O/H", "OxygenOverHydrogen": "O/H", "IronOverHydrogen": "Fe/H", }[long_species] except KeyError: raise RegistrationDoesNotMatchError full_name = ( f"Linear {element_name} Abundance Weighted {part_type.capitalize()} Mass ({fraction_name}) " f"$\times M_{{\\rm gas}}$ ({aperture_size} kpc)") snake_case = f"lin_{short_species}_times_{part_type}_mass_{aperture_size}_kpc" return unit, full_name, snake_case else: raise RegistrationDoesNotMatchError
def registration_positions( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Registers all positon based quantities (those beginning with X, Y, or Z). """ if not field_path[0] in ["X", "Y", "Z"] and not field_path[:4] == "Zmet": raise RegistrationDoesNotMatchError # All position quantities have units of length unit = unit_system.length # Capture group 1: x, y, or z # Capture group 2: ignore # Capture group 3: ptype # Capture group 4: misc info, e.g. mbp or minpot match_string = "(X|Y|Z)c(_([a-z]*))?([a-z]*)?" regex = cached_regex(match_string) match = regex.match(field_path) if match: coordinate = match.group(1) ptype = match.group(3) misc = match.group(4) full_name = f"${coordinate.lower()}$" if ptype: full_name += f" ({ptype})" if misc: if misc == "mbp": full_name = f"Most bound particle {full_name}" elif misc == "minpot": full_name = f"Minimum potential {full_name}" else: full_name = f"{misc} {full_name}" else: full_name = "CoM " + full_name else: raise RegistrationDoesNotMatchError return unit, full_name, field_path.lower()
def registration_gas_diffuse_element_masses( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Registers the masses in Hydrogen & Helium within apertures """ unit = unit_system.mass # Capture aperture size match_string = "Aperture_Diffuse([a-zA-Z]*)MassesFrom(Table|Model)_aperture_total_gas_([0-9]*)_kpc" regex = cached_regex(match_string) match = regex.match(field_path) if match: element = match.group(1) table_model = match.group(2) aperture_size = match.group(3) try: long_name_element = ( f"Diffuse {element} from depletion {table_model.lower()}") element_symbol = { "Carbon": "C", "Oxygen": "O", "Magnesium": "Mg", "Silicon": "Si", "Iron": "Fe", }[element] math_name = ( f"M^{{\\rm {table_model.lower()}}}_{{\\rm {element_symbol}, diffuse}}" ) except KeyError: raise RegistrationDoesNotMatchError full_name = ( f"{element} ({table_model}) Gas Mass {element_symbol} ({aperture_size} kpc)" ) snake_case = f"{element.lower()}_mass_{table_model.lower()}_{aperture_size}_kpc" return unit, full_name, snake_case else: raise RegistrationDoesNotMatchError
def registration_metallicity( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Registers metallicity-based quantities (those beginning with Zmet) """ if not field_path[:4] == "Zmet": raise RegistrationDoesNotMatchError unit = unit_system.metallicity # Need to do a regex search # Capture group 1: gas/star. # Capture group 2: star forming? match_string = "Zmet_?([a-z]*)_?(sf|nsf)?" regex = cached_regex(match_string) match = regex.match(field_path) if match: ptype = match.group(1) star_forming = match.group(2) full_name = "Metallicity $Z" if ptype: if ptype == "gas": full_name += "_g" elif ptype == "star": full_name += "_*" cap_ptype = ptype[0].upper() + ptype[1:] full_name = f"{cap_ptype} {full_name}" full_name += "$" if star_forming: full_name += f" ({star_forming.upper()})" else: raise RegistrationDoesNotMatchError return unit, full_name, field_path.lower()
def registration_gas_H_and_He_masses( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Registers the masses in Hydrogen & Helium within apertures """ unit = unit_system.mass # Capture aperture size match_string = "Aperture_([a-zA-Z]*)_aperture_total_gas_([0-9]*)_kpc" regex = cached_regex(match_string) match = regex.match(field_path) if match: long_species = match.group(1) aperture_size = match.group(2) try: short_species = { "HeliumMasses": "He", "HydrogenMasses": "H" }[long_species] long_name_species = { "HeliumMasses": "Helium", "HydrogenMasses": "Hydrogen", }[long_species] math_name = { "HeliumMasses": "M_{\\rm He}", "HydrogenMasses": "M_{\\rm H}" }[long_species] except KeyError: raise RegistrationDoesNotMatchError full_name = f"{long_name_species} Gas Mass {math_name} ({aperture_size} kpc)" snake_case = f"{short_species}_mass_{aperture_size}_kpc" return unit, full_name, snake_case else: raise RegistrationDoesNotMatchError
def registration_gas_element_ratios_times_masses( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Registers the Fe/H times mass and O/H times mass within apertures """ unit = unit_system.mass # Capture aperture size match_string = "Aperture_([a-zA-Z]*)_aperture_total_gas_([0-9]*)_kpc" regex = cached_regex(match_string) match = regex.match(field_path) if match: long_species = match.group(1) aperture_size = match.group(2) try: short_species = { "OxygenOverHydrogenMasses": "O_over_H", "IronOverHydrogenMasses": "Fe_over_H", }[long_species] element_name = { "OxygenOverHydrogenMasses": "Oxygen", "IronOverHydrogenMasses": "Iron", }[long_species] fraction_name = { "OxygenOverHydrogenMasses": "(O/H)", "IronOverHydrogenMasses": "(Fe/H)", }[long_species] except KeyError: raise RegistrationDoesNotMatchError full_name = f"{element_name} Abundance Weighted Gas Mass {fraction_name}$\times M_{{\\rm gas}}$ ({aperture_size} kpc)" snake_case = f"{short_species}_times_gas_mass_{aperture_size}_kpc" return unit, full_name, snake_case else: raise RegistrationDoesNotMatchError
def registration_projected_apertures( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Registers aperture values by searching them with regex. """ # Capture group 1: aperture number # Capture group 2: quantity # Capture group 3: particle type # Capture group 4: sf / nsf # Capture group 5: size of aperture match_string = ( "Projected_aperture_([0-9])_([^_]*)_([a-zA-Z]*)?_?([a-zA-Z]*)?_?([0-9]*)_kpc" ) regex = cached_regex(match_string) match = regex.match(field_path) if match: aperture = match.group(1) quantity = match.group(2) ptype = match.group(3) star_forming = match.group(4) aperture_size = int(match.group(5)) unit = get_aperture_unit(quantity, unit_system) name = get_particle_property_name_conversion(quantity, ptype) if star_forming: sf_in_name = f"{star_forming.upper()} " else: sf_in_name = "" full_name = f"{sf_in_name}{name} (Projection {aperture}, {aperture_size} kpc)" snake_case = field_path.lower().replace("aperture_", "") return unit, full_name, snake_case else: raise RegistrationDoesNotMatchError
def registration_rotational_support( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Registers rotational support quantities (those beginning with K). Note that this corresponds to \kappa in Sales+2010 _not_ K. """ if not field_path[0] == "K": raise RegistrationDoesNotMatchError # All quantities are ratios and so are dimensionless unit = unyt.dimensionless # Capture group 1: particle type # Capture group 2: star forming / not star forming match_string = "Krot_?([a-z]*)_?([a-z]*)?" regex = cached_regex(match_string) match = regex.match(field_path) if match: ptype = match.group(1) star_forming = match.group(2) full_name = "$\\kappa_{{\\rm rot}" if ptype: full_name += f", {{\\rm {ptype}}}" full_name += "}$" if star_forming: full_name += f" ({star_forming.upper()})" else: raise RegistrationDoesNotMatchError return unit, full_name, field_path.lower()
def registration_rvmax_quantities( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Registration for all quantities measured within RVmax (Start with RVmax) """ if not field_path[:5] == "RVmax": raise RegistrationDoesNotMatchError # Capture group 1: Eigenvector or velocity dispersion # Capture group 2: xx, xy, etc. for above # Capture group 3: Angular momentum quantity # Capture group 4: x, y, z for angular momentum # Capture group 5: catch all others match_string = "RVmax_((eig|veldisp)_([a-z]{2}))?_?(L([a-z]))?_?([a-zA-Z0-9_]*)" regex = cached_regex(match_string) match = regex.match(field_path) if match: raise RegistrationDoesNotMatchError return # TODO
def registration_spherical_overdensities( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Registers SO aperture values by searching them with regex. """ # Capture group 1: quantity # Capture group 2: particle type # Capture group 3: sf / nsf # Capture group 4: size of aperture match_string = "SO_([^_]*)_([a-zA-Z]*)?_?([a-zA-Z]*)?_?([0-9]*)_rhocrit" regex = cached_regex(match_string) match = regex.match(field_path) if match: quantity = match.group(1) ptype = match.group(2) star_forming = match.group(3) aperture_size = int(match.group(4)) unit = get_aperture_unit(quantity, unit_system) name = get_particle_property_name_conversion(quantity, ptype) if star_forming: sf_in_name = f"{star_forming.upper()} " else: sf_in_name = "" full_name = f"{sf_in_name}{name} ({aperture_size} $\\rho_{{\\rm crit}}$)" snake_case = field_path.lower().replace("so_", "") return unit, full_name, snake_case else: raise RegistrationDoesNotMatchError
def registration_temperature( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Registers temperature based quantites (Those beginning with T). """ if not field_path[0] == "T": raise RegistrationDoesNotMatchError unit = unyt.K # Capture group 1: particle type # Capture group 2: star forming? match_string = "T_?([a-z]*)?_?(sf|nsf)?" regex = cached_regex(match_string) match = regex.match(field_path) if match: ptype = match.group(1) star_forming = match.group(2) full_name = "$T$" if ptype: full_name += " (" cap_ptype = ptype[0].upper() + ptype[1:] full_name += cap_ptype if star_forming: full_name += f", {star_forming.upper()}" full_name += ")" return unit, full_name, field_path.lower()
def registration_cold_dense_gas_properties( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Registers the mass of cold (T < 10^4.5 K), dense (nH > 0.1 cm^-3) gas in apertures. """ unit = unit_system.mass # Capture aperture size match_string = "Aperture_ColdDense([a-zA-Z]*)Masses_aperture_total_gas_([0-9]*)_kpc" regex = cached_regex(match_string) match = regex.match(field_path) if match: quantity_key = match.group(1) aperture_size = match.group(2) try: long_quantity = { "DiffuseMetal": "Diffuse Metal", "Gas": "Gas", }[quantity_key] short_quantity = { "DiffuseMetal": "diffuse_metal", "Gas": "gas", }[quantity_key] except KeyError: raise RegistrationDoesNotMatchError full_name = ( f"{long_quantity} Masses in Cold, Dense ($T < 10^{{4.5}}\;{{\rm K}}$, " f"$n_{{\\rm H}}$ > 0.1 \\; {{\rm cm^{{-3}}}}$) Gas ({aperture_size} kpc)" ) snake_case = f"cold_dense_{short_quantity}_mass_{aperture_size}_kpc" return unit, full_name, snake_case else: raise RegistrationDoesNotMatchError
def registration_dust_masses_from_table( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Registers the dust mass fraction properties. """ if not field_path[:28] == "Aperture_DustMassesFromTable": raise RegistrationDoesNotMatchError unit = unit_system.mass match_string = "Aperture_DustMassesFromTable_aperture_total_gas_([0-9]*)_kpc" regex = cached_regex(match_string) match = regex.match(field_path) if match: aperture_size = match.group(1) full_name = f"Total Dust Mass from Tables ({aperture_size} kpc)" snake_case = f"dust_mass_table_{aperture_size}_kpc" else: raise RegistrationDoesNotMatchError return unit, full_name, snake_case
def registration_masses( field_path: str, unit_system: VelociraptorUnits) -> (unyt.Unit, str, str): """ Registration for all mass-based quantities. (Start with M) """ if not field_path[0] == "M": raise RegistrationDoesNotMatchError # All, obviously, have a unit of mass unit = unit_system.mass full_name = "" # Deal with special cases. if field_path == "Mvir": full_name = "$M_{\\rm vir}$" elif field_path == "Mass_FOF": full_name = "$M_{\\rm FOF}$" elif field_path == "Mass_tot": full_name = r"$M$" # General regex matching case. # Capture group 1: Mass or M # Capture group 2: radius within this was calculated, e.g. 200crit # Capture group 3: excluding? # Capture group 4: ptype # Capture group 5: star forming? # Capture group 6: "other" match_string = ( "(Mass|M)_?([A-Z]*[0-9]+[a-z]*)?_?(excl)?_?([a-z]*)_?(nsf|sf)?_?([a-zA-Z0-9]*)" ) regex = cached_regex(match_string) match = regex.match(field_path) if match and not full_name: mass = match.group(1) radius = match.group(2) excluding = match.group(3) ptype = match.group(4) star_forming = match.group(5) other = match.group(6) full_name = "$M" if radius: full_name += f"_{{\\rm {radius}}}" elif other: full_name += f"_{{\\rm {other}}}" full_name += "$" if ptype: full_name += " (" if excluding: full_name += "Excl. " cap_ptype = ptype[0].upper() + ptype[1:] full_name += cap_ptype if star_forming: full_name += f", {star_forming.upper()}" full_name += ")" return unit, full_name, field_path.lower()