def make_giant_molecular_clouds(Ngmc):
    N_thick_disk = int(0.5 * Ngmc)
    N_thin_disk = int(0.5 * Ngmc)
    converter = nbody_system.nbody_to_si(1.e+8 | units.MSun, 1.0 | units.kpc)
    from amuse.ext.protodisk import ProtoPlanetaryDisk
    Rin = 3.5 | units.kpc
    Rout = 7.5 | units.kpc
    masses = new_powerlaw_mass_distribution(N_thick_disk,
                                            alpha=-1.6,
                                            mass_min=1.0e+3 | units.MSun,
                                            mass_max=1.0e+8 | units.MSun)
    MGMCs = masses.sum()
    MWG = MilkyWay_galaxy()
    v_inner = MWG.vel_circ(Rout)
    MGalaxy = v_inner**2 * Rout / constants.G
    print("Masses:", MGMCs.in_(units.MSun), MGalaxy.in_(units.MSun), \
          MGMCs/MGalaxy)
    GMCs = ProtoPlanetaryDisk(len(masses),
                              convert_nbody=converter,
                              Rmin=Rin.value_in(units.kpc),
                              Rmax=Rout.value_in(units.kpc),
                              q_out=30.0,
                              discfraction=MGMCs / MGalaxy).result

    #second population of GMCs
    masses = new_powerlaw_mass_distribution(len(GMCs),
                                            alpha=-1.6,
                                            mass_min=1.e+3 | units.MSun,
                                            mass_max=1.0e+8 | units.MSun)
    GMCs.mass = masses
    MGMCs = masses.sum()
    thin_disk_GMCs = ProtoPlanetaryDisk(N_thin_disk,
                                        convert_nbody=converter,
                                        Rmin=Rin.value_in(units.kpc),
                                        Rmax=2 * Rout.value_in(units.kpc),
                                        q_out=10.0,
                                        discfraction=MGMCs / MGalaxy).result
    thin_disk_GMCs.masses = masses
    GMCs.add_particles(thin_disk_GMCs)
    GMCs.velocity *= -1
    GMCs.mass = new_powerlaw_mass_distribution(len(GMCs),
                                               alpha=-1.6,
                                               mass_min=1.e+3 | units.MSun,
                                               mass_max=1.0e+8 | units.MSun)
    print("v=", v_inner.in_(units.kms))
    print("GMC mass=", GMCs.mass.sum().in_(units.MSun))
    for gi in range(len(GMCs)):
        r = GMCs[gi].position.length()
        vc = MWG.vel_circ(r)
        GMCs[gi].velocity = GMCs[gi].velocity * (vc /
                                                 GMCs[gi].velocity.length())

    return GMCs
def add_debris_disk(star,
                    ndisk_per_MSun,
                    fdisk,
                    masteroid,
                    Rmin,
                    Rmax,
                    alpha=1.5,
                    Q=1.0):

    Ndisk = int(ndisk_per_MSun * star.mass.value_in(units.MSun))
    print("Run with Ndisk = ", Ndisk)

    converter = nbody_system.nbody_to_si(star.mass, Rmin)
    disk = ProtoPlanetaryDisk(Ndisk,
                              convert_nbody=converter,
                              densitypower=alpha,
                              Rmin=Rmin / Rmin,
                              Rmax=Rmax / Rmin,
                              q_out=Q,
                              discfraction=fdisk).result

    disk.mass = masteroid
    disk.name = "asteroid"
    disk.type = "debris"
    disk.host = star.key
    disk.position += star.position
    disk.velocity += star.velocity
    return disk
def make_giant_molecular_clouds(Ngmc):
    N_thick_disk = int(0.5*Ngmc)
    N_thin_disk = int(0.5*Ngmc)
    converter=nbody_system.nbody_to_si(1.e+8|units.MSun, 1.0|units.kpc)
    from amuse.ext.protodisk import ProtoPlanetaryDisk
    Rin = 3.5 | units.kpc
    Rout = 7.5 | units.kpc
    masses = new_powerlaw_mass_distribution(N_thick_disk, alpha=-1.6,
                                            mass_min=1.0e+3|units.MSun,
                                            mass_max=1.0e+8|units.MSun)
    MGMCs = masses.sum()
    MWG = MilkyWay_galaxy()    
    v_inner = MWG.vel_circ(Rout)
    MGalaxy = v_inner**2*Rout/constants.G
    print "Masses:", MGMCs.in_(units.MSun), MGalaxy.in_(units.MSun), \
          MGMCs/MGalaxy
    GMCs = ProtoPlanetaryDisk(len(masses), convert_nbody=converter,
                              Rmin=Rin.value_in(units.kpc), 
                              Rmax=Rout.value_in(units.kpc),
                              q_out=30.0, discfraction=MGMCs/MGalaxy).result

    #second population of GMCs
    masses = new_powerlaw_mass_distribution(len(GMCs), alpha=-1.6,
                                            mass_min=1.e+3|units.MSun,
                                            mass_max=1.0e+8|units.MSun)    
    GMCs.mass = masses
    MGMCs = masses.sum()
    thin_disk_GMCs = ProtoPlanetaryDisk(N_thin_disk, convert_nbody=converter,
                              Rmin=Rin.value_in(units.kpc), 
                              Rmax=2*Rout.value_in(units.kpc),
                              q_out=10.0, discfraction=MGMCs/MGalaxy).result
    thin_disk_GMCs.masses = masses
    GMCs.add_particles(thin_disk_GMCs)
    GMCs.velocity *= -1
    GMCs.mass = new_powerlaw_mass_distribution(len(GMCs), alpha=-1.6,
                                                 mass_min=1.e+3|units.MSun,
                                                 mass_max=1.0e+8|units.MSun)
    print "v=", v_inner.in_(units.kms)
    print "GMC mass=", GMCs.mass.sum().in_(units.MSun)
    for gi in range(len(GMCs)):
        r = GMCs[gi].position.length()
        vc = MWG.vel_circ(r)
        GMCs[gi].velocity = GMCs[gi].velocity * (vc/GMCs[gi].velocity.length())

    return GMCs
示例#4
0
def initial_conditions(Q, N, Rmax, diskmassfrac, seed_disk):
    '''
	returns Sun + 8 planets, as well as a disk around Neptune
	'''

    #get the solar system objects

    sun_and_planets = new_solar_system()

    #throw out Pluto, get Neptune object from new_solar_system
    N_particles = len(sun_and_planets)
    sun_and_planets = sun_and_planets[:N_particles - 1]
    Nep_ind = len(sun_and_planets) - 1
    Sun = sun_and_planets[0]
    Neptune = sun_and_planets[Nep_ind]

    #hill radius of Neptune
    a_Neptune = np.sqrt(Neptune.x**2 + Neptune.y**2 + Neptune.z**2)
    Neptune_Hill = a_Neptune * (Neptune.mass / Sun.mass)**(1 / 3.)

    #get the disk with appropriate Salpeter mass distribution

    #Salpeter mass function with a range of 1 order of magnitude
    mmin = 0.0005 * Neptune.mass  #mmax goes to 0.005
    masses = new_salpeter_mass_distribution(N,
                                            mass_min=mmin,
                                            mass_max=(10 * mmin))

    #set up converter, protoplanetary disk gas particles
    np.random.seed(seed_disk)  #random seed for the disk
    converter_gas = nbody_system.nbody_to_si(Neptune.mass, Rmax | units.AU)
    gas = ProtoPlanetaryDisk(N,
                             convert_nbody=converter_gas,
                             Rmin=converter_gas.to_nbody(Neptune_Hill).number,
                             Rmax=converter_gas.to_nbody(Rmax
                                                         | units.AU).number,
                             q_out=Q,
                             discfraction=diskmassfrac).result

    #attribute Salpeter masses to the gas
    gas.mass = masses

    #move disk to Neptune's phase space coordinates
    gas.x += Neptune.x
    gas.y += Neptune.y
    gas.z += Neptune.z
    gas.vx += Neptune.vx
    gas.vy += Neptune.vy
    gas.vz += Neptune.vz

    return sun_and_planets, gas