Software Requirements Specification for Projectile

Samuel J. Crawford, Brooks MacLachlan, and W. Spencer Smith

This section records information for easy reference.

The unit system used throughout is SI (Système International d'Unités). In addition to the basic units, several derived units are also used. For each unit, Tab: ToU lists the symbol, a description and the SI name.

The symbols used in this document are summarized in Tab: ToS along with their units. Throughout the document, symbols in bold will represent vectors, and scalars otherwise. The symbols are listed in alphabetical order. For vector quantities, the units shown are for each component of the vector.

Projectile motion is a common problem in physics. Therefore, it is useful to have a program to solve and model these types of problems. The program documented here is called Projectile.

The following section provides an overview of the Software Requirements Specification (SRS) for Projectile. This section explains the purpose of this document, the scope of the system, the characteristics of the intended reader, and the organization of the document.

The scope of the requirements includes the analysis of a two-dimensional (2D) projectile motion problem with constant acceleration. Given the appropriate inputs, Projectile determines if the projectile hits the target.

This section first presents the problem description, which gives a high-level view of the problem to be solved. This is followed by the solution characteristics specification, which presents the assumptions, theories, and definitions that are used.

A system is needed to efficiently and correctly predict the landing position of a projectile.

This subsection provides a list of terms that are used in the subsequent sections and their meaning, with the purpose of reducing ambiguity and making it easier to correctly understand the requirements.

• Launcher: Where the projectile is launched from and the device that does the launching.
• Projectile: The object to be launched at the target.
• Target: Where the projectile should be launched to.
• Gravity: The force that attracts one physical body with mass to another.
• Cartesian coordinate system: A coordinate system that specifies each point uniquely in a plane by a set of numerical coordinates, which are the signed distances to the point from two fixed perpendicular oriented lines, measured in the same unit of length (from cartesianWiki).
• Rectilinear: Occuring in one dimension.

The physical system of Projectile, as shown in Fig:Launch, includes the following elements:

PS1: The launcher.

PS2: The projectile (with initial velocity vⁱ and launch angle θ).

PS3: The target.

Given the initial velocity vector of the projectile, the goal statements are:

The instance models that govern Projectile are presented in Section: Instance Models. The information to understand the meaning of the instance models and their derivation is also presented, so that the instance models can be verified.

This section simplifies the original problem and helps in developing the theoretical models by filling in the missing information for the physical system. The assumptions refine the scope by providing more detail.

This section focuses on the general equations and laws that Projectile is based on.

This section collects the laws and equations that will be used to build the instance models.

Assume we have rectilinear motion of a particle (of negligible size and shape, from A: pointMass); that is, motion in a straight line. The velocity is v and the acceleration is a. The motion in TM: acceleration is now one-dimensional with a constant acceleration, represented by a^c. The initial velocity (at t = 0, from A: timeStartZero) is represented by vⁱ. From TM: acceleration, using the above symbols we have:

Rearranging and integrating, we have:

Performing the integration, we have the required equation:

Assume we have rectilinear motion of a particle (of negligible size and shape, from A: pointMass); that is, motion in a straight line. The position is p and the velocity is v. The motion in TM: velocity is now one-dimensional. The initial position (at t = 0, from A: timeStartZero) is represented by pⁱ. From TM: velocity, using the above symbols we have:

Rearranging and integrating, we have:

From GD: rectVel we can replace v:

Performing the integration, we have the required equation:

\mathbf{v}=\begin{bmatrix} {{v_{x}}^{i}}+{{a_{x}}^{c}} t\\ {{v_{y}}^{i}}+{{a_{y}}^{c}} t \end{bmatrix} $$| |Description|v is the velocity (m/s)
v_xⁱ is the x-component of initial velocity (m/s)
a_x^c is the x-component of constant acceleration (m/s²)
t is the time (s)
v_yⁱ is the y-component of initial velocity (m/s)
a_y^c is the y-component of constant acceleration (m/s²)| |Source|--| |RefBy||

For a two-dimensional Cartesian coordinate system (A: twoDMotion and A: cartSyst), we can represent the velocity vector as $\mathbf{v}=\begin{bmatrix} {v_{x}}\\ {v_{y}} \end{bmatrix}$ and the acceleration vector as $\mathbf{a}=\begin{bmatrix} {a_{x}}\\ {a_{y}} \end{bmatrix}$ . The acceleration is assumed to be constant (A: constAccel) and the constant acceleration vector is represented as ${\mathbf{a}^{c}}=\begin{bmatrix} {{a_{x}}^{c}}\\ {{a_{y}}^{c}} \end{bmatrix}$ . The initial velocity (at t = 0, from A: timeStartZero) is represented by ${\mathbf{v}^{i}}=\begin{bmatrix} {{v_{x}}^{i}}\\ {{v_{y}}^{i}} \end{bmatrix}$ . Since we have a Cartesian coordinate system, GD: rectVel can be applied to each coordinate of the velocity vector to yield the required equation:

\mathbf{p}=\begin{bmatrix} {{p_{x}}^{i}}+{{v_{x}}^{i}} t+\frac{{{a_{x}}^{c}} t^{2}}{2}\\ {{p_{y}}^{i}}+{{v_{y}}^{i}} t+\frac{{{a_{y}}^{c}} t^{2}}{2} \end{bmatrix} $$| |Description|p is the position (m)
p_xⁱ is the x-component of initial position (m)
v_xⁱ is the x-component of initial velocity (m/s)
t is the time (s)
a_x^c is the x-component of constant acceleration (m/s²)
p_yⁱ is the y-component of initial position (m)
v_yⁱ is the y-component of initial velocity (m/s)
a_y^c is the y-component of constant acceleration (m/s²)| |Source|--| |RefBy|IM: calOfLandingTime and IM: calOfLandingDist|

For a two-dimensional Cartesian coordinate system (A: twoDMotion and A: cartSyst), we can represent the position vector as $\mathbf{p}=\begin{bmatrix} {p_{x}}\\ {p_{y}} \end{bmatrix}$ , the velocity vector as $\mathbf{v}=\begin{bmatrix} {v_{x}}\\ {v_{y}} \end{bmatrix}$ , and the acceleration vector as $\mathbf{a}=\begin{bmatrix} {a_{x}}\\ {a_{y}} \end{bmatrix}$ . The acceleration is assumed to be constant (A: constAccel) and the constant acceleration vector is represented as ${\mathbf{a}^{c}}=\begin{bmatrix} {{a_{x}}^{c}}\\ {{a_{y}}^{c}} \end{bmatrix}$ . The initial velocity (at t = 0, from A: timeStartZero) is represented by ${\mathbf{v}^{i}}=\begin{bmatrix} {{v_{x}}^{i}}\\ {{v_{y}}^{i}} \end{bmatrix}$ . Since we have a Cartesian coordinate system, GD: rectPos can be applied to each coordinate of the position vector to yield the required equation:

This section collects and defines all the data needed to build the instance models.

v=|\mathbf{v}| $$| |<b>Description</b>|<em>v</em> is the speed (m/s) <br> <em><b>v</b></em> is the velocity (m/s)| |<b>Notes</b>|For a given velocity vector $\mathbf{v}$, the magnitude of the vector ($|\mathbf{v}|$) is the scalar called speed.| |Source|--| |RefBy|DD: speedIY and DD: speedIX|

{{v_{x}}^{i}}={v^{i}} \cos\left(θ\right) $$| |Description|v_xⁱ is the x-component of initial velocity (m/s)
vⁱ is the initial speed (m/s)
θ is the launch angle (rad)</li>| |Notes|vⁱ is from DD: vecMag.
θ is shown in Fig:Launch.| |Source|--| |RefBy|IM: calOfLandingDist|

{{v_{y}}^{i}}={v^{i}} \sin\left(θ\right) $$| |Description|v_yⁱ is the y-component of initial velocity (m/s)
vⁱ is the initial speed (m/s)
θ is the launch angle (rad)| |Notes|vⁱ is from DD: vecMag.
θ is shown in Fig:Launch.| |Source|--| |RefBy|IM: calOfLandingTime|

This section transforms the problem defined in Section: Problem Description into one which is expressed in mathematical terms. It uses concrete symbols defined in Section: Data Definitions to replace the abstract symbols in the models identified in Section: Theoretical Models and Section: General Definitions.

{t{flight}}=\frac{2 {v{launch}} \sin\left(θ\right)}{g} $$| |<b>Description</b>|<em>t_flight</em> is the flight duration (s) <br> <em>v_launch</em> is the launch speed (m/s) <br> <em>θ</em> is the launch angle (rad) <br> <em>g</em> is the gravitational acceleration (m/s²)| |<b>Notes</b>|The constraint $0<θ<\frac{π}{2}$ is from <a href=#posXDirection>A: posXDirection</a> and <a href=#yAxisGravity>A: yAxisGravity</a>, and is shown in <a href=#Figure:Launch>Fig:Launch</a>. <br> <em>g</em> is defined in <a href=#Sec:AuxConstants>Section: Values of Auxiliary Constants</a>. <br> The constraint ${t_{flight}}>0$ is from A: timeStartZero.| |Source|--| |RefBy|IM: calOfLandingDist and FR: Calculate-Values|

We know that p_yⁱ = 0 (A: launchOrigin) and a_y^c = −g (A: accelYGravity). Substituting these values into the y-direction of GD: posVec gives us:

To find the time that the projectile lands, we want to find the t value (t_flight) where p_y = 0 (since the target is on the x-axis from A: targetXAxis). From the equation above we get:

Dividing by t_flight (with the constraint t_flight > 0) gives us:

Solving for t_flight gives us:

From DD: speedIY (with vⁱ = v_launch) we can replace v_yⁱ:

{p{land}}=\frac{2 {v{launch}}^{2} \sin\left(θ\right) \cos\left(θ\right)}{g} $$| |<b>Description</b>|<em>p_land</em> is the landing position (m) </br> <em>v_launch</em> is the launch speed (m/s) <br> <em>θ</em> is the launch angle (rad) <br> <em>g</em> is the gravitational acceleration (m/s²)| |<b>Notes</b>|The constraint $0<θ<\frac{π}{2}$ is from <a href=#posXDirection>A: posXDirection</a> and <a href=#yAxisGravity>A: yAxisGravity</a>, and is shown in <a href=#Figure:Launch>Fig:Launch</a>. <br> <em>g</em> is defined in <a href=#Sec:AuxConstants>Section: Values of Auxiliary Constants</a>. <br> The constraint ${p_{land}}>0$ is from A: posXDirection.| |Source|--| |RefBy|IM: offsetIM and FR: Calculate-Values|

We know that p_xⁱ = 0 (A: launchOrigin) and a_x^c = 0 (A: accelXZero). Substituting these values into the x-direction of GD: posVec gives us:

To find the landing position, we want to find the p_x value (p_land) at flight duration (from IM: calOfLandingTime):

From DD: speedIX (with vⁱ = v_launch) we can replace v_xⁱ:

Rearranging this gives us the required equation:

{d{offset}}={p{land}}-{p_{target}} $$| |Description|d_offset is the distance between the target position and the landing position (m)
p_land is the landing position (m)
p_target is the target position (m)| |Notes|p_land is from IM: calOfLandingDist.
The constraints p_land > 0 and p_target > 0 are from A: posXDirection.| |Source|--| |RefBy|FR: Output-Values, IM: messageIM, and FR: Calculate-Values|

s=\begin{cases} \text{"The target was hit."}, & |\frac{{d_{offset}}}{{p_{target}}}|<ε\\ \text{"The projectile fell short."}, & {d_{offset}}<0\\ \text{"The projectile went long."}, & {d_{offset}}>0 \end{cases} $$| |Description|s is the output message as a string (Unitless)
d_offset is the distance between the target position and the landing position (m)
p_target is the target position (m)
ε is the hit tolerance (Unitless)| |Notes|d_offset is from IM: offsetIM.
The constraint p_target > 0 is from A: posXDirection.
The constraint d_offset > −p_land is from the fact that p_land > 0, from A: posXDirection.
ε is defined in Section: Values of Auxiliary Constants.| |Source|--| |RefBy|FR: Output-Values and FR: Calculate-Values|

Table:InDataConstraints shows the data constraints on the input variables. The column for physical constraints gives the physical limitations on the range of values that can be taken by the variable. The uncertainty column provides an estimate of the confidence with which the physical quantities can be measured. This information would be part of the input if one were performing an uncertainty quantification exercise. The constraints are conservative, to give the user of the model the flexibility to experiment with unusual situations. The column of typical values is intended to provide a feel for a common scenario.

Table:OutDataConstraints shows the data constraints on the output variables. The column for physical constraints gives the physical limitations on the range of values that can be taken by the variable.

This section provides the functional requirements, the tasks and behaviours that the software is expected to complete, and the non-functional requirements, the qualities that the software is expected to exhibit.

This section provides the functional requirements, the tasks and behaviours that the software is expected to complete.

This section provides the non-functional requirements, the qualities that the software is expected to exhibit.

The purpose of the traceability matrices is to provide easy references on what has to be additionally modified if a certain component is changed. Every time a component is changed, the items in the column of that component that are marked with an "X" should be modified as well. Table:TraceMatAvsAll shows the dependencies of data definitions, theoretical models, general definitions, instance models, requirements, likely changes, and unlikely changes on the assumptions. Table:TraceMatRefvsRef shows the dependencies of data definitions, theoretical models, general definitions, and instance models with each other. Table:TraceMatAllvsR shows the dependencies of requirements, goal statements on the data definitions, theoretical models, general definitions, and instance models.

This section contains the standard values that are used for calculations in Projectile.