makecloud 1.0.0__tar.gz

makecloud-1.0.0/MakeCloud.py

@@ -0,0 +1,659 @@
+#!/usr/bin/env python
+"""
+Usage: MakeCloud.py [options]
+
+Options:
+   -h --help            Show this screen.
+   --R=<pc>             Outer radius of the cloud in pc [default: 10.0]
+   --M=<msun>           Mass of the cloud in msun [default: 2e4]
+   --filename=<name>    Name of the IC file to be generated
+   --N=<N>              Number of gas particles [default: 2000000]
+   --density_exponent=<f>   Power law exponent of the density profile [default: 0.0]
+   --spin=<f>           Spin parameter: fraction of binding energy in solid-body rotation [default: 0.0]
+   --omega_exponent=<f>  Powerlaw exponent of rotational frequency as a function of cylindrical radius [default: 0.0]
+   --turb_slope=<f>      Slope of the turbulent power spectra [default: 2.0]
+   --turb_sol=<f>       Fraction of turbulence in solenoidal modes [default: 0.5]
+   --alpha_turb=<f>     Turbulent virial parameter (BM92 convention: 2Eturb/|Egrav|) [default: 2.]
+   --bturb=<f>          Magnetic energy as a fraction of the binding energy [default: 0.1]
+   --bfixed=<f>         Magnetic field in magnitude in code units, used instead of bturb if not set to zero [default: 0]
+   --minmode=<N>        Minimum populated turbulent wavenumber for Gaussian initial velocity field, in units of pi/R [default: 2]
+   --turb_path=<name>   Path to store turbulent velocity fields so that we only need to generate them once (defaults to ~/turb)
+   --glass_path=<name>  Contains the the path of the glass file (defaults to your home directory)
+   --boxsize=<f>        Simulation box size
+   --Mstar=<msun>       Mass of the star/black hole, if any [default: 0.0]
+   --v_star=<vx,vy,vz>  Velocity of the star [default: 0.0,0.0,0.0]
+   --x_star=<x,y,z>     Position of the star, defaults to center of the box
+   --star_stage=<N>     Evolutionary stage of the star/black hole [default: 7]
+   --derefinement       Apply radial derefinement to ambient cells outside of 3* cloud radius
+   --no_diffuse_gas     Remove diffuse ISM envelope fills the rest of the box with uniform density.
+   --phimode=<f>        Relative amplitude of m=2 density perturbation (e.g. for Boss-Bodenheimer test) [default: 0.0]
+   --localdir           Changes directory defaults assuming all files are used from local directory.
+   --B_unit=<gauss>     Unit of magnetic field in gauss [default: 1.0]
+   --length_unit=<pc>   Unit of length in pc [default: 1]
+   --mass_unit=<msun>   Unit of mass in M_sun [default: 1]
+   --v_unit=<m/s>       Unit of velocity in m/s [default: 1e3]
+   --unit_system=<name> Units system to adopt (options: starforge_classic (m/s - pc - Msun - T), FIRE (km/s - kpc - 1e10Msun - uG)) [default: None]
+   --turb_seed=<N>      Random seed for turbulence initialization [default: 42]
+   --tmax=<N>           Maximum time to run the simulation to, in units of the freefall time [default: 5]
+   --nsnap=<N>          Number of snapshots per freefall time [default: 150]
+   --param_only         Just makes the parameters file, not the IC
+   --fixed_ncrit=<f>    Fixes ncrit to a specific value [default: 0.0]
+   --makebox            Creates a second box IC of equivalent volume and mass to the cloud
+   --impact_dist=<b>    Initial separation between cloud centers of mass in units of the cloud radius  (0 is no cloud-cloud collision) [default: 0.0]
+   --impact_param=<b>   Impact parameter of cloud-cloud collision in units of the cloud radius [default: 0.0]
+   --v_impact=<v>       Impact velocity, in units of the cloud's RMS turbulent velocity [default: 1.0]
+   --impact_axis=<x>    Axis along which collision occurs (z is along magnetic field lines) [default: x]
+   --makecylinder       Creates a third, cylindrical IC of equivalent volume and mass to the cloud
+   --cyl_aspect_ratio=<f>   Sets the aspect ratio of the cylinder, i.e. Length/Diameter [default: 10]
+   --Z=<solar>          Metallicity of the cloud in Solar units (just for params file) [default: 1.0]
+   --ISRF=<solar>       Interstellar radiation background of the cloud in Solar neighborhood units (just for params file) [default: 1.0]
+"""
+
+import os
+import numpy as np
+from scipy import fftpack, interpolate
+from scipy.spatial.distance import cdist
+import h5py
+from docopt import docopt
+
+
+def get_glass_coords(N_gas, glass_path, center_on_cell=False):
+    x = h5py.File(glass_path)["Coordinates"][:]
+    if not center_on_cell:  # if we don't want a cell at the exact box center
+        np.random.seed(42)
+        x = (x + np.random.rand(x.shape[1])) % 1.0
+    Nx = len(x)
+
+    while len(x) * np.pi * 4 / 3 / 8 < N_gas:
+        print(
+            "Need %d particles, have %d. Tessellating 8 copies of the glass file to get required particle number"
+            % (N_gas * 8 / (4 * np.pi / 3), len(x))
+        )
+        x = np.concatenate(
+            [
+                x / 2 + i * np.array([0.5, 0, 0]) + j * np.array([0, 0.5, 0]) + k * np.array([0, 0, 0.5])
+                for i in range(2)
+                for j in range(2)
+                for k in range(2)
+            ]
+        )
+    print("Glass loaded!")
+    order = x.max(axis=1).argsort()
+    return x[order]
+
+
+def TurbField(res=256, minmode=2, maxmode=64, slope=2.0, sol_weight=1.0, seed=42):
+    freqs = fftpack.fftfreq(res)
+    freq3d = np.array(np.meshgrid(freqs, freqs, freqs, indexing="ij"))
+    intfreq = np.around(freq3d * res)
+    kSqr = np.sum(np.abs(freq3d) ** 2, axis=0)
+    intkSqr = np.sum(np.abs(intfreq) ** 2, axis=0)
+    VK = []
+
+    # apply ~k^-2 exp(-k^2/kmax^2) filter to white noise to get x, y, and z components of velocity field
+    for i in range(3):
+        np.random.seed(seed + i)
+        rand_phase = fftpack.fftn(
+            np.random.normal(size=kSqr.shape)
+        )  # fourier transform of white noise
+        vk = rand_phase * (float(minmode) / res) ** 2 / (np.power(kSqr, slope/2.0) + 1e-300)
+        vk[intkSqr == 0] = 0.0
+        vk[intkSqr < minmode**2] *= (
+            intkSqr[intkSqr < minmode**2] ** 2 / minmode**4
+        )  # smoother filter than mode-freezing; should give less "ringing" artifacts
+        vk *= np.exp(-intkSqr / maxmode**2)
+
+        VK.append(vk)
+    VK = np.array(VK)
+
+    vk_new = np.zeros_like(VK)
+
+    # do projection operator to get the correct mix of compressive and solenoidal
+    for i in range(3):
+        for j in range(3):
+            if i == j:
+                vk_new[i] += sol_weight * VK[j]
+            vk_new[i] += (1 - 2 * sol_weight) * freq3d[i] * freq3d[j] / (kSqr + 1e-300) * VK[j]
+    vk_new[:, kSqr == 0] = 0.0
+    VK = vk_new
+
+    vel = np.array([fftpack.ifftn(vk).real for vk in VK])  # transform back to real space
+    vel -= np.average(vel, axis=(1, 2, 3))[:, np.newaxis, np.newaxis, np.newaxis]
+    vel = vel / np.sqrt(np.sum(vel**2, axis=0).mean())  # normalize so that RMS is 1
+    return np.array(vel)
+
+
+
+def _load_params_template():
+    local = os.path.join(os.path.dirname(os.path.realpath(__file__)), "params.txt")
+    if os.path.exists(local):
+        return open(local).read()
+    from importlib.resources import files
+    return files("makecloud").joinpath("params.txt").read_text()
+
+
+def main():
+    arguments = docopt(__doc__)
+    R = float(arguments["--R"])
+    M_gas = float(arguments["--M"])
+    N_gas = int(float(arguments["--N"]) + 0.5)
+    M_star = float(arguments["--Mstar"])
+    v_star = np.array([float(v) for v in arguments["--v_star"].split(",")])
+    spin = float(arguments["--spin"])
+    omega_exponent = float(arguments["--omega_exponent"])
+    turbulence = float(arguments["--alpha_turb"]) / 2
+    seed = int(float(arguments["--turb_seed"]) + 0.5)
+    tmax = int(float(arguments["--tmax"]))
+    nsnap = int(float(arguments["--nsnap"]))
+    turb_slope = float(arguments["--turb_slope"])
+    turb_sol = float(arguments["--turb_sol"])
+    magnetic_field = float(arguments["--bturb"])
+    bfixed = float(arguments["--bfixed"])
+    minmode = int(arguments["--minmode"])
+    filename = arguments["--filename"]
+    diffuse_gas = not arguments["--no_diffuse_gas"]
+    param_only = arguments["--param_only"]
+    if arguments["--unit_system"] is not None:
+        match arguments["--unit_system"]:
+            case "starforge_classic":
+                length_unit_pc = 1
+                mass_unit_Msun = 1
+                v_unit_SI = 1
+                B_unit_gauss = 1e4
+            case "FIRE":
+                length_unit_pc = 1e3
+                mass_unit_Msun = 1e10
+                v_unit_SI = 1e3
+                B_unit_gauss = 1
+    else:
+        length_unit_pc = float(arguments["--length_unit"])
+        mass_unit_Msun = float(arguments["--mass_unit"])
+        v_unit_SI = float(arguments["--v_unit"])
+        B_unit_gauss = float(arguments["--B_unit"])
+
+    t_unit = length_unit_pc / v_unit_SI
+
+    G = 4300.71 * v_unit_SI**-2 * mass_unit_Msun / length_unit_pc
+    makebox = arguments["--makebox"]
+    impact_param = float(arguments["--impact_param"])
+    impact_dist = float(arguments["--impact_dist"])
+    v_impact = float(arguments["--v_impact"])
+    impact_axis = arguments["--impact_axis"]
+    makecylinder = arguments["--makecylinder"]
+    cyl_aspect_ratio = float(arguments["--cyl_aspect_ratio"])
+    fixed_ncrit = float(arguments["--fixed_ncrit"])
+    density_exponent = float(arguments["--density_exponent"])
+    metallicity = float(arguments["--Z"])
+    ISRF = float(arguments["--ISRF"])
+    if arguments["--turb_path"]:
+        turb_path = arguments["--turb_path"]
+    else:
+        turb_path = os.path.expanduser("~") + "/turb"
+    if arguments["--glass_path"]:
+        glass_path = arguments["--glass_path"]
+    else:
+        prefix = os.path.expanduser("~") + "/.makecloud_glass"
+        glass_path = prefix + "/glass_256.hdf5"
+        if not os.path.exists(glass_path):
+            if not os.path.isdir(prefix):
+                os.mkdir(prefix)
+            import urllib.request
+
+            print("Downloading glass file...")
+            urllib.request.urlretrieve(
+                "https://users.flatironinstitute.org/~mgrudic/glass/glass_256.hdf5",
+                glass_path,
+            )
+
+    if arguments["--boxsize"] is not None:
+        boxsize = float(arguments["--boxsize"])
+    else:
+        boxsize = 10 * R
+
+    if arguments["--x_star"]:
+        x_star = np.array([float(x) for x in arguments["--x_star"].split(",")])
+    else:  # default to center of box
+        x_star = np.repeat(0.5 * boxsize, 3)
+
+    derefinement = arguments["--derefinement"]
+
+    res_effective = int(N_gas ** (1.0 / 3.0) + 0.5)
+    phimode = float(arguments["--phimode"])
+
+    filename = (
+        "M%3.2g_" % (M_gas)
+        + ("Mstar%g_" % (M_star) if M_star > 0 else "")
+        + ("rho_exp%g_" % (-density_exponent) if density_exponent < 0 else "")
+        + "R%g_Z%g_S%g_A%g_B%g_I%g_Res%d_n%d_sol%g"
+        % (
+            R,
+            metallicity,
+            spin,
+            2 * turbulence,
+            magnetic_field,
+            ISRF,
+            res_effective,
+            minmode,
+    #        turb_slope,
+            turb_sol,
+        )
+        + ("_%d" % seed)
+        + ("_collision_%g_%g_%g_%s" % (impact_dist, impact_param, v_impact, impact_axis) if impact_dist > 0 else "")
+        + ".hdf5"
+    )
+    filename = filename.replace("+", "").replace("e0", "e")
+    filename = "".join(filename.split())
+
+    dm = M_gas / N_gas
+    dm_solar = dm / mass_unit_Msun
+    rho_avg = 3 * M_gas / R**3 / (4 * np.pi)
+    if dm_solar < 0.1:  # if we're doing something marginally IMF-resolving
+        softening = 3.11e-5  # ~6.5 AU, minimum sink radius is 2.8 times that (~18 AU)
+        ncrit = 1e13  # ~100x the opacity limit
+    else:  # something more FIRE-like, where we rely on a sub-grid prescription turning gas into star particles
+        softening = 0.1
+        ncrit = 100
+
+    if fixed_ncrit:
+        ncrit = fixed_ncrit
+
+    tff = (3 * np.pi / (32 * G * rho_avg)) ** 0.5
+    L = (4 * np.pi * R**3 / 3) ** (1.0 / 3)  # volume-equivalent box size
+    vrms = (6 / 5 * G * M_gas / R) ** 0.5 * turbulence**0.5
+
+    if turbulence:
+        tcross = L / vrms
+    else:
+        tcross = tff
+
+    turbenergy = (
+        0.019111097819633344 * vrms**3 / L
+    )  # ST_Energy sets the dissipation rate of SPECIFIC energy ~ v^2 / (L/v) ~ v^3/L
+
+    paramsfile = _load_params_template()
+
+    jet_particle_mass = min(dm, max(1e-4, dm / 10.0))
+    MS_wind_particle_mass = (
+        jet_particle_mass / 10
+    )  # MS winds have lower mdot than jets, so we should be able to better resolve them this way
+
+    replacements = {
+        "NAME": filename.replace(".hdf5", ""),
+        "DTSNAP": tff / nsnap,
+        "MAXTIMESTEP": tff / (nsnap),
+        "SOFTENING": softening,
+        "GASSOFT": 2.0e-8,
+        "TMAX": tff * tmax,
+        "RHOMAX": ncrit,
+        "BOXSIZE": boxsize,
+        "OUTFOLDER": "output",
+        "JET_PART_MASS": jet_particle_mass,
+        "MS_WIND_PART_MASS": MS_wind_particle_mass,
+        "BH_SEED_MASS": dm / 2.0,
+        "TURBDECAY": tcross / 2,
+        "TURBENERGY": turbenergy,
+        "TURBFREQ": tcross / 20,
+        "TURB_KMIN": int(100 * 2 * np.pi / L) / 100.0,
+        "TURB_KMAX": int(100 * 4 * np.pi / (L) + 1) / 100.0,
+        "TURB_SIGMA": (M_gas/2e4)**0.5 * (R/10)**-0.5 * 600 * turbulence**0.5,
+        "TURB_MINLAMBDA": int(100 * R / 2) / 100,
+        "TURB_MAXLAMBDA": int(100 * R * 2) / 100,
+        "TURB_COHERENCE_TIME": tcross / 2,
+        "UNIT_L": 3.085678e18 * length_unit_pc,
+        "UNIT_M": 1.989e33 * mass_unit_Msun,
+        "UNIT_V": v_unit_SI * 1e2,
+        "UNIT_B": B_unit_gauss,
+        "ZINIT": metallicity,
+        "ISRF": ISRF,
+    }
+
+    for k, r in replacements.items():
+        paramsfile = paramsfile.replace(k, (r if isinstance(r, str) else "{:.2e}".format(r)))
+
+    open("params_" + filename.replace(".hdf5", "") + ".txt", "w").write(paramsfile)
+    if makebox:
+        replacements_box = replacements.copy()
+        replacements_box["NAME"] = filename.replace(".hdf5", "_BOX")
+        replacements_box["BOXSIZE"] = L
+        replacements_box["TURB_MINLAMBDA"] = int(100 * L / 2) / 100
+        replacements_box["TURB_MAXLAMBDA"] = int(100 * L * 2) / 100
+        paramsfile = _load_params_template()
+        for k in replacements_box.keys():
+            paramsfile = paramsfile.replace(k, str(replacements_box[k]))
+        open("params_" + filename.replace(".hdf5", "") + "_BOX.txt", "w").write(paramsfile)
+    if makecylinder:
+        # Get cylinder params
+        R_cyl = R * np.sqrt(np.pi / (4 * cyl_aspect_ratio))  # surface density equivalent cylinder
+        L_cyl = R_cyl * 2 * cyl_aspect_ratio
+        vrms_cyl = (
+            (2 * G * M_gas / L_cyl) ** 0.5 * turbulence** 0.5
+        )  # the potential is different for a cylinder than for a sphere, so we need to rescale vrms to get the right alpha, using E_grav_cyl = -GM**2/L
+        vrms_cyl *= 0.71  # additional scaling found numerically to make the stirring run reproduce the right alpha and filament length (similarly determined numerical factor added to GIZMO)
+        tcross_cyl = 2 * R_cyl / vrms_cyl
+        boxsize_cyl = L_cyl * 1.5 + R_cyl * 5  # the box should fit the cylinder and be many times bigger than its width
+        print("Cylinder params: L=%g R=%g boxsize=%g vrms=%g" % (L_cyl, R_cyl, boxsize_cyl, vrms_cyl))
+        replacements_cyl = replacements.copy()
+        replacements_cyl["NAME"] = filename.replace(".hdf5", "_CYL")
+        replacements_cyl["BOXSIZE"] = boxsize_cyl
+        # New driving params
+        replacements_cyl["TURB_MINLAMBDA"] = int(100 * R_cyl) / 100
+        replacements_cyl["TURB_MAXLAMBDA"] = int(100 * R_cyl * 4) / 100
+        replacements_cyl["TURB_SIGMA"] = vrms_cyl
+        replacements_cyl["TURB_COHERENCE_TIME"] = tcross_cyl / 2
+        # Legacy driving params, probably needs tuning
+        replacements_cyl["TURBDECAY"] = tcross_cyl / 2
+        replacements_cyl["TURBENERGY"] = 0.019111097819633344 * vrms_cyl**3 / R_cyl
+        replacements_cyl["TURBFREQ"] = tcross_cyl / 20
+        replacements_cyl["TURB_KMIN"] = int(100 * 2 * np.pi / R_cyl) / 100.0
+        replacements_cyl["TURB_KMAX"] = int(100 * 4 * np.pi / (R_cyl) + 1) / 100.0
+        paramsfile = _load_params_template()
+        for k in replacements_cyl.keys():
+            paramsfile = paramsfile.replace(k, str(replacements_cyl[k]))
+        open("params_" + filename.replace(".hdf5", "") + "_CYL.txt", "w").write(paramsfile)
+
+    if param_only:
+        print("Parameters only run, exiting...")
+        exit()
+
+    mgas = np.repeat(dm, N_gas)
+
+    x = get_glass_coords(N_gas, glass_path)
+    Nx = len(x)
+    x = 2 * (x - 0.5)
+    print("Computing radii...")
+    r = cdist(x, [np.zeros(3)])[:, 0]
+    print("Done! Sorting coordinates...")
+    x = x[r.argsort()][:N_gas]
+    print("Done! Rescaling...")
+    x *= (float(Nx) / N_gas * 4 * np.pi / 3 / 8) ** (1.0 / 3) * R
+    print("Done! Recomupting radii...")
+    r = cdist(x, [np.zeros(3)])[:, 0]
+    if np.any(r == 0):
+        raise ValueError(
+            "found point with r=0 in the glass file, we don't handle this case throughout our calculations yet. Stopping."
+        )
+    x, r = x / r.max(), r / r.max()
+    print("Doing density profile...")
+    rnew = r ** (3.0 / (3 + density_exponent)) * R
+
+
+    x = x * (rnew / r)[:, None]
+    r = np.sum(x**2, axis=1) ** 0.5
+    r_order = r.argsort()
+    x, r = np.take(x, r_order, axis=0), r[r_order]
+
+    if not os.path.exists(turb_path):
+        os.makedirs(turb_path)
+    fname = turb_path + "/vturb%d_beta%g_sol%g_seed%d.npy" % (minmode, turb_slope, turb_sol, seed)
+    if not os.path.isfile(fname):
+        vt = TurbField(minmode=minmode, slope = turb_slope, sol_weight=turb_sol, seed=seed)
+        nmin, nmax = vt.shape[-1] // 4, 3 * vt.shape[-1] // 4
+        vt = vt[
+            :, nmin:nmax, nmin:nmax, nmin:nmax
+        ]  # we take the central cube of size L/2 so that opposide sides of the cloud are not correlated
+        np.save(fname, vt)
+    else:
+        vt = np.load(fname)
+
+    xgrid = np.linspace(-R, R, vt.shape[-1])
+    v = []
+    for i in range(3):
+        v.append(interpolate.interpn((xgrid, xgrid, xgrid), vt[i, :, :, :], x))
+    v = np.array(v).T
+    print("Coordinates obtained!")
+
+    Mr = mgas.cumsum()
+    ugrav = G * np.sum(Mr / r * mgas)
+    v -= np.average(v, axis=0)
+    Eturb = 0.5 * dm * np.sum(v**2)
+    v *= np.sqrt(turbulence * ugrav / Eturb)
+    E_rot_target = spin * ugrav
+    Rcyl = np.sqrt(x[:, 0] ** 2 + x[:, 1] ** 2)
+    omega = Rcyl**omega_exponent
+    vrot = np.cross(np.c_[np.zeros_like(omega), np.zeros_like(omega), omega], x)
+    Erot_actual = np.sum(0.5 * mgas[:, None] * vrot**2)
+    vrot *= np.sqrt(E_rot_target / Erot_actual)
+    v += vrot
+
+    B = np.c_[np.zeros(N_gas), np.zeros(N_gas), np.ones(N_gas)]
+    vA_unit = (
+        3.429e8 * B_unit_gauss * (M_gas) ** -0.5 * R**1.5 * np.sqrt(4 * np.pi / 3) / v_unit_SI
+    )  # alfven speed for unit magnetic field
+    uB = 0.5 * M_gas * vA_unit**2  # magnetic energy we would have for unit magnetic field
+    if bfixed > 0:
+        B = B * bfixed
+    else:
+        B = B * np.sqrt(magnetic_field * ugrav / uB)  # renormalize to desired magnetic energy
+
+    v = v - np.average(v, axis=0)
+    x = x - np.average(x, axis=0)
+
+    r, phi = np.sum(x**2, axis=1) ** 0.5, np.arctan2(x[:, 1], x[:, 0])
+    theta = np.arccos(x[:, 2] / r)
+    phi += phimode * np.sin(2 * phi) / 2
+    x = r[:, np.newaxis] * np.c_[np.cos(phi) * np.sin(theta), np.sin(phi) * np.sin(theta), np.cos(theta)]
+
+    if makecylinder:
+
+        def ind_in_cylinder(x, L_cyl, R_cyl):
+            return (np.abs(x[:, 0]) < L_cyl / 2) & (np.sum(x[:, 1:] ** 2, axis=1) < R_cyl**2)
+
+        # Just get a roughly homogeneous cylinder along the x axis, we will stir it anyway
+        N_cyl = 0
+        while N_cyl <= N_gas:  # should be very unlikely that we need to repeat, but let's check to be sure
+            x_cyl = np.random.rand(2 * N_gas, 3) * 2 - 1
+            x_cyl[:, 0] *= L_cyl / 2
+            x_cyl[:, 1] *= R_cyl
+            x_cyl[:, 2] *= R_cyl
+            x_cyl = x_cyl[ind_in_cylinder(x_cyl, L_cyl, R_cyl)]
+            N_cyl = len(x_cyl)
+            # print("N_cyl: %g N_gas: %g"%(N_cyl,N_gas))
+        x_cyl = x_cyl[:N_gas]  # keep only the right amount of gas
+        # Let's add some initial velocity to make the driving phase shorter, let's start with a rotational component
+        v_cyl = np.cross([1, 0, 0], x_cyl, axis=-1) / R_cyl
+        # tangential with magnitude increasing linearly
+        v_cyl *= vrms_cyl
+
+    u = np.ones_like(mgas) * 0.101 / 2.0  # /2 needed because it is molecular
+
+    if impact_dist > 0:
+        x = np.concatenate([x, x])
+        impact_dir = {
+            "x": np.array([1.0, 0, 0]),
+            "y": np.array([0, 1, 0]),
+            "z": np.array([0, 0, 1]),
+        }[impact_axis]
+        impact_param_dir = {
+            "x": np.array([0, 1, 0]),
+            "y": np.array([0, 0, 1]),
+            "z": np.array([1, 0, 0]),
+        }[impact_axis]
+        x[:N_gas] += impact_dist * R * impact_dir
+        x[N_gas:] -= impact_dist * R * impact_dir
+        x[:N_gas] += 0.5 * impact_param * R * impact_param_dir
+        x[N_gas:] -= 0.5 * impact_param * R * impact_param_dir
+        v = np.concatenate([v, v])
+        vrms = np.sum(v**2, axis=1).mean() ** 0.5
+        v[:N_gas] -= v_impact * vrms * impact_dir
+        v[N_gas:] += v_impact * vrms * impact_dir
+        B = np.concatenate([B, B])
+        u = np.concatenate([u, u])
+        mgas = np.concatenate([mgas, mgas])
+
+    u = (
+        np.ones_like(mgas) * (200 / v_unit_SI) ** 2
+    )  # start with specific internal energy of (200m/s)^2, this is overwritten unless starting with restart flag 2###### #0.101/2.0 #/2 needed because it is molecular
+
+    if diffuse_gas:
+        # assuming 10K vs 10^4K gas: factor of ~10^3 density contrast
+        rho_warm = M_gas * 3 / (4 * np.pi * R**3) / 1000
+        if derefinement:
+            M_warm = (boxsize**3 - (4 * np.pi * R**3 / 3)) * rho_warm  # mass of diffuse box-filling medium
+            N_warm = int(M_warm / (dm))
+            x0 = get_glass_coords(N_gas, glass_path)
+            Nx = len(x0)
+            x0 = 2 * (x0 - 0.5)
+            r0 = (x0 * x0).sum(1) ** 0.5
+            x0, r0 = x0[r0.argsort()], r0[r0.argsort()]
+            # first lay down the stuff within 3*R
+            N_warm = int(4 * np.pi * rho_warm * (3 * R) ** 3 / 3 / dm)  # number of cells within 3R
+            x_warm = x0[:N_warm] * 3 * R / r0[N_warm - 1]  # uniform density of cells within 3R
+            x0 = x0[
+                N_warm:
+            ]  # now we take the ones outside the initial sphere and map them to a n(R) ~ R^-3 profile so that we get constant number of cells per log radius interval
+            r0 = r0[N_warm:]
+            rnew = 3 * R * np.exp(np.arange(len(x0)) / N_warm / 3)
+            x_warm = np.concatenate([x_warm, (rnew / r0)[:, None] * x0], axis=0)
+            x_warm = x_warm[np.max(np.abs(x_warm), axis=1) < boxsize / 2]
+            N_warm = len(x_warm)
+            R_warm = (x_warm * x_warm).sum(1) ** 0.5
+            mgas = np.concatenate([mgas, np.clip(dm * (R_warm / (3 * R)) ** 3, dm, np.inf)])
+        else:
+            M_warm = boxsize**3 * rho_warm  # mass of diffuse box-filling medium
+            N_warm = int(M_warm / dm)  # get glass with N_warm particles
+            x_warm = get_glass_coords(N_warm, glass_path)[:N_warm]
+            x_warm /= x_warm.max()
+            x_warm = boxsize * x_warm - boxsize / 2
+            if impact_dist == 0:
+                x_warm = x_warm[np.sum(x_warm**2, axis=1) > R**2]
+            N_warm = len(x_warm)
+            mgas = np.concatenate([mgas, np.repeat(mgas.sum() / len(mgas), N_warm)])
+        x = np.concatenate([x, x_warm])
+        v = np.concatenate([v, np.zeros((N_warm, 3))])
+        Bmag = np.average(np.sum(B**2, axis=1)) ** 0.5
+        B = np.concatenate([B, np.repeat(Bmag, N_warm)[:, np.newaxis] * np.array([0, 0, 1])])
+        u = np.concatenate([u, np.repeat(101.0, N_warm)])
+
+        if makecylinder:
+            # The magnetic field is paralell to the cylinder (true at low densities, so probably fine for IC)
+            B_cyl = np.concatenate([B, np.repeat(Bmag, N_warm)[:, np.newaxis] * np.array([1, 0, 0])])
+            # Add diffuse medium
+            M_warm_cyl = (boxsize_cyl**3 - (4 * np.pi * R**3 / 3)) * rho_warm
+            N_warm_cyl = int(M_warm_cyl / (dm))
+            x_warm = boxsize_cyl * np.random.rand(N_warm_cyl, 3) - boxsize_cyl / 2  # will be recentered later
+            x_warm = x_warm[~ind_in_cylinder(x_warm, L_cyl, R_cyl)]  # keep only warm gas outside the cylinder
+            # print("N_warm_cyl: %g N_warm_cyl_kept %g "%(N_warm_cyl,len(x_warm)))
+            N_warm_cyl = len(x_warm)
+            x_cyl = np.concatenate([x_cyl, x_warm])
+            v_cyl = np.concatenate([v_cyl, np.zeros((N_warm, 3))])
+
+    else:
+        N_warm = 0
+
+    rho = np.repeat(3 * M_gas / (4 * np.pi * R**3), len(mgas))
+    if diffuse_gas:
+        rho[-N_warm:] /= 1000
+    h = (32 * mgas / rho) ** (1.0 / 3)
+
+    x += boxsize / 2  # cloud is always centered at (boxsize/2,boxsize/2,boxsize/2)
+    if makecylinder:
+        x_cyl += boxsize_cyl / 2
+
+    print("Writing snapshot...")
+
+    F = h5py.File(filename, "w")
+    F.create_group("PartType0")
+    F.create_group("Header")
+    F["Header"].attrs["NumPart_ThisFile"] = [
+        len(mgas),
+        0,
+        0,
+        0,
+        0,
+        (1 if M_star > 0 else 0),
+    ]
+    F["Header"].attrs["NumPart_Total"] = [
+        len(mgas),
+        0,
+        0,
+        0,
+        0,
+        (1 if M_star > 0 else 0),
+    ]
+    F["Header"].attrs["BoxSize"] = boxsize
+    F["Header"].attrs["Time"] = 0.0
+    F["PartType0"].create_dataset("Masses", data=mgas)
+    F["PartType0"].create_dataset("Coordinates", data=x)
+    F["PartType0"].create_dataset("Velocities", data=v)
+    F["PartType0"].create_dataset("ParticleIDs", data=1 + np.arange(len(mgas)))
+    F["PartType0"].create_dataset("InternalEnergy", data=u)
+
+    if M_star > 0:
+        F.create_group("PartType5")
+        # Let's add the sink at the center
+        F["PartType5"].create_dataset("Masses", data=np.array([M_star]))
+        F["PartType5"].create_dataset("Coordinates", data=[x_star])  # at the center
+        F["PartType5"].create_dataset("Velocities", data=[v_star])  # at rest
+        F["PartType5"].create_dataset("ParticleIDs", data=np.array([F["PartType0/ParticleIDs"][:].max() + 1]))
+        # Advanced properties for sinks
+        F["PartType5"].create_dataset("BH_Mass", data=M_star)  # all the mass in the sink/protostar/star
+        F["PartType5"].create_dataset("BH_Mass_AlphaDisk", data=np.array([0.0]))  # starts with no disk
+        F["PartType5"].create_dataset("BH_Mdot", data=np.array([0.0]))  # starts with no mdot
+        F["PartType5"].create_dataset("BH_Specific_AngMom", data=np.array([0.0]))  # starts with no angular momentum
+        F["PartType5"].create_dataset("SinkRadius", data=np.array([softening]))  # Sinkradius set to softening
+        F["PartType5"].create_dataset("StellarFormationTime", data=np.array([0.0]))
+        F["PartType5"].create_dataset("ProtoStellarAge", data=np.array([0.0]))
+        F["PartType5"].create_dataset("ProtoStellarStage", data=np.array([5], dtype=np.int32), dtype=np.int32)
+        # Stellar properties
+        # if (central_star or central_SN):
+        # if central_star:
+        #       print("Assuming central sink is a ZAMS star")
+        # starts as ZAMS star
+        # else:
+        # print("Assuming central sink is a ZAMS star about to go supernova")
+        # F["PartType5"].create_dataset("ProtoStellarStage", data=np.array([6],dtype=np.int32), dtype=np.int32) #starts as ZAMS star going SN
+        # Set guess for ZAMS stellar radius, will be overwritten
+        if (M_star) > 1.0:
+            R_ZAMS = (M_star) ** 0.57
+        else:
+            R_ZAMS = (M_star) ** 0.8
+        F["PartType5"].create_dataset("ProtoStellarRadius_inSolar", data=np.array([R_ZAMS]))  # Sinkradius set to softening
+        F["PartType5"].create_dataset("StarLuminosity_Solar", data=np.array([0.0]))  # dummy
+        F["PartType5"].create_dataset("Mass_D", data=np.array([0.0]))  # No D left
+
+    if magnetic_field > 0.0:
+        F["PartType0"].create_dataset("MagneticField", data=B)
+    F.close()
+
+    if makebox:
+        F = h5py.File(filename.replace(".hdf5", "_BOX.hdf5"), "w")
+        F.create_group("PartType0")
+        F.create_group("Header")
+        F["Header"].attrs["NumPart_ThisFile"] = [len(mgas), 0, 0, 0, 0, 0]
+        F["Header"].attrs["NumPart_Total"] = [len(mgas), 0, 0, 0, 0, 0]
+        F["Header"].attrs["MassTable"] = [M_gas / len(mgas), 0, 0, 0, 0, 0]
+        F["Header"].attrs["BoxSize"] = (4 * np.pi * R**3 / 3) ** (1.0 / 3)
+        F["Header"].attrs["Time"] = 0.0
+        F["PartType0"].create_dataset("Masses", data=mgas[: len(mgas)])
+        F["PartType0"].create_dataset(
+            "Coordinates",
+            data=np.random.rand(len(mgas), 3) * F["Header"].attrs["BoxSize"],
+        )
+        F["PartType0"].create_dataset("Velocities", data=np.zeros((len(mgas), 3)))
+        F["PartType0"].create_dataset("ParticleIDs", data=1 + np.arange(len(mgas)))
+        F["PartType0"].create_dataset("InternalEnergy", data=u)
+        if magnetic_field > 0.0:
+            F["PartType0"].create_dataset("MagneticField", data=B[: len(mgas)])
+        F.close()
+
+    if makecylinder:
+        F = h5py.File(filename.replace(".hdf5", "_CYL.hdf5"), "w")
+        F.create_group("PartType0")
+        F.create_group("Header")
+        F["Header"].attrs["NumPart_ThisFile"] = [N_gas + N_warm_cyl, 0, 0, 0, 0, 0]
+        F["Header"].attrs["NumPart_Total"] = [N_gas + N_warm_cyl, 0, 0, 0, 0, 0]
+        F["Header"].attrs["MassTable"] = [dm, 0, 0, 0, 0, 0]
+        F["Header"].attrs["BoxSize"] = boxsize_cyl
+        F["Header"].attrs["Time"] = 0.0
+        F["PartType0"].create_dataset("Masses", data=mgas)
+        F["PartType0"].create_dataset("Coordinates", data=x_cyl)
+        F["PartType0"].create_dataset("Velocities", data=v_cyl)
+        F["PartType0"].create_dataset("ParticleIDs", data=1 + np.arange(N_gas + N_warm_cyl))
+        F["PartType0"].create_dataset("InternalEnergy", data=u)
+        if magnetic_field > 0.0:
+            F["PartType0"].create_dataset("MagneticField", data=B_cyl)
+        F.close()
+
+
+if __name__ == "__main__":
+    main()

makecloud-1.0.0/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: makecloud
+Version: 1.0.0
+Summary: Generate turbulent molecular cloud initial conditions for GIZMO/STARFORGE simulations
+Author: Dávid Guszejnov
+Author-email: "Michael Y. Grudić" <mgrudic@flatironinstitute.org>
+License: MIT
+Project-URL: Homepage, https://github.com/mikegrudic/MakeCloud
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: h5py
+Requires-Dist: docopt
+
+# MakeCloud
+
+Requires the following packages:
+numpy
+scipy
+h5py
+docopt
+
+If you want to use glassy initial conditions, you will need <a href=https://data.obs.carnegiescience.edu/starforge/glass_orig.npy>this file</a>, and you should point the script to it via the --glass_path option.
+
+By default, we generate turbulent velocity fields on the fly but then store that data somewhere so we don't have to do all those FFTs again next. You'll have to specify the path where the files get stored via the --turb_path option.
+
+#Usage
+
+Run python MakeCloud.py -h for instructions
+
+e.g. if I wanted a 10^6 solar mass cloud of radius 100pc, resolved in 10^6 gas cells, I would do
+
+python MakeCloud.py --M=1e6 --R=100 --N=1000000

makecloud-1.0.0/README.md

@@ -0,0 +1,19 @@
+# MakeCloud
+
+Requires the following packages:
+numpy
+scipy
+h5py
+docopt
+
+If you want to use glassy initial conditions, you will need <a href=https://data.obs.carnegiescience.edu/starforge/glass_orig.npy>this file</a>, and you should point the script to it via the --glass_path option.
+
+By default, we generate turbulent velocity fields on the fly but then store that data somewhere so we don't have to do all those FFTs again next. You'll have to specify the path where the files get stored via the --turb_path option.
+
+#Usage
+
+Run python MakeCloud.py -h for instructions
+
+e.g. if I wanted a 10^6 solar mass cloud of radius 100pc, resolved in 10^6 gas cells, I would do
+
+python MakeCloud.py --M=1e6 --R=100 --N=1000000

makecloud-1.0.0/calcGMCProps.py

@@ -0,0 +1,111 @@
+"""
+Simple routines to calculate the cloud's: radius, 
+average density, surface density, free-fall time (in years),
+and number of particles (N) given a cloud mass and cell mass
+resolution to choose 
+
+Written by: Anna Rosen, 11/2/22
+"""
+
+import math
+import numpy
+
+MSUN = 1.989e33  # g
+PCCM = 3.086e18  # cm
+G = 6.6743e-8  # cm^3 g^-1 s
+SECYR = 3600 * 24 * 365.25  # s
+
+
+def calcRhoAve(Mcl, Rcl=None, Sigma=1):
+    """
+    Inputs:
+    #cloud mass = Mcl [Msun]
+    #cloud radius = Rcl [pc]
+    #Sigma = Cloud surface density, default = 1 g/cm^2
+
+    Output:
+    rho_ave [g/cm^3]
+    """
+    if Rcl is None and Sigma > 0.0:
+        print(
+            "No Rcl supplied, calc. Rcl assuming Sigma = %.2e g/cm^2" % Sigma
+        )
+        Rcl = calcRcl(Mcl, Sigma)
+    else:
+        print("Error: must supple Rcl (in pc) or Sigma > 0")
+    M = Mcl * MSUN
+    R = Rcl * PCCM
+    rho_ave = 3 * M / (4 * math.pi * R**3.0)
+    print("Average cloud density =  %.2e g/cm^3" % rho_ave)
+    return rho_ave
+
+
+def calcRcl(Mcl, Sigma):
+    """
+    Inputs:
+    #cloud mass = Mcl [Msun]
+    #cloud surface density = Sigma [g/cm^2]
+
+    Output:
+    Rcl [pc]
+    """
+    M = Mcl * MSUN
+    Rcl = (M / (math.pi * Sigma)) ** 0.5 / PCCM
+    print("Cloud Radius = %.2f pc" % Rcl)
+    return Rcl
+
+
+def calc_SurfaceDensity(Mcl, Rcl):
+    """
+    Inputs:
+    #cloud mass = Mcl [Msun]
+    #cloud radius = Sigma [g/cm^2]
+
+    Output:
+    Sigma [g/cm^2]
+    """
+    M = Mcl * MSUN
+    R = Rcl * PCCM
+    Sigma = M / (math.pi * R**3.0)
+    print("Cloud surface density =  %.2e g/cm^2" % Sigma)
+    return rho_ave
+
+
+def calc_tff(Mcl, Rcl=None, Sigma=1):
+    """
+    Inputs:
+    #cloud mass = Mcl [Msun]
+    #cloud surface density = Sigma [g/cm^2]
+
+    Output:
+    tff [yr]
+    """
+    if Rcl is None and Sigma > 0.0:
+        print(
+            "No Rcl supplied, calc. Rcl assuming Sigma = %.2e g/cm^2" % Sigma
+        )
+        Rcl = calcRcl(Mcl, Sigma)
+    else:
+        print("Error: must supple Rcl (in pc) or Sigma > 0")
+
+    rho_ave = calcRhoAve(Mcl, Rcl=Rcl, Sigma=1)
+
+    tff = (3 * math.pi / (32 * G * rho_ave)) ** 0.5 / SECYR
+    print("tff = %.2f yr" % tff)
+    return tff
+
+
+def calc_Npart(Mcl, massRes=1e-3):
+    """
+    Inputs:
+    #cloud mass = Mcl [Msun]
+    #mass/cell [Msun]
+
+    Output:
+    N [particles]
+    """
+
+    N = Mcl / massRes
+    print("For Mcl = %.2e Msun, Mcell = %.2e" % (Mcl, massRes))
+    print("N = %.2e particles" % N)
+    return N

makecloud-1.0.0/makecloud/params.txt

@@ -0,0 +1,250 @@
+%-------------------------------------------------------------------------
+%----  This file contains the input parameters needed at run-time for 
+%       simulations. It is based on and closely resembles the GADGET-3
+%       parameterfile (format of which and parsing routines written by 
+%       Volker Springel [volker.springel@h-its.org]). It has been updated
+%       with new naming conventions and additional variables as needed by 
+%       Phil Hopkins [phopkins@caltech.edu] for GIZMO.
+%-------------------------------------------------------------------------
+
+%----  Relevant files (filenames and directories)
+InitCondFile  NAME
+OutputDir     OUTFOLDER
+
+%---- File formats (input and output)
+ICFormat    3  % 1=unformatted (gadget) binary, 3=hdf5, 4=cluster
+SnapFormat  3  % 1=unformatted (gadget) binary, 3=hdf5
+
+
+%---- Output parameters 
+RestartFile                 restart 
+SnapshotFileBase            snapshot 
+OutputListOn                0  % =1 to use list in "OutputListFilename" 
+OutputListFilename          output_times.txt  % list of times (in code units) for snaps
+NumFilesPerSnapshot         1
+NumFilesWrittenInParallel   1  % must be < N_processors & power of 2
+
+%---- Output frequency 
+TimeOfFirstSnapshot     0.  % time (code units) of first snapshot
+TimeBetSnapshot         DTSNAP  % time between (if OutputListOn=0), code units
+TimeBetStatistics       DTSNAP % time between additional statistics (e.g. energy)
+
+%---- CPU run-time and checkpointing time-limits
+TimeLimitCPU            172800  % in seconds
+CpuTimeBetRestartFile   7200  	% in seconds 
+ResubmitOn              0 
+ResubmitCommand         my-scriptfile 
+
+%---- Desired simulation beginning and end times (in code units) for run
+TimeBegin   0.0    % Beginning of the simulation
+TimeMax     TMAX    % End of the simulation
+
+%---- Maximum and minimum timesteps allowed
+MaxSizeTimestep         MAXTIMESTEP  % in code units, set for your problem
+MinSizeTimestep         1.0e-15 % set this very low, or get the wrong answer
+
+
+%---- System of units
+UnitLength_in_cm            UNIT_L
+UnitMass_in_g               UNIT_M
+UnitVelocity_in_cm_per_s    UNIT_V
+UnitMagneticField_in_gauss  UNIT_B
+GravityConstantInternal     0           % calculated by code if =0
+
+%---- Cosmological parameters
+ComovingIntegrationOn   0       % is it cosmological? (yes=1, no=0)
+BoxSize                 BOXSIZE  % in code units
+Omega0                  0.    % =0 for non-cosmological
+OmegaLambda             0.    % =0 for non-cosmological
+OmegaBaryon             0.  % =0 for non-cosmological
+HubbleParam             1.     % little 'h'; =1 for non-cosmological runs
+
+
+%----- Memory allocation
+%MaxMemSize          5000    % sets maximum MPI process memory use in MByte
+PartAllocFactor     5.0     % memory load allowed for better cpu balance
+BufferSize          500     % in MByte
+
+%---- Rebuild domains when >this fraction of particles active
+TreeDomainUpdateFrequency   0.005    % 0.0005-0.05, dept on core+particle number
+
+
+%---- (Optional) Initial hydro temperature & temperature floor (in Kelvin)
+InitGasTemp     1e4	    % set by IC file if =0
+MinGasTemp     	2.73	    % don't trust cooling function below ~5K, whether dust, molecular lines, or photoelectric heating
+InitRadiationTemp 20.       % Initial and/or boundary radiation temperature (for RT_INFRARED)
+
+%---- Hydro reconstruction (kernel) parameters
+DesNumNgb               32      % domain-reconstruction kernel number: 32 standard, 60-114 for quintic
+MaxHsml                 1.0e10  % minimum gas kernel length (some very large value to prevent errors)
+MinGasHsmlFractional    0       % minimum kernel length relative to gas force softening (<= 1)
+
+
+%---- Gravitational softening lengths 
+%----- Softening lengths per particle type. If ADAPTIVE_GRAVSOFT is set, these  
+%-------- are the minimum softening allowed for each type ------- 
+%-------- (units are co-moving for cosmological integrations)
+SofteningGas    1e-10   % gas (particle type=0) (in co-moving code units)
+SofteningHalo   0.020    % dark matter/collisionless particles (type=1)
+SofteningDisk   0.150    % collisionless particles (type=2)
+SofteningBulge  0.500    % collisionless particles (type=3)
+SofteningStars  SOFTENING   % stars spawned from gas (type=4)
+SofteningBndry  SOFTENING       % black holes (if active), or collisionless (type=5)
+
+%---- if these are set in cosmo runs, SofteningX switches from comoving to physical
+%------- units when the comoving value exceeds the choice here
+%------- (these are ignored, and *only* the above are used, for non-cosmo runs)
+SofteningGasMaxPhys     0.0005  % e.g. switch to 0.5pc physical below z=1
+SofteningHaloMaxPhys    0.010
+SofteningDiskMaxPhys    0.075 
+SofteningBulgeMaxPhys   0.250 
+SofteningStarsMaxPhys   0.0005 
+SofteningBndryMaxPhys   0.0005 
+%----- parameters for adaptive gravitational softening 
+AGS_DesNumNgb           32  % neighbor number for calculating adaptive gravsoft
+
+
+
+
+%-------------------------------------------------------------------------
+%-------------------------------------------------------------------------
+%---------- Physics Modules ----------------------------------------------
+%-------------------------------------------------------------------------
+%-------------------------------------------------------------------------
+
+
+%------------------------------------------------------------
+%------------------ Additional Fluid Physics ----------------
+%------------------------------------------------------------
+
+%---- Magneto-Hydrodynamics Parameters (MAGNETIC on)
+%----- Initial B-Field Strengths (if MHD_B_SET_IN_PARAMS on, otherwise read from IC file)
+BiniX   1.0e-8    % initial B_x, in code units
+BiniY   1.0e-8    % initial B_y, in code units
+BiniZ   1.0e-8    % initial B_z, in code units
+
+%---- Thermal Conduction (CONDUCTION on)
+%----- set coefficient kappa [code units] or, if CONDUCTION_SPITZER on, multiplies value
+ConductionCoeff  1.0  % set/multiply conduction coefficient
+
+%---- Navier-Stokes Viscosity (VISCOSITY on)
+%--- set coefficients eta,zeta [code units] or, if VISCOSITY_BRAGINSKII on, multiplies value
+ShearViscosityCoeff     1.0     % set/multiply shear viscosity coefficient
+BulkViscosityCoeff      1.0     % set/multiply bulk viscosity coefficient
+
+%---- Turbulent Diffusion Master Switch (TURB_DIFFUSION on)
+TurbDiffusionCoefficient 1.0    % Normalizes diffusion rates relative to Smagorinsky-Lilly theory [best calibration] (~0.5-2)
+
+%---- Cosmic Ray + Gas Fluids (COSMIC_RAYS on)
+CosmicRayDiffusionCoeff     1.0     % multiplies anisotropic diffusion/streaming coefficients
+
+%---- Dust-Gas Mixtures (GRAIN_FLUID on)
+Grain_Internal_Density      1.0     % internal/material density of grains in g/cm^3
+Grain_Size_Min              1.e-6   % minimum grain size in cm
+Grain_Size_Max              1.e-4   % maximum grain size in cm
+Grain_Size_Spectrum_Powerlaw  0.5   % power-law distribution of grain sizes (dm/dlnr~r^x)
+
+
+%-------------------------------------------------------------------------
+%------------------ Star, Black Hole, and Galaxy Formation ---------------
+%-------------------------------------------------------------------------
+
+
+%---- Star Formation parameters (GALSF on)
+CritPhysDensity     RHOMAX    %  critical physical density for star formation (cm^(-3)) 
+SfEffPerFreeFall    1.0     %  SFR/(Mgas/tfreefall) for gas which meets SF criteria
+
+
+
+%-------------- FIRE (PFH) explicit star formation & feedback model (FIRE on)
+%--- initial metallicity of gas & stars in simulation 
+InitMetallicity             ZINIT  % initial gas+stellar metallicity (in solar)
+InitStellarAge              0.0   % initial mean age (in Gyr; for stars in sim ICs)
+%--- local radiation-pressure driven winds (GALSF_FB_FIRE_RT_LOCALRP) 
+WindMomentumLoading         1.0     % fraction of photon momentum to couple
+%--- SneII Heating Model (GALSF_FB_MECHANICAL) 
+SNeIIEnergyFrac             1.0     % fraction of mechanical energy to couple
+%--- HII region photo-heating model (GALSF_FB_FIRE_RT_HIIHEATING)  
+HIIRegion_fLum_Coupled      1.0     % fraction of ionizing photons allowed to see gas
+%--- long-range radiation pressure acceleration (GALSF_FB_FIRE_RT_LONGRANGE) 
+PhotonMomentum_Coupled_Fraction  1.0  % fraction of L to allow incident
+PhotonMomentum_fUV          0.0    % incident SED f(L) in UV (minimum scattering)
+PhotonMomentum_fOPT         0.0    % incident SED f(L) in optical/near-IR 
+%--- gas return/recycling
+GasReturnFraction           1.0     % fraction of gas mass returned (relative to ssp)
+GasReturnEnergy             1.0     % fraction of returned gas energy+momentum (relative to ssp)
+%--- cosmic rays (COSMIC_RAYS)
+CosmicRay_SNeFraction       0.1     % fraction of SNe ejecta kinetic energy into cosmic rays (~10%)
+
+InterstellarRadiationFieldStrength  ISRF % interstellar radiation field intensity relative to values measured in Solar neighborhood
+
+%-------------- Black Hole accretion & formation (BLACK_HOLES on)
+%--- formation/seeding  
+SeedSinkMass            BH_SEED_MASS    % initial mass (on-the-fly or single galaxy)
+SeedAlphaDiskMass            0.0        % initial mass in the alpha disk (BH_ALPHADISK_ACCRETION)
+SeedSinkMinRedshift     2.0        % minimum redshift where new BH particles are seeded (lower-z ceases seeding)
+SeedSinkMassSigma       0.5        % lognormal standard deviation (in dex) in initial BH seed masses
+%----- (specific options for on-the-fly friends-of-friends based BH seeding: FOF on)
+MinFoFMassForNewSeed         10.	    % minimum mass of FOF group (stars or DM) to get seed, in code units
+TimeBetOnTheFlyFoF           1.01       % time (in code units, e.g. scale-factor) between on-the-fly FOF searches
+%--- accretion
+SinkAccretionFactor     1.0	    % multiplier for mdot (relative to model)
+SinkEddingtonFactor     1e100	    % fraction of eddington to cap (can be >1) 
+SinkNgbFactor           1.0	    % multiplier for kernel neighbors for BH 
+SinkMaxAccretionRadius  BOXSIZE	    % max radius for BH neighbor search/accretion (code units)
+SinkRadiativeEfficiency 5e-7        % radiative efficiency (for accretion and feedback)
+%--- feedback 
+SinkFeedbackFactor      1.0	    % generic feedback strength multiplier 
+BH_FluxMomentumFactor        0.0	    % multiply radiation pressure (BH_PHOTONMOMENTUM), set it to zero to avoid launching gas from rad. pressure 
+Sink_f_accretion              0.7        % fraction of gas swallowed by BH (BH_WIND options)
+Sink_v_outflow                100.	    % velocity (km/s) of BAL outflow (BH_WIND options)
+Sink_internal_temperature     1.0e3      % internal temperature (K) of BAL outflow (BH_WIND_SPAWN)
+Sink_wind_particle_mass       JET_PART_MASS     % mass of 'virtual wind particles' in code units (BH_WIND_SPAWN)
+Sink_wind_particle_mass_MS    MS_WIND_PART_MASS     % mass of 'virtual wind particles' in MS stellar winds, if 0 then Sink_wind_particle_mass is used, in code units (SINGLE_STAR_FB_WINDS)
+
+
+%-------------------------------------------------------------------------
+%------------------ Grackle cooling module -----------------
+%-------------------------------------------------------------------------
+
+%-------------- Grackle UVB file (COOL_GRACKLE on)
+GrackleDataFile		     CloudyData_UVB=HM2012.h5
+
+
+
+%-------------------------------------------------------------------------
+%------------------ Driven Turbulence (Large-Eddy boxes) -----------------
+%-------------------------------------------------------------------------
+
+%-------------- Turbulent stirring parameters (TURB_DRIVING on)
+TurbDrive_ApproxRMSVturb            TURB_SIGMA
+TurbDrive_MinWavelength             TURB_MINLAMBDA 
+TurbDrive_MaxWavelength             TURB_MAXLAMBDA 
+TurbDrive_SolenoidalFraction        1  
+TurbDrive_CoherenceTime             TURB_COHERENCE_TIME
+TurbDrive_DrivingSpectrum           1
+TurbDrive_RandomNumberSeed          42
+TurbDrive_TimeBetweenTurbUpdates    DTSNAP
+TurbDrive_TimeBetTurbSpectrum       DTSNAP
+
+
+%-------------------------------------------------------------------------------------------------
+%------------------ Non-Standard Dark Matter, Dark Energy, Gravity, or Expansion -----------------
+%-------------------------------------------------------------------------------------------------
+
+%-------------- Parameters for non-standard or time-dependent Gravity/Dark Energy/Expansion (GR_TABULATED_COSMOLOGY on)
+DarkEnergyConstantW       -1        % time-independent DE parameter w, used only if no table
+TabulatedCosmologyFile    CosmoTbl  % table with cosmological parameters
+
+%--- Developer-Mode Parameters (usually hard-coded, but set manually if DEVELOPER_MODE is on) --------
+ErrTolTheta                  0.5    % 0.7=standard
+ErrTolForceAcc               0.0025 % 0.0025=standard
+ErrTolIntAccuracy        0.01  % <0.02
+CourantFac               0.2    % <0.20
+MaxRMSDisplacementFac    0.125  % <0.25
+MaxNumNgbDeviation      0.05    % <<DesNumNgb (values<1 are fine)
+AGS_MaxNumNgbDeviation  0.10  % tolerance in Nngb (make larger than gas)
+%---- Magneto-Hydrodynamics Developer-Mode Parameters (MAGNETIC on)
+%--- Dedner 2002 div-cleaning parameters
+DivBcleaningParabolicSigma   1.0 % (3D~0.7-1.0,2D~0.2-0.3)
+DivBcleaningHyperbolicSigma  1.0 % (~1)

makecloud-1.0.0/makecloud.egg-info/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: makecloud
+Version: 1.0.0
+Summary: Generate turbulent molecular cloud initial conditions for GIZMO/STARFORGE simulations
+Author: Dávid Guszejnov
+Author-email: "Michael Y. Grudić" <mgrudic@flatironinstitute.org>
+License: MIT
+Project-URL: Homepage, https://github.com/mikegrudic/MakeCloud
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: h5py
+Requires-Dist: docopt
+
+# MakeCloud
+
+Requires the following packages:
+numpy
+scipy
+h5py
+docopt
+
+If you want to use glassy initial conditions, you will need <a href=https://data.obs.carnegiescience.edu/starforge/glass_orig.npy>this file</a>, and you should point the script to it via the --glass_path option.
+
+By default, we generate turbulent velocity fields on the fly but then store that data somewhere so we don't have to do all those FFTs again next. You'll have to specify the path where the files get stored via the --turb_path option.
+
+#Usage
+
+Run python MakeCloud.py -h for instructions
+
+e.g. if I wanted a 10^6 solar mass cloud of radius 100pc, resolved in 10^6 gas cells, I would do
+
+python MakeCloud.py --M=1e6 --R=100 --N=1000000

makecloud-1.0.0/makecloud.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+MakeCloud.py
+README.md
+calcGMCProps.py
+pyproject.toml
+makecloud/__init__.py
+makecloud/params.txt
+makecloud.egg-info/PKG-INFO
+makecloud.egg-info/SOURCES.txt
+makecloud.egg-info/dependency_links.txt
+makecloud.egg-info/entry_points.txt
+makecloud.egg-info/requires.txt
+makecloud.egg-info/top_level.txt

makecloud-1.0.0/makecloud.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

makecloud-1.0.0/makecloud.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+makecloud = MakeCloud:main

makecloud-1.0.0/makecloud.egg-info/requires.txt

@@ -0,0 +1,4 @@
+numpy
+scipy
+h5py
+docopt

makecloud-1.0.0/makecloud.egg-info/top_level.txt

@@ -0,0 +1,3 @@
+MakeCloud
+calcGMCProps
+makecloud

makecloud-1.0.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "makecloud"
+version = "1.0.0"
+description = "Generate turbulent molecular cloud initial conditions for GIZMO/STARFORGE simulations"
+authors = [
+    {name = "Michael Y. Grudić", email = "mgrudic@flatironinstitute.org"},
+    {name = "Dávid Guszejnov"},
+]
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+dependencies = [
+    "numpy",
+    "scipy",
+    "h5py",
+    "docopt",
+]
+
+[project.urls]
+Homepage = "https://github.com/mikegrudic/MakeCloud"
+
+[project.scripts]
+makecloud = "MakeCloud:main"
+
+[tool.setuptools]
+py-modules = ["MakeCloud", "calcGMCProps"]
+packages = ["makecloud"]
+
+[tool.setuptools.package-data]
+makecloud = ["params.txt"]

makecloud-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+