Undergraduate Projects, 2018-19

AJHS-UG-1

Feedback Learning-Based Rocket Course Correction

This project aims to build a feedback learning-based controller for stabilising a rocket launcher during launch and possibly also during landing (in the style of SpaceX). The idea is that the controller has to keep the rocket vertical (or at some predetermined attitude), despite unpredictable forces that may cause the rocket to topple.

The problem may be described as follows. We assume that the rocket has a gimballing engine that may pivot to provide horizontal moments to correct its attitude during launch (and landing), but we do not know precisely what moments may be achieved and have to learn from experience. The moments may vary, according to the size and power of the engine. They will also change as the centre of mass of the rocket launcher moves, due to the expulsion of reaction mass and the pooling of fuel in the bottom of the stage. Finally, the environmental conditions may offer unpredictable cross-winds to overcome.

The project will build a real-world physics simulator for rocket launchers of different sizes, masses and thrusts. It will then develop an agnostic controller for missions that include launches and landings, that attempts to keep each of these rockets stable, given only local knowledge about the rocket's attitude (such as could be gained from an internal guidance system). The controller will use some kind of learning algorithm to continually update how it makes course corrections, as the conditions change. Software may be developed in any suitable programming language; by default in Java.

AJHS-UG-2

Total Recovery of all Rocket Stages

This project aims to complete a realistic study of the various methods for recovering all stages of a multi-stage rocket launcher. The company SpaceX has made history by being the first company to recover and reuse the first booster stage of their Falcon 9 rocket; however the second stage, which reaches far higher orbital velocities, cannot be so easily recovered and is currently destroyed during re-entry in the upper atmosphere after being de-orbited.

How could all stages be safely de-orbited, recovered and reused? Technologies to investigate include supersonic retro-propulsion, heat shielding technologies, or various aerobraking possibilities such as a ballute-style balloon. You will need to build a realistic physics simulator to model the forces and heating loads on a rocket during launch and landing and consider various trade-offs between the strategies for de-orbiting each rocket stage. Supersonic retro-propulsion requires extra fuel in the stage reserved for landing. Heat shielding adds extra weight to the stage and the profile of the stage may have to be redesigned. Aerobraking needs to be resilient at different speeds and altitudes, as the density of the atmosphere changes.

This project would suit a student with an interest in space physics and could be completed in a programming environment with strong engineering mathematics support, such as MatLab. The conclusion of the project should state whether it is possible to recover all stages and which methods are most suitable.

AJHS-UG-4

Modular Testing by Combination of Testable State Machines

This project aims to explore the notion of state machine combination and how this might be used as the basis for a modular testing method. There exist powerful testing methods based on extended finite state machines (EFSMs). Individual software units can be specified as a kind of EFSM, which allows the automatic generation of exhaustive tests that cover all states and transitions. However, what if software is specified in a modular way, as several EFSMs?

An example might be a single sign-in service, which has a login process with two states (logged-out, logged-in). This can be tested in isolation; but then it is combined with another software service, such as a shopping cart, which has its own EFSM. Conceptually, the EFSM of the shopping cart needs to be embedded in the logged-in state of the login service. This is now a hierarchical EFSM (with a substate machine), for which the expansion to a flat state machine is known. Other ways of combining EFSMs may include parallel composition, which also has a known expansion.

The project will answer the question: what is the new testing obligation, when two or more EFSMs are combined in this way? The brute-force approach (and benchmark) would be to perform the expansion, and then generate tests for the flattened EFSM. But there may be smarter ways of determining what additional tests are needed, when combining two EFSMs. If existing test-suites exist for the EFSMs in isolation, what additional tests need to be generated when combining them? This project will use Java as the implementation language.

AJHS-UG-5

JSON-to-Java Marshalling for Java Abstract Syntax Trees

This project aims to provide a JSON marshalling package for Java Abstract Syntax Trees (JAST), an ongoing Sheffield research project for handling document-oriented databases in Java. Currently, JAST has a package for marshalling, unmarshalling and binding XML-to-Java. This project will provide the equivalent package for JSON (Java Script Object Notation), which is a more compact textual format than XML.

Marshalling is the process of mapping an arbitrarily-complex Java object in memory to a suitably-encoded data file; and unmarshalling is the reverse process of reconstructing the same Java object in memory from file. The project stages will include writing a parser for JSON, and creating a Factory that can reconstruct Java objects in memory, given the parse- tree; and writing a serialising engine that can convert the Java object in memory to correct JSON syntax. Some novel research is needed to handle reconstruction of generic types. All software will be developed in Java.

See: http://staffwww.dcs.shef.ac.uk/people/A.Simons/jast/

AJHS-UG-7a, 7b, 7c

Ferromone Trails for Self-Organising Trains

This project aims to build a simulation of part of the UK national rail network and explore whether it may be possible to increase capacity by allowing trains to self-organise at what speeds they travel. Currently, the UK uses the Victorian-era fixed-block signalling system, which allows trains to enter fixed lengths of track, controlled by signals, and prohibits the following train to enter, until the previous train has cleared the block. In the same way that ant insect-colonies self-organise by depositing pheromone trails, this project hypothesizes that trains will read and deposit electronic signals to trackside RFID devices, known as balises, such that following trains may safely predict the location of the previous train, obviating the need for fixed-blocks and allowing the line-occupancy to increase.

This project will involve building a Java model of the railway track, including junctions and crossovers, populating the track with balises (spaced at ideal distances to be determined) and will simulate the operation of train services that stop at particular stations. The project will answer questions relating to how many trains can be released, at what frequency of departure, without trains accidentally colliding with trains in front? How is this affected by trains joining the line at a junction, or crossing over the line? How do trains get advance warning of other trains at junctions or crossovers? By default, the implementation language will be Java.

Resources: https://wiki.openraildata.com/index.php/Main_Page