Imagine you're creating a computer program that simulates the motion of a ball bouncing on the ground until it comes to a stop.

Here are the key details:

The simulation happens on a flat surface, with coordinates in three dimensions: x$,$ y$,$ and z$.$

You'll start the simulation by launching a ball with a certain speed, angle, and direction.

Parameters you'll use:

Starting Speed: How fast the ball is initially moving.

Starting Bearing: The angle at which the ball is launched from the horizontal.

Starting Trajectory: The angle at which the ball is launched from the vertical.

Bounce Percentage: How much energy is retained when the ball bounces.

Drag Rate: How much speed is lost when the ball is in contact with the ground.

Ground Threshold: The height at which the ball is considered to be on the ground.

Time Interval: The duration of each time step in the simulation.

The ball starts from a height of $2\mathrm{.}2$ meters.

You'll use vectors to represent the ball's direction and speed. A vector is like an arrow indicating both direction and magnitude.

At each time step, you'll calculate the ball's movement and update its position.

You'll also consider forces like gravity and drag from the ground to update the ball's velocity.

If the ball bounces, its velocity and position change accordingly.

The simulation ends when the ball hits the ground and stops moving much.

Your task is to code this simulation and plot the following:

Distance traveled over time.

Ball's path from side view $($x$-$position vs$.$ z$-$position$).$

Height over time.

Ball's path from top$-$down view $($x$-$position vs$.$ y$-$position$).$

$3$D plot showing the ball's path.

Velocity over time.

Trajectory over time.

You'll use specific parameters for the simulation: bounce percentage of $0\mathrm{.}7,$ drag rate of $0\mathrm{.}01,$ ground threshold of $0\mathrm{.}01,$ and time interval of $0\mathrm{.}001.$ Try different values for speed, bearing, and trajectory to see where the ball stops, aiming for an x$-$value close to $20$ meters. can you start with this code $=====$import matplotlib.pyplot as plt

import math

import astropy.coordinates

#Takes a $3$D vector, and returns a tuple of the x$,$ y$,$ and z components

def spherical$\_$to$\_$components$($magnitude$,$ bearing, trajectory$)$:

return astropy.coordinates.spherical$\_$to$\_$cartesian$($magnitude$,$ math.radians$($trajectory$),$ math.radians$($bearing$))$

#Takes the x$,$ y$,$ and z components of a $3$D vector, and returns a tuple of magnitude, bearing, and trajectory

def components$\_$to$\_$spherical$($x$,$ y$,$ z$)$:

magnitude, trajectory, bearing $=$ astropy.coordinates.cartesian$\_$to$\_$spherical$($x$,$ y$,$ z$)$

return magnitude, math.degrees$($bearing$.$to$\_$value$()),$ math.degrees$($trajectory$.$to$\_$value$())$

#Takes two $3$D vectors $($each specified by magnitude, bearing, and trajectory$)$ and returns a

#tuple representing the sum of the two vectors

def add$\_$spherical$\_$vectors$($magnitude$1,$ bearing$1,$ trajectory$1,$ magnitude$2,$ bearing$2,$ trajectory$2)$:

x$1,$ y$1,$ z$1=$ spherical$\_$to$\_$components$($magnitude$1,$ bearing$1,$ trajectory$1)$

x$2,$ y$2,$ z$2=$ spherical$\_$to$\_$components$($magnitude$2,$ bearing$2,$ trajectory$2)$

return components$\_$to$\_$spherical$($x$1+$ x$2,$ y$1+$ y$2,$ z$1+====$ and can you use the approach used in this code $==========$ import matplotlib.pyplot as plt

class SimpleDTSim:

def $\_\_$init$\_\_($self$)$:

# You might want to initialize the simulation here, but that means that you will initialize when the

# object is created, rather than on every simulation run

self.x $=0$

self.a $=0$

self.result $=[]$

def initialize$($self$,$ starting$\_$x$,$ a$)$:

self.x $=$ starting$\_$x

self.a $=$ a

self.result $=[$self$.$x$]$

def observe$($self$)$:

self.result.append$($self$.$x$)$

def update$($self$)$:

self.x $=$ self.a $*$ self.x

def runsim$($self$,$ x$,$ a$,$ steps$)$:

self.initialize$($x$,$ a$)$

for t in range$($steps$)$:

self.update$()$

self.observe$()$

plt$.$plot$($self$.$result$)$

plt$.$show$()$

if $\_\_$name$\_\_==\text{'}\_\_$main$\_\_\text{'}$:

sim $=$ SimpleDTSim$()$

sim.runsim$(1,1\mathrm{.}1,30)$ or the one attached on the screenshot like i want the code to have the same def functions like, $\_\_$init$\_\_,$ def initialize$($self$,$ def observe$($self$),$ def update$($self$),$ def runsim$($self$,$ if $\_\_$name$\_\_==\text{'}\_\_$main$\_\_\text{'}.$