def __init__(self, scanId, show_rays=True, show_grid=True):
self.scanId = scanId
self.root, self.target, agent_pose, goal_pose = scanId.split('-')
self.root = os.path.join(Files.basedir, dirname(self.root))
self.agent_pose_ini = to_array(agent_pose)
self.goal_pose_ini = to_array(goal_pose)
# Cache variables
self.pmc_var = None
# Visualization settnigs
self.show_rays = show_rays
self.show_grid = show_grid
# Floyd warshall algorithm for shortest path supervision
self.mapfile_var = join(self.root, Files.objfile)
self.planner = FloydWarshallRobotslang(self.mapfile_var)
# Navigation pixels for visualization
self.nav_pixels = self.planner.navigable_pixels
## Target poses
self.target_poses = get_targets()[scanId]
self.target_pixels = pose2pixel(np.asarray(self.target_poses), MC.mazeshape)
self.target_pixels = list(zip(["jar", "mug", "paddle"], self.target_pixels))
# Randomize location of agent and goal
self.agent = Particles(1)
self.goal = Particles(1)
# Start by resetting
self.reset()
def run_temporal_moments_calculation(number_of_moments,
segmentation_tuple,
kind_of='not_norm'):
p = Particles('./data/position_data_1_1.txt')
segmentations = np.arange(*segmentation_tuple)
moments_n = np.zeros((len(segmentations), number_of_moments))
if kind_of == 'norm':
mom = Moments.normalized_temporal_moment
elif kind_of == 'not_norm':
mom = Moments.temporal_moment
for n in np.arange(0, number_of_moments): # order of the moment
for i, l in enumerate(segmentations): # lengths to be tested
moments_n[i, n] = mom(
n, p.time,
p.discrete_particle_distribution(l, p.time, p.qy))
# print(np.trapz(p.discrete_particle_distribution(l, p.time, p.qy)))
moment_list = []
for i in np.arange(0, number_of_moments):
moment_list.append('m_' + str(i))
moments_n_df = pd.DataFrame(moments_n,
columns=moment_list,
index=segmentations)
moments_n_df.to_csv('./data/temporal_moments.csv')
moments_n_df = moments_n_df.drop('m_0',
axis=1) # drop in order not to plot
moments_n_df.plot()
plt.xlabel('Segmentation L [m]')
plt.xlim(segmentations[1], segmentations[-1])
plt.ylabel('Moment []')
plt.title('Moment versus L')
plt.savefig('./data/temporal_moments.png')
def __init__(self, env, num_particles, particle_angle_range, num_rays,
r_mean, r_std, ang_mean, ang_std, visualize, background, save_to,
row_min, row_max, n_angle_bins, front_angle_range):
"""Instantiates the visual particle filter with initial constraints.
Args:
run (dataset object): Provides access to an experiment
experiment Location of the experiment
mapfile Image location of top down maze image that is in turn converted
to gridmap file via the Gridmap class
num_particles Number of particles used for tracking
particle_size Size for scatter plot particles
arrow_size Arrow size (in meters)
"""
# Set the run
self.env = env
# Setup the particles
self.particles = Particles(num_particles, r_mean, r_std, ang_mean, ang_std)
## Matplotlib based visualization
self.visualize = visualize
self.viz_map = env.mapfile
self.featurizer = HistogramFeatures()
# Color gradient
self.num_cgs = 100
self.color_gradient = list(Color("red").range_to(Color("green"), self.num_cgs))
def heatmap(self, viz):
viz = viz * 0
planner = self.env.planner
particles = Particles(planner.poses.shape[0])
particles.pose[:,:2] = planner.poses[:,:2]
particles.pose[:, 2] = self.env.agent.pose[:,2]
pixels = pose2pixel(particles.pose, MC.mazeshape)
weights = np.zeros(len(particles))
measurement = self.env.get_visual_obs(self.env.agent.pose)
for i, (pose, pix) in enumerate(zip(particles.pose, pixels)):
pose_measurement = self.env.get_visual_obs(pose)
weights[i] = (pose_measurement == measurement).sum()
#print(weights.max(), weights.min(), weights.mean())
#weights = softmax(weights, t=.05)
for i, (pose, pix) in enumerate(zip(particles.pose, pixels)):
c_indx = int((self.num_cgs-1) * weights[i]/weights.max())
color = color2bgr(self.color_gradient[c_indx])
self.env.draw_circle(viz, pix, rad=20, color=color)
self.env.draw_orientation(viz, pose, thickness=2)
for i, (pose, pix) in enumerate(zip(particles.pose, pixels)):
cv2.putText(viz, str(int(weights[i])), point(pix), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2, cv2.LINE_AA)
return viz
def main():
parser = argparse.ArgumentParser(description="FluidSim")
parser.add_argument("--USE_SPHERICAL_GRAV", default=False)
parser.add_argument("--SimType", type=str, default='PIC')
parser.add_argument("--GRAV_FACTOR", type=float, default=0.01)
parser.add_argument('--out_dir', type=str, default='output/')
parser.add_argument('--n_iter', type=int, default=50)
args = parser.parse_args()
gravity = 9.8
if (args.USE_SPHERICAL_GRAV):
gravity *= args.GRAV_FACTOR
grid = Grid3D(gravity, (30, 30, 30), 1) #g, (nx,ny,nz),lx
if not os.path.exists(args.out_dir):
os.makedirs(args.out_dir)
particles = Particles(grid, args.SimType)
init_water_drop(grid, particles, 2, 2, 2)
particles.write_to_file("{}/frameparticles{:0>4}".format(args.out_dir, 0))
for i in range(args.n_iter):
print(
"===================================================> step {}...\n"
.format(i))
advance_one_frame(grid, particles, 1 / 30)
particles.write_to_file("{}/frameparticles{:0>4}".format(
args.out_dir, i))
def generate(self):
''' Returns a particle object with the parameters specified
in the constructor of the Generator object
'''
coords = self._create_phase_space()
particles = Particles(self.macroparticlenumber,
self.intensity/self.macroparticlenumber,
self.charge, self.mass, self.circumference,
self.gamma,
coords_n_momenta_dict=coords)
self._linear_match_phase_space(particles)
return particles
def run_particle_distibution_graphs(self):
p = Particles('./data/position_data_example_1.txt',
dimension=2,
time_start=0,
time_end=500000,
time_step=100)
dist_cum = p.cumulative_distribution(0.0000505, p.qx)
# dist_disc = p.discrete_particle_distribution(0.00005, p.time, p.qy)
plt.scatter(range(len(dist_cum)), dist_cum)
plt.xlabel('time')
plt.ylabel('N')
plt.grid(1)
plt.show()
def __init__(self, ai_game, simple: bool = True) -> None:
self.settings = ai_game.settings
self.screen = ai_game.screen
self.screen_rect = ai_game.screen.get_rect()
self.image = pygame.image.load("images/ship.png")
self.orig_image = self.image
self.rect = self.image.get_rect()
self.rect.midbottom = self.screen_rect.midbottom
self.rect.y -= 10
self.moving_right = False
self.moving_left = False
self.moving_down = False
self.moving_up = False
self.x = float(self.rect.x)
self.y = float(self.rect.y)
self.simple = simple
self.hide = False
self.particles = Particles(self.screen)
def __init__(self):
rospy.init_node('pf')
# pose_listener responds to selection of a new approximate robot
# location (for instance using rviz)
rospy.Subscriber("initialpose",
PoseWithCovarianceStamped,
self.update_initial_pose)
# publisher for the particle cloud for visualizing in rviz.
self.particle_pub = rospy.Publisher("particlecloud",
PoseArray,
queue_size=10)
# create instances of two helper objects that are provided to you
# as part of the project
self.occupancy_field = OccupancyField()
self.transform_helper = TFHelper()
self.particles = Particles()
self.particles.initialize_particles()
self.ranges = []
def two_particles_1d_random(self):
return Particles(num_particles=2,
num_dimensions=1,
mass=1,
diameter=0.1)
import matplotlib.pyplot as plt
from matplotlib import animation
from matplotlib.patches import Circle, Arrow
import numpy as np
from particles import Particles
from rotor import Rotor
rotor = Rotor()
particles = Particles(rotor=rotor)
fig = plt.figure()
subplot_shape = (2,4)
ax = plt.subplot2grid(subplot_shape, (0,0), rowspan=2, colspan=3)
ax_cumulative_theta = plt.subplot2grid(subplot_shape, (0,3) )
ax_cumulative_theta.xaxis.set_ticks([])
ax_cumulative_v_theta = plt.subplot2grid(subplot_shape, (1,3) )
plt.tight_layout()
ax_main_objs = []
cumulative_plot = None
cumulative_v_plot = None
def init():
global ax_main_objs
global cumulative_plot
global cumulative_v_plot
def __init__(self, screen, endless = False):
self.screen = screen
self.sharks = []
self.shark_sprites = pygame.sprite.Group()
self.player = Steamboat()
self.player_sprite = pygame.sprite.Group()
self.player_sprite.add(self.player)
self.health = Health()
self.health_sprite = pygame.sprite.Group()
self.health_sprite.add(self.health)
self.damage_count = 0
self.t = 0
self.water = Water.global_water
#Water.global_water = self.water
self.water_sprite = pygame.sprite.Group()
self.water_sprite.add(self.water)
if not Game.sky:
Game.sky = util.load_image("taivas")
Game.sky = pygame.transform.scale(self.sky, (SCREEN_WIDTH, SCREEN_HEIGHT))
self.cannonballs = []
self.cannonball_sprites = pygame.sprite.Group()
self.pirates = []
self.pirate_sprites = pygame.sprite.Group()
self.titanic = None
self.titanic_sprite = pygame.sprite.Group()
self.seagulls = []
self.seagull_sprites = pygame.sprite.Group()
self.particles = Particles()
self.particle_sprite = pygame.sprite.Group()
self.particle_sprite.add(self.particles)
self.mines = []
self.mine_sprites = pygame.sprite.Group()
self.score = Score()
self.score_sprite = pygame.sprite.Group()
self.score_sprite.add(self.score)
self.powerups = []
self.powerup_sprites = pygame.sprite.Group()
self.level = Level(endless)
self.lastshot = MIN_FIRE_DELAY + 1
self.gameover = False
self.gameover_image = None
self.gameover_rect = None
self.done = False
self.pause = False
self.pause_image = util.bigfont.render("Pause", Variables.alpha, (0,0,0))
self.pause_rect = self.pause_image.get_rect()
self.pause_rect.center = self.screen.get_rect().center
self.spacepressed = None
def _create_sampler(self, alpha):
parts = Particles(**self.particles_params)
wave_function = WaveFunction(parts,
**self.wave_function_params,
alpha=alpha)
return self.sampler_type(step_size=0.1, wave_function=wave_function)
def main():
parameters = dict()
read_parameters_file(parameters)
check_parameters_consistency(parameters)
print_parameters(parameters)
# gas density field:
density = Field(field="rho", parameters=parameters)
# number of grid cells in the radial and azimuthal directions
nrad = density.nrad
ncol = density.ncol
nsec = density.nsec
# volume of each grid cell (code units)
# calculate_volume(density)
volume = np.zeros((nsec, ncol, nrad))
for i in range(nsec):
for j in range(ncol):
for k in range(nrad):
volume[i, j,
k] = (density.rmed[k]**2 * np.sin(density.tmed[j]) *
density.dr[k] * density.dth[j] * density.dp[i])
# Mass of gas in units of the star's mass
Mgas = np.sum(density.data * volume)
print("Mgas / Mstar= " + str(Mgas) + " and Mgas [kg] = " +
str(Mgas * density.cumass))
# Allocate arrays
nbin = parameters["nbin"]
# bins = np.asarray([0.0001, 0.001, 0.01, 0.1, 0.3, 1, 3, 10, 100, 1000, 3000])
bins = np.asarray([0.0001, 0.001, 0.01, 0.1, 0.2])
particles_per_bin_per_cell = np.zeros(nbin * nsec * ncol * nrad)
dust_cube = np.zeros((nbin, nsec, ncol, nrad))
particles_per_bin = np.zeros(nbin)
tstop_per_bin = np.zeros(nbin)
# =========================
# Compute dust mass volume density for each size bin
# =========================
if (parameters["RTdust_or_gas"] == "dust"
and parameters["recalc_density"] == "Yes"
and parameters["polarized_scat"] == "No"):
print("--------- computing dust mass volume density ----------")
particle_data = Particles(ns=parameters["particle_file"],
directory=parameters["dir"])
populate_dust_bins(
density,
particle_data,
nbin,
bins,
particles_per_bin_per_cell,
particles_per_bin,
tstop_per_bin,
)
dust_cube = particles_per_bin_per_cell.reshape(
(nbin, density.nsec, density.ncol, density.nrad))
frac = np.zeros(nbin)
buf = 0.0
# finally compute dust surface density for each size bin
for ibin in range(nbin):
# fraction of dust mass in current size bin 'ibin', easy to check numerically that sum_frac = 1
frac[ibin] = (pow(bins[ibin + 1], (4.0 - parameters["pindex"])) -
pow(bins[ibin], (4.0 - parameters["pindex"]))) / (
pow(parameters["amax"],
(4.0 - parameters["pindex"])) -
pow(parameters["amin"],
(4.0 - parameters["pindex"])))
# total mass of dust particles in current size bin 'ibin'
M_i_dust = parameters["ratio"] * Mgas * frac[ibin]
buf += M_i_dust
print("Dust mass [in units of Mstar] in species ", ibin, " = ",
M_i_dust)
# dustcube, which contained N_i(r,phi), now contains sigma_i_dust (r,phi)
dust_cube[
ibin, :, :, :] *= M_i_dust / volume / particles_per_bin[ibin]
# conversion in g/cm^2
# dimensions: nbin, nrad, nsec
dust_cube[ibin, :, :, :] *= (density.cumass * 1e3) / (
(density.culength * 1e2)**2.0)
# Overwrite first bin (ibin = 0) to model extra bin with small dust tightly coupled to the gas
if parameters["bin_small_dust"] == "Yes":
frac[0] *= 5e3
print("!!!!!!!!!!!!!!!!!!!!!!!!!!!")
print(
"Bin with index 0 changed to include arbitrarilly small dust tightly coupled to the gas"
)
print("Mass fraction of bin 0 changed to: ", str(frac[0]))
print("!!!!!!!!!!!!!!!!!!!!!!!!!!!")
# radial index corresponding to 0.3"
imin = np.argmin(np.abs(density.rmed - 1.4))
# radial index corresponding to 0.6"
imax = np.argmin(np.abs(density.rmed - 2.8))
dust_cube[0, :, :, imin:imax] = (density.data[:, :, imin:imax] *
parameters["ratio"] * frac[0] *
(density.cumass * 1e3) /
((density.culength * 1e2)**2.0))
print(
"Total dust mass [g] = ",
np.sum(dust_cube[:, :, :, :] * volume *
(density.culength * 1e2)**2.0),
)
print(
"Total dust mass [Mgas] = ",
np.sum(dust_cube[:, :, :, :] * volume *
(density.culength * 1e2)**2.0) /
(Mgas * density.cumass * 1e3),
)
print(
"Total dust mass [Mstar] = ",
np.sum(dust_cube[:, :, :, :] * volume *
(density.culength * 1e2)**2.0) / (density.cumass * 1e3),
)
# Total dust surface density
dust_surface_density = np.sum(dust_cube, axis=0)
print("Maximum dust surface density [in g/cm^2] is ",
dust_surface_density.max())
DUSTOUT = open("dust_density.inp", "w")
DUSTOUT.write("1 \n") # iformat
DUSTOUT.write(str(nrad * nsec * ncol) + " \n") # n cells
DUSTOUT.write(str(int(nbin)) + " \n") # nbin size bins
rhodustcube = np.zeros((nbin, nsec, ncol, nrad))
# dust aspect ratio as function of ibin and r (or actually, R, cylindrical radius)
hd = np.zeros((nbin, nrad))
# gus aspect ratio
hgas = np.zeros(nrad)
for irad in range(nrad):
hgas[irad] = (density.rmed[irad] * np.cos(density.tmed[:]) *
density.data[0, :, irad]).sum(
axis=0) / (density.data[0, :, irad]).sum(axis=0)
for ibin in range(nbin):
if parameters["polarized_scat"] == "No":
for irad in range(nrad):
hd[ibin, irad] = hgas[irad] / np.sqrt(
1.0 +
tstop_per_bin[ibin] / parameters["alphaviscosity"] *
(1.0 + 2.0 * tstop_per_bin[ibin]) /
(1.0 + tstop_per_bin[ibin]))
else:
print(
"Set of initial conditions not implemented for pluto yet. Only parameters['polarized_scat'] == 'No'"
)
sys.exit("I must exit!")
# work out exponential and normalization factors exp(-z^2 / 2H_d^2)
# with z = r cos(theta) and H_d = h_d x R = h_d x r sin(theta)
# r = spherical radius, R = cylindrical radius
rho_dust_cube = dust_cube
rho_dust_cube = np.nan_to_num(rho_dust_cube)
# for plotting purposes
axirhodustcube = np.sum(rho_dust_cube,
axis=3) / nsec # ncol, nbin, nrad
# Renormalize dust's mass volume density such that the sum over the 3D grid's volume of
# the dust's mass volume density x the volume of each grid cell does give us the right
# total dust mass, which equals ratio x Mgas.
rhofield = np.sum(rho_dust_cube, axis=0) # sum over dust bins
Cedge, Aedge, Redge = np.meshgrid(
density.tedge, density.pedge,
density.redge) # ncol+1, nrad+1, Nsec+1
r2 = Redge * Redge
jacob = r2[:-1, :-1, :-1] * np.sin(Cedge[:-1, :-1, :-1])
dphi = Aedge[1:, :-1, :-1] - Aedge[:-1, :-1, :-1] # same as 2pi/nsec
dr = Redge[:-1, :-1, 1:] - Redge[:-1, :-1, :-1] # same as Rsup-Rinf
dtheta = Cedge[:-1, 1:, :-1] - Cedge[:-1, :-1, :-1]
# volume of a cell in cm^3
vol = (jacob * dr * dphi * dtheta * ((density.culength * 1e2)**3)
) # ncol, nrad, Nsec
total_mass = np.sum(rhofield * vol)
normalization_factor = (parameters["ratio"] * Mgas *
(density.cumass * 1e3) / total_mass)
rho_dust_cube = rho_dust_cube * normalization_factor
print(
"total dust mass after vertical expansion [g] = ",
np.sum(np.sum(rho_dust_cube, axis=0) * vol),
" as normalization factor = ",
normalization_factor,
)
# write mass volume densities for all size bins
for ibin in range(nbin):
print("dust species in bin", ibin, "out of ", nbin - 1)
for k in range(nsec):
for j in range(ncol):
for i in range(nrad):
DUSTOUT.write(
str(rho_dust_cube[ibin, k, j, i]) + " \n")
# print max of dust's mass volume density at each colatitude
for j in range(ncol):
print(
"max(rho_dustcube) [g cm-3] for colatitude index j = ",
j,
" = ",
rho_dust_cube[:, :, j, :].max(),
)
DUSTOUT.close()
# plot azimuthally-averaged density vs. radius and colatitude
if parameters["plot_density"] == "Yes":
plot_density(nbin, nsec, ncol, nrad, density, rho_dust_cube)
# free RAM memory
del rho_dust_cube, dust_cube, particles_per_bin_per_cell
elif parameters["RTdust_or_gas"] == "gas":
print(
"Set of initial conditions not implemented for pluto yet. Only parameters['RTdust_or_gas'] == 'dust'"
)
sys.exit("I must exit!")
elif parameters["polarized_scat"] == "Yes":
print(
"Set of initial conditions not implemented for pluto yet. Only parameters['polarized_scat'] == 'No'"
)
sys.exit("I must exit!")
else:
print(
"--------- I did not compute dust densities (recalc_density = No in params.dat file) ----------"
)
# =========================
# Compute dust opacities
# =========================
if parameters["RTdust_or_gas"] == "dust" and parameters[
"recalc_opac"] == "Yes":
print("--------- computing dust opacities ----------")
# Calculation of opacities uses the python scripts makedustopac.py and bhmie.py
# which were written by C. Dullemond, based on the original code by Bohren & Huffman.
logawidth = 0.05 # Smear out the grain size by 5% in both directions
na = 20 # Use 10 grain size samples per bin size
chop = 1.0 # Remove forward scattering within an angle of 5 degrees
# Extrapolate optical constants beyond its wavelength grid, if necessary
extrapol = True
verbose = False # If True, then write out status information
ntheta = 181 # Number of scattering angle sampling points
# link to optical constants file
optconstfile = (os.path.expanduser(parameters["opacity_dir"]) + "/" +
parameters["species"] + ".lnk")
# The material density in gram / cm^3
graindens = 2.0 # default density in g / cc
if (parameters["species"] == "mix_2species_porous"
or parameters["species"] == "mix_2species_porous_ice"
or parameters["species"] == "mix_2species_porous_ice70"):
graindens = 0.1 # g / cc
if (parameters["species"] == "mix_2species"
or parameters["species"] == "mix_2species_60silicates_40ice"):
graindens = 1.7 # g / cc
if parameters["species"] == "mix_2species_ice70":
graindens = 1.26 # g / cc
if parameters["species"] == "mix_2species_60silicates_40carbons":
graindens = 2.7 # g / cc
# Set up a wavelength grid (in cm) upon which we want to compute the opacities
# 1 micron -> 1 cm
lamcm = 10.0**np.linspace(0, 4, 200) * 1e-4
# Set up an angular grid for which we want to compute the scattering matrix Z
theta = np.linspace(0.0, 180.0, ntheta)
for ibin in range(int(nbin)):
# median grain size in cm in current bin size:
agraincm = 10.0**(
0.5 *
(np.log10(1e2 * bins[ibin]) + np.log10(1e2 * bins[ibin + 1])))
print("====================")
print("bin ", ibin + 1, "/", nbin)
print(
"grain size [cm]: ",
agraincm,
" with grain density [g/cc] = ",
graindens,
)
print("====================")
pathout = parameters["species"] + str(ibin)
opac = compute_opac_mie(
optconstfile,
graindens,
agraincm,
lamcm,
theta=theta,
extrapolate=extrapol,
logawidth=logawidth,
na=na,
chopforward=chop,
verbose=verbose,
)
if parameters["scat_mode"] >= 3:
print("Writing dust opacities in dustkapscatmat* files")
write_radmc3d_scatmat_file(opac, pathout)
else:
print("Writing dust opacities in dustkappa* files")
write_radmc3d_kappa_file(opac, pathout)
else:
print(
"------- taking dustkap* opacity files in current directory (recalc_opac = No in params.dat file) ------ "
)
# Write dustopac.inp file even if we don't (re)calculate dust opacities
if parameters["RTdust_or_gas"] == "dust":
print("-> writing dust opacities")
write_dustopac(
species=parameters["species"],
scat_mode=parameters["scat_mode"],
nbin=parameters["nbin"],
)
if parameters["plot_opac"] == "Yes":
print("-> plotting dust opacities")
plot_opacities(
species=parameters["species"],
amin=parameters["amin"],
amax=parameters["amax"],
nbin=parameters["nbin"],
lbda1=parameters["wavelength"] * 1e3,
)
print("-> writing radmc3d script")
write_radmc3d_script(parameters)
# =========================
# Call to RADMC3D thermal solution and ray tracing
# =========================
if parameters["recalc_radmc"] == "Yes" or parameters[
"recalc_rawfits"] == "Yes":
# Write other parameter files required by RADMC3D
print("--------- printing auxiliary files ----------")
# need to check why we need to output wavelength...
if parameters["recalc_rawfits"] == "No":
write_wavelength()
write_stars(Rstar=parameters["rstar"], Tstar=parameters["teff"])
# Write 3D spherical grid for RT computational calculation
write_AMRgrid(density, Plot=False)
# rto_style = 3 means that RADMC3D will write binary output files
# setthreads corresponds to the number of threads (cores) over which radmc3d runs
write_radmc3dinp(
incl_dust=parameters["incl_dust"],
incl_lines=parameters["incl_lines"],
lines_mode=parameters["lines_mode"],
nphot_scat=parameters["nb_photons_scat"],
nphot=parameters["nb_photons"],
rto_style=3,
tgas_eq_tdust=parameters["tgas_eq_tdust"],
modified_random_walk=1,
scattering_mode_max=parameters["scat_mode"],
setthreads=parameters["nbcores"],
)
# Add 90 degrees to position angle so that RADMC3D's definition of
# position angle be consistent with observed position
# angle, which is what we enter in the params.dat file
M = RTmodel(
distance=parameters["distance"],
Lambda=parameters["wavelength"] * 1e3,
label=parameters["label"],
line=parameters["gasspecies"],
iline=parameters["iline"],
vkms=parameters["vkms"],
widthkms=parameters["widthkms"],
npix=parameters["nbpixels"],
phi=parameters["phiangle"],
incl=parameters["inclination"],
posang=parameters["posangle"] + 90.0,
)
# Set dust / gas temperature if Tdust_eq_Thydro == 'Yes'
if (parameters["recalc_rawfits"] == "No"
and parameters["Tdust_eq_Thydro"] == "Yes"
and parameters["RTdust_or_gas"] == "dust"
and parameters["recalc_temperature"] == "Yes"):
print("--------- Writing temperature file (no mctherm) ----------")
os.system("rm -f dust_temperature.bdat") # avoid confusion!...
TEMPOUT = open("dust_temperature.dat", "w")
TEMPOUT.write("1 \n") # iformat
TEMPOUT.write(str(nrad * nsec * ncol) + " \n") # n cells
TEMPOUT.write(str(int(nbin)) + " \n") # nbin size bins
gas_temp = np.zeros((ncol, nrad, nsec))
thydro = (parameters["aspectratio"] * parameters["aspectratio"] *
density.cutemp *
density.rmed**(-1.0 + 2.0 * parameters["flaringindex"]))
for k in range(nsec):
for j in range(ncol):
gas_temp[j, :, k] = thydro
# write dust temperature for all size bins
for ibin in range(nbin):
print(
"writing temperature of dust species in bin",
ibin,
"out of ",
nbin - 1,
)
for k in range(nsec):
for j in range(ncol):
for i in range(nrad):
TEMPOUT.write(str(gas_temp[j, i, k]) + " \n")
TEMPOUT.close()
del gas_temp
# Now run RADMC3D
if parameters["recalc_rawfits"] == "No":
print("--------- Now executing RADMC3D ----------")
os.system("./script_radmc")
print("--------- exporting results in fits format ----------")
outfile = exportfits(M, parameters)
if parameters["plot_temperature"] == "Yes":
plot_temperature(nbin, nsec, ncol, nrad, density, parameters)
else:
print(
"------- I did not run RADMC3D, using existing .fits file for convolution "
)
print(
"------- (recalc_radmc = No in params.dat file) and final image ------ "
)
if parameters["RTdust_or_gas"] == "dust":
outfile = ("image_" + str(parameters["label"]) + "_lbda" +
str(parameters["wavelength"]) + "_i" +
str(parameters["inclination"]) + "_phi" +
str(parameters["phiangle"]) + "_PA" +
str(parameters["posangle"]))
else:
print(
"Set of initial conditions not implemented for pluto yet. Only parameters['RTdust_or_gas'] == 'dust'"
)
sys.exit("I must exit!")
if parameters["secondorder"] == "Yes":
outfile = outfile + "_so"
if parameters["dustdens_eq_gasdens"] == "Yes":
outfile = outfile + "_ddeqgd"
if parameters["bin_small_dust"] == "Yes":
outfile = outfile + "_bin0"
outfile = outfile + ".fits"
# =========================
# Convolve raw flux with beam and produce final image
# =========================
if parameters["recalc_fluxmap"] == "Yes":
print("--------- Convolving and writing final image ----------")
f = fits.open("./" + outfile)
# remove .fits extension
outfile = os.path.splitext(outfile)[0]
# add bmaj information
outfile = outfile + "_bmaj" + str(parameters["bmaj"])
outfile = outfile + ".fits"
hdr = f[0].header
# pixel size converted from degrees to arcseconds
cdelt = np.abs(hdr["CDELT1"] * 3600.0)
# get wavelength and convert it from microns to mm
lbda0 = hdr["LBDAMIC"] * 1e-3
# no polarized scattering: fits file directly contains raw intensity field
if parameters["polarized_scat"] == "No":
nx = hdr["NAXIS1"]
ny = hdr["NAXIS2"]
raw_intensity = f[0].data
if parameters["recalc_radmc"] == "No" and parameters[
"plot_tau"] == "No":
# sum over pixels
print("Total flux [Jy] = " + str(np.sum(raw_intensity)))
# check beam is correctly handled by inserting a source point at the
# origin of the raw intensity image
if parameters["check_beam"] == "Yes":
raw_intensity[:, :] = 0.0
raw_intensity[nx // 2 - 1, ny // 2 - 1] = 1.0
# Add white (Gaussian) noise to raw flux image to simulate effects of 'thermal' noise
if (parameters["add_noise"] == "Yes"
and parameters["RTdust_or_gas"] == "dust"
and parameters["plot_tau"] == "No"):
# beam area in pixel^2
beam = ((np.pi / (4.0 * np.log(2.0))) * parameters["bmaj"] *
parameters["bmin"] / (cdelt**2.0))
# noise standard deviation in Jy per pixel (I've checked the expression below works well)
noise_dev_std_Jy_per_pixel = parameters[
"noise_dev_std"] / np.sqrt(0.5 * beam) # 1D
# noise array
noise_array = np.random.normal(
0.0,
noise_dev_std_Jy_per_pixel,
size=parameters["nbpixels"] * parameters["nbpixels"],
)
noise_array = noise_array.reshape(parameters["nbpixels"],
parameters["nbpixels"])
raw_intensity += noise_array
if parameters["brightness_temp"] == "Yes":
# beware that all units are in cgs! We need to convert
# 'intensity' from Jy/pixel to cgs units!
# pixel size in each direction in cm
pixsize_x = cdelt * parameters["distance"] * au
pixsize_y = pixsize_x
# solid angle subtended by pixel size
pixsurf_ster = (pixsize_x * pixsize_y /
parameters["distance"] /
parameters["distance"] / pc / pc)
# convert intensity from Jy/pixel to erg/s/cm2/Hz/sr
intensity_buf = raw_intensity / 1e23 / pixsurf_ster
# beware that lbda0 is in mm right now, we need to have it in cm in the expression below
raw_intensity = (h * c / kB / (lbda0 * 1e-1)) / np.log(
1.0 +
2.0 * h * c / intensity_buf / pow((lbda0 * 1e-1), 3.0))
# raw_intensity = np.nan_to_num(raw_intensity)
else:
print(
"Set of initial conditions not implemented for pluto yet. Only parameters['polarized_scat'] == 'No'"
)
sys.exit("I must exit!")
# ------------
# smooth image
# ------------
# beam area in pixel^2
beam = ((np.pi / (4.0 * np.log(2.0))) * parameters["bmaj"] *
parameters["bmin"] / (cdelt**2.0))
# stdev lengths in pixel
stdev_x = (parameters["bmaj"] /
(2.0 * np.sqrt(2.0 * np.log(2.0)))) / cdelt
stdev_y = (parameters["bmin"] /
(2.0 * np.sqrt(2.0 * np.log(2.0)))) / cdelt
# a) case with no polarized scattering
if parameters["polarized_scat"] == "No" and parameters[
"plot_tau"] == "No":
# Call to Gauss_filter function
if parameters["moment_order"] != 1:
smooth = Gauss_filter(raw_intensity,
stdev_x,
stdev_y,
parameters["bpaangle"],
Plot=False)
else:
smooth = raw_intensity
# convert image from Jy/pixel to mJy/beam or microJy/beam
# could be refined...
if parameters["brightness_temp"] == "Yes":
convolved_intensity = smooth
else:
convolved_intensity = smooth * 1e3 * beam # mJy/beam
strflux = "Flux of continuum emission (mJy/beam)"
if parameters["gasspecies"] == "co":
strgas = r"$^{12}$CO"
elif parameters["gasspecies"] == "13co":
strgas = r"$^{13}$CO"
elif parameters["gasspecies"] == "c17o":
strgas = r"C$^{17}$O"
elif parameters["gasspecies"] == "c18o":
strgas = r"C$^{18}$O"
elif parameters["gasspecies"] == "hco+":
strgas = r"HCO+"
elif parameters["gasspecies"] == "so":
strgas = r"SO"
else:
strgas = parameters["gasspecies"]
if parameters["gasspecies"] != "so":
strgas += r" ($%d \rightarrow %d$)" % (
parameters["iline"],
parameters["iline"] - 1,
)
if parameters["gasspecies"] == "so" and parameters["iline"] == 14:
strgas += r" ($5_6 \rightarrow 4_5$)"
if parameters["brightness_temp"] == "Yes":
if parameters["RTdust_or_gas"] == "dust":
strflux = r"Brightness temperature (K)"
else:
if convolved_intensity.max() < 1.0:
convolved_intensity = smooth * 1e6 * beam # microJy/beam
strflux = r"Flux of continuum emission ($\mu$Jy/beam)"
if parameters["plot_tau"] == "Yes":
convolved_intensity = raw_intensity
strflux = r"Absorption optical depth $\tau"
# -------------------------------------
# SP: save convolved flux map solution to fits
# -------------------------------------
hdu = fits.PrimaryHDU()
hdu.header["BITPIX"] = -32
hdu.header["NAXIS"] = 2 # 2
hdu.header["NAXIS1"] = parameters["nbpixels"]
hdu.header["NAXIS2"] = parameters["nbpixels"]
hdu.header["EPOCH"] = 2000.0
hdu.header["EQUINOX"] = 2000.0
hdu.header["LONPOLE"] = 180.0
hdu.header["CTYPE1"] = "RA---SIN"
hdu.header["CTYPE2"] = "DEC--SIN"
hdu.header["CRVAL1"] = float(0.0)
hdu.header["CRVAL2"] = float(0.0)
hdu.header["CDELT1"] = hdr["CDELT1"]
hdu.header["CDELT2"] = hdr["CDELT2"]
hdu.header["LBDAMIC"] = hdr["LBDAMIC"]
hdu.header["CUNIT1"] = "deg "
hdu.header["CUNIT2"] = "deg "
hdu.header["CRPIX1"] = float((parameters["nbpixels"] + 1.0) / 2.0)
hdu.header["CRPIX2"] = float((parameters["nbpixels"] + 1.0) / 2.0)
if strflux == "Flux of continuum emission (mJy/beam)":
hdu.header["BUNIT"] = "milliJY/BEAM"
if strflux == r"Flux of continuum emission ($\mu$Jy/beam)":
hdu.header["BUNIT"] = "microJY/BEAM"
if strflux == "":
hdu.header["BUNIT"] = ""
hdu.header["BTYPE"] = "FLUX DENSITY"
hdu.header["BSCALE"] = 1
hdu.header["BZERO"] = 0
del hdu.header["EXTEND"]
# keep track of all parameters in params.dat file
# for i in range(len(lines_params)):
# hdu.header[var[i]] = par[i]
hdu.data = convolved_intensity
inbasename = os.path.basename("./" + outfile)
if parameters["add_noise"] == "Yes":
substr = "_wn" + str(parameters["noise_dev_std"]) + "_JyBeam.fits"
jybeamfileout = re.sub(".fits", substr, inbasename)
else:
jybeamfileout = re.sub(".fits", "_JyBeam.fits", inbasename)
hdu.writeto(jybeamfileout, overwrite=True)
plot_image(nx, cdelt, lbda0, strflux, convolved_intensity,
jybeamfileout, parameters)
print("--------- done! ----------")
def setUp(self):
self.particles1 = Particles(20, 1, (200, 2))
def particles(self):
if self._particles is None:
self._particles = Particles(self.CONST_G)
return self._particles
def __init__(self,
screen,
usealpha=True,
noparticles=False,
endless=False):
self.screen = screen
self.usealpha = usealpha
self.noparticles = noparticles
self.sharks = []
self.shark_sprites = pygame.sprite.Group()
self.player = Steamboat()
self.player_sprite = pygame.sprite.Group()
self.player_sprite.add(self.player)
self.health = Health()
self.health_sprite = pygame.sprite.Group()
self.health_sprite.add(self.health)
self.damage_count = 0
self.t = 0
self.water = Water.global_water #Water(self.usealpha)
#Water.global_water = self.water
self.water_sprite = pygame.sprite.Group()
self.water_sprite.add(self.water)
self.sky = util.load_image("taivas")
self.sky = pygame.transform.scale(self.sky,
(SCREEN_WIDTH, SCREEN_HEIGHT))
self.cannonballs = []
self.cannonball_sprites = pygame.sprite.Group()
self.pirates = []
self.pirate_sprites = pygame.sprite.Group()
self.titanic = None
self.titanic_sprite = pygame.sprite.Group()
self.seagulls = []
self.seagull_sprites = pygame.sprite.Group()
self.particles = Particles(self.usealpha)
self.particle_sprite = pygame.sprite.Group()
self.particle_sprite.add(self.particles)
self.mines = []
self.mine_sprites = pygame.sprite.Group()
self.score = Score()
self.score_sprite = pygame.sprite.Group()
self.score_sprite.add(self.score)
self.powerups = []
self.powerup_sprites = pygame.sprite.Group()
self.level = Level(endless)
self.lastshot = MIN_FIRE_DELAY + 1
self.gameover = False
self.gameover_image = None
self.gameover_rect = None
self.done = False
self.pause = False
font = util.load_font(
"Cosmetica",
40) #pygame.font.Font(pygame.font.get_default_font(), 36)
self.pause_image = font.render("Pause", True, (0, 0, 0))
self.pause_rect = self.pause_image.get_rect()
self.pause_rect.center = self.screen.get_rect().center
def five_particles_3d_random(self):
return Particles(num_particles=5,
num_dimensions=3,
mass=1,
diameter=0.1)
def single_point_particle_1d():
return Particles(num_particles=1, num_dimensions=1, mass=1, diameter=0)
cv.imshow(
'map',
draw_field(field=FIELD.copy(),
robot=robot,
particles=particles,
obstacles=obstacles))
user_input = cv.waitKey(1)
if start_localization:
cv.setMouseCallback(
'map', on_mouse=lambda event, x, y, flags, param: None)
# Create particles at the current robot pose
particles = Particles(row=robot.row,
column=robot.column,
angle=robot.angle,
map_rows=NUM_MAP_ROWS,
map_columns=NUM_MAP_COLUMNS)
rospy.loginfo('[SLAM] start localization')
t0 = time()
start_localization = False
pause_localization = False
started_once = True
elif not pause_localization:
localize()
elif pause_localization and started_once:
# Pause localization and update with "actions"
