def generate_random_point_on_line(OA_,OB_,ud01_) :
r = ud01_()
x = r * (OB_.x-OA_.x) + OA_.x
y = r * (OB_.y-OA_.y) + OA_.y
return vector_2d(x,y)
def generate_point_on_circle_perimeter(self, ud01_):
r_theta = ud01_()
r_theta = r_theta * 2 * math.pi
x_ = self.circle.get_radius() * math.cos(r_theta)
y_ = self.circle.get_radius() * math.sin(r_theta)
return (vector_2d(x_, y_))
def generate_point_on_disk_surface(self,ud01_) :
r = ud01_()
r = self.circle.get_radius() * math.sqrt(r)
r_theta = ud01_()
r_theta = r_theta * 2 * math.pi
x_ = r * math.cos(r_theta)
y_ = r * math.sin(r_theta)
return ( vector_2d(x_,y_) )
def generate_random_point_on_plane(x_min_,x_max_,y_min_,y_max_,ud01_) :
test_value_max_above_min(x_max_, x_min_)
test_value_max_above_min(y_max_, y_min_)
x = ud01_()
x = x * (x_max_ - x_min_) + x_min_
y = ud01_()
y = y * (y_max_ - y_min_) + y_min_
return vector_2d(x,y)
def calculate_impact_point(x0_, z0_, v0_, alpha0_, g_):
t_impact = (v0_ * math.sin(alpha0_) /
g_) * (1 + math.sqrt(1 + (2 * g_ * z0_) /
(v0_**2 * math.sin(alpha0_)**2)))
x_impact = v0_ * math.cos(alpha0_) * t_impact + x0_
angle_impact = math.asin((((g_ * t_impact) / 2 * v0_) -
(z0_ / (v0_ * t_impact))) % 2 - 1)
vx_impact = v0_ * math.cos(angle_impact)
vz_impact = -g_ * t_impact + v0_ * math.sin(angle_impact)
v_impact = vector_2d(vx_impact, vz_impact)
return (x_impact, t_impact, angle_impact, v_impact)
def __init__(self,rectangle_) :
self.rectangle = rectangle_
weight_tot = self.rectangle.get_perimeter()
weight1 = self.rectangle.get_a() / weight_tot
weight2 = ( self.rectangle.get_a() + self.rectangle.get_b() ) / weight_tot
weight3 = ( 2 * self.rectangle.get_a() + self.rectangle.get_b() ) / weight_tot
OA = vector_2d(-self.rectangle.get_a()/2,self.rectangle.get_b()/2)
OB = vector_2d(self.rectangle.get_a()/2,self.rectangle.get_b()/2)
OC = vector_2d(self.rectangle.get_a()/2,-self.rectangle.get_b()/2)
OD = vector_2d(-self.rectangle.get_a()/2,-self.rectangle.get_b()/2)
AB = segment_2d(OA,OB)
BC = segment_2d(OB,OC)
CD = segment_2d(OC,OD)
DA = segment_2d(OD,OA)
self.points = []
self.points.append(OA)
self.points.append(OB)
self.points.append(OC)
self.points.append(OD)
self.weights = []
self.weights.append(weight1)
self.weights.append(weight2)
self.weights.append(weight3)
self.weights.append(1)
self.generators = []
self.generators.append(segment_2d_uniform_generator(AB))
self.generators.append(segment_2d_uniform_generator(BC))
self.generators.append(segment_2d_uniform_generator(CD))
self.generators.append(segment_2d_uniform_generator(DA))
return
def ballistics_stepper_sim(self):
t_sim = 0
t = self.duration_sim
sim_file = open("sim_file.data", "w")
OM = vector_2d(self.x0, self.z0)
sim_file.write("{} {}\n".format(OM.get_x(), OM.get_y()))
x = self.x0
z = self.z0
vx = self.vx0
vz = self.vz0
while (t_sim < t):
x = OM.get_x()
z = OM.get_y()
if (self.is_in_wind(t_sim, self.environment) == True):
vx = vx * math.exp(-(self.friction_val / self.mass))
# Otherwise, vx is constant in a frictionless world
vz = vz - (self.g * self.step_sim)
x = x + vx * self.step_sim
z = z + vz * self.step_sim
OM.set_x(x)
OM.set_y(z)
sim_file.write("{} {}\n".format(OM.get_x(), OM.get_y()))
t_sim = t_sim + self.step_sim
impact_site = (OM.get_x(), OM.get_y())
sim_file.close()
return impact_site
def generate_random_point_on_segment(self, ud01):
r = ud01()
vector = self.segment.get_vector() * r
new_finish = self.segment.get_start() + vector
point = segment_2d(self.segment.get_start(), new_finish)
return point
if __name__ == "__main__":
seed = 314159262
kl_gen1 = kl_generator(seed)
OA = vector_2d(1.0, 2.0)
OB = vector_2d(4.785, 8.0)
AB = segment_2d(OA, OB)
nb_vectors = 1000
segment_gen = segment_2d_uniform_generator(AB)
rng_file = open("random_segments_data.csv", "w")
for i in range(nb_vectors):
OM = segment_gen.generate_random_point_on_segment(kl_gen1)
# We transform the segment into a vector to plot in into Gnuplot
OM = OM.get_start() + OM.get_vector()
rng_file.write("{} {}\n".format(OM.get_x(), OM.get_y()))
def shoot(self, ud01_):
rx = ud01_()
ry = ud01_()
x = self.sq.get_side_length() * (-0.5 + rx)
y = self.sq.get_side_length() * (-0.5 + ry)
return vector_2d(x, y)
point.set_x(point_x)
point.set_y(point_y)
point = point + self.translation
return point
if __name__ == "__main__":
rectangle1 = rectangle(4.0, 10.0)
gen1 = rectangle_perimeter_generator(rectangle1)
seed = 31415926
kl_gen = kl_generator(seed)
OA = vector_2d(10.0, -5.0)
theta = 1
wr = position_2d_wrapper_generator(gen1, OA, theta)
nb_rectangles = 1000
#sys.stdout.write("aaaaaaaaa = {}\n".format(OA_translated))
rng_file = open("prng_translation.data", "w")
for i in range(nb_rectangles):
wr = position_2d_wrapper_generator(gen1, OA, theta)
OA_translated = wr(kl_gen)
# We transform the segment into a vector to plot in into Gnuplot
rng_file.write("{} {}\n".format(OA_translated.get_x(),
OA_translated.get_y()))
def get_vector(self):
x = self.finish.get_x() - self.start.get_x()
y = self.finish.get_y() - self.start.get_y()
return vector_2d(x, y)
def __init__(self, start_=vector_2d(0.0, 0.0), finish_=vector_2d(0.0,
0.0)):
self.start = start_
self.finish = finish_
return
def get_vector(self):
x = self.finish.get_x() - self.start.get_x()
y = self.finish.get_y() - self.start.get_y()
return vector_2d(x, y)
def get_length(self):
_vector = self.get_vector()
return _vector.mag()
def inside(self, point_, error_, error_mag_):
return collision_detection_on_segment(point_, self.start, self.finish)
if __name__ == "__main__":
OA = vector_2d(2.0, 4.0)
OB = vector_2d(4.0, 8.0)
OL = vector_2d(2.2, 4.4)
OM = vector_2d(12.0, 24.0)
ON = vector_2d(2.0, 6.0)
OP = vector_2d(2.0, 4.05)
error = 0.1
error_mag = 0.1
AB = segment_2d(OA, OB)
sys.stdout.write("Length = {}\n".format(AB.get_length()))
AB_vector = AB.get_vector()
sys.stdout.write("Vector = {}\n".format(AB_vector))
is_inside = AB.inside(OL, error, error_mag)
sys.stdout.write("OL is inside? = {}\n".format(is_inside))
def __call__(self, ud01_) :
r_vector = self.generate_point_on_disk_surface(ud01_)
return r_vector
if __name__ == "__main__" :
seed = 314159262
kl_gen1 = kl_generator(seed)
r = 5.0
start_theta = 0.0
cir1 = circle(r,start_theta)
cir1_gen = disk_surface_generator(cir1)
rng_file = open("prng_circle.data","w")
nb_circles = 1000
OM = vector_2d(1.8,-3.7) # Translation
for i in range(nb_circles) :
wr = translation_2d_wrapper_generator(cir1_gen,OM)
OM_translated = wr(kl_gen1)
# We transform the segment into a vector to plot in into Gnuplot
rng_file.write("{} {}\n".format(OM_translated.get_x(),OM_translated.get_y()))
rng_file.close()
sys.exit(0)
