Pipelay vessel design optimisation using genetic algorithms
Pipelay procedure
Subsea oil and gas pipelines are usually installed to the seabed by pipelay vessel. S-lay is one of the pipes most common installation methods which is characterised by “S” curve during laying to the seabed. Before laying to the seabed, the pipes are stored and assembled on the vessel. The pipe leaves the vessel at the stern part through a sloping ramp, (Fig.1). The stinger is located at the end of the ramp. It is used to support the pipeline, to control the curvature, and to prevent massive deflections in the overbend region. With the chosen angle, segments of the stinger can be set to determine its shape. Stinger length depends on water depth and submerged weight of the pipes. Sufficient length of the stinger is required to avoid excessive bending that may cause the pipelines to buckle. Tensioners are located on the ramp; it has the function to hold the suspended length of the pipeline, [1].
The upper curved part of the pipeline is known as the overbend. The pipeline will lose contacts with the stinger at a chosen angle and goes downward straightly and then gradually bends in the opposite direction known as the sagbend area (hence, the “S” curve). From the sagbend area, the suspended pipe continues to reach the seabed at the touchdown point. The detail of the S-lay configuration is shown in Fig. 2. In the sagbend area , the combination of bending and pressure loads must safely be sustained, [1].
The tension applied at the top is used to control the curvature in the sagbend region. Excessive bending, local buckling and collapse could happen if the tension in the top is lost due to sudden movements of the ship or any others reasons. The main function of the lay vessel is to provide tension to hold the suspended line pipes and to control its shape. The behaviour of the long suspended pipeline is more like a cable rather than a beam (so-called catenary curve), [1].
Usually, engineers try to minimise the top tension to reduce operational costs while preserving tensioners’ ability to hold the pipe during installation in rough seas.
In this paper, I propose using genetic algorithm for the vessel laying profile design optimisation for successfully conducting subsea pipeline installation procedure. Basically, it is a problem of continuous function optimisation with some constraints, for which genetic algorithms are nicely suited. Formally, I aim to minimise top tension of tensioners with the constraints that sagbend tension is no greater than 60% of pipe’s Yield Strength (SMYS) and overbend tension is no greater that 90% of SMYS. The function to be minimised is that of analytical (in contrast to numerical, usually done by specialised software) static pipelay analysis with the following assumptions: the lift-off point is assumed to occur at the second from the last roller at the bottom of the stinger. This is where the catenary curve is deemed to join. In fact, it is recognised that the true point of contra-flexion is beyond the end of the stinger; All current and wave forces on the pipeline and barge are ignored; Water absorption is taken as zero because of the short time that the pipe is immersed prior to touchdown; The end cap pressure can thus be taken as acting over the outer diameter of the concrete. For the optimisation function derivation, one should contemplate simple considerations of the geometry of the barge, the pipe’s friction on the stinger and catenary equation, that can be found, for example, in [1], and is beyond the scope of this paper. Alternatively, more complex optimisation function can be used including that of provided by commercial software for static and dynamic analysis of pipelay. In this article, however, I wanted to keep things simple.
Genetic Algorithms
According to Wikipedia, in computer science and operations research, a genetic algorithm (GA) is a metaheuristic inspired by the process of natural selection that belongs to the larger class of evolutionary algorithms (EA). Genetic algorithms are commonly used to generate high-quality solutions to optimisation and search problems by relying on biologically inspired operators such as mutation, crossover and selection. In a genetic algorithm, a population of candidate solutions (called individuals, creatures, or phenotypes) to an optimisation problem is evolved toward better solutions. Each candidate solution has a set of properties (its chromosomes or genotype) which can be mutated and altered; traditionally, solutions are represented in binary as strings of 0s and 1s, but other encodings are also possible (with e.g., continuous variables like in this paper). The evolution usually starts from a population of randomly generated individuals, and is an iterative process, with the population in each iteration called a generation. In each generation, the fitness of every individual in the population is evaluated; the fitness is usually the value of the objective function in the optimisation problem being solved. The more fit individuals are stochastically selected from the current population, and each individual’s genome is modified (recombined and possibly randomly mutated) to form a new generation. The new generation of candidate solutions is then used in the next iteration of the algorithm. Commonly, the algorithm terminates when either a maximum number of generations has been produced, or a satisfactory fitness level has been reached for the population.
A good introductory book for GAs, extensively used in this article, is [2]. It uses python as a primary programming language and DEAP framework for implementing genetic algorithms. DEAP is a novel evolutionary computation framework for rapid prototyping and testing of ideas. It seeks to make algorithms explicit and data structures transparent. It works in perfect harmony with parallelisation mechanism such as multiprocessing and SCOOP, [3].
Input data
Tuning the Lay-barge data using genetic algorithms
The following steps describe the main parts of GA program:
1. We start by setting the lower and upper boundary for each of the float values representing a Lay-barge data:
BOUNDS_LOW = [0, 80, 100, 5, 5, 3, 2, 100, 40]
BOUNDS_HIGH = [5, 150, 250, 15, 20, 20, 10, 250, 80]2. Since our goal is to minimise the top tension of tensioners, we define a single objective, minimisation fitness strategy:
creator.create(“FitnessMin”, base.Fitness, weights=(-1.0,))3. Now comes a particularly interesting part: since the solution is represented by a list of float values, each of a different range, we use the following loop to iterate over all pairs of lower-bound, upper-bound values. For each entry in Lay-barge data (table 4), we create a separate toolbox operator, which will be used to generate random float values in the appropriate range:
for i in range(NUM_OF_PARAMS):
toolbox.register(“hyperparameter_” + str(i), random.uniform, BOUNDS_LOW[i],BOUNDS_HIGH[i])4. Then, we create the parameter tuple, which contains the separate float number generators we just created for each parameter:
for i in range(NUM_OF_PARAMS):
hyperparameters = hyperparameters (toolbox.__getattribute__(“hyperparameter_” + str(i)),)5. Now, we can use this parameter tuple, in conjunction with DEAP’s built-in initCycle() operator, to create a new individualCreator operator that fills up an individual instance with a combination of randomly generated parameter values:
toolbox.register(“individualCreator”, tools.initCycle,
creator.Individual, hyperparameters, n=1)6. Then, we instruct the genetic algorithm to use the pipelayStatic() method instance for fitness evaluation:
def piplayStatic(individual):
# Pipe data
…….
# Environmental data
……. # Pipe Launch Rollers
……
# Lay-Barge Input Data
thetaPT = individual[0]
LFL = individual[1]
RB = individual[2]
ELPT = individual[3]
LPT = individual[4]
ELWL = individual[5]
LMP = individual[6]
RS = individual[7]
CL = individual[8]
Ttens_tonnef, TTS_ratio, TopS_ratio = static_pipe_lay(ODs, ts, Es, SMYS, rho_s, tFBE, rhoFBE, tconc, rho_conc, d, rho_sea, mu_roller, thetaPT, LFL, RB, ELPT, LPT, ELWL, LMP, RS, CL) if numpy.isnan(Ttens_tonnef):
Ttens_tonnef = 100
if TTS_ratio > 0.6 or TTS_ratio < 0.3 or TopS_ratio > 0.9:
return Ttens_tonnef*PENALTY_VALUE,
return Ttens_tonnef,toolbox.register(“evaluate”, piplayStatic)
Here, we use static_pipe_lay() as function for our “black-box” static pipeline installation analysis. We also apply PENALTY_VALUE = 10 if our constraints are violated.
7. Now, we need to define the genetic operators. While, for the selection operator, we use the usual tournament selection with a tournament size of 2, we choose crossover and mutation operators that are specialised for bounded float-list chromosomes and provide them with the boundaries we defined for each parameter:
toolbox.register(“select”, tools.selTournament, tournsize=2)
toolbox.register(“mate”,
tools.cxSimulatedBinaryBounded,
low=BOUNDS_LOW,
up=BOUNDS_HIGH,
eta=CROWDING_FACTOR)toolbox.register(“mutate”,
tools.mutPolynomialBounded,
low=BOUNDS_LOW,
up=BOUNDS_HIGH,
eta=CROWDING_FACTOR,
indpb=1.0 / NUM_OF_PARAMS)
8. In addition, we use the elitist approach, where the HOF (hall-of-fame) members — the current best individuals — are always passed untouched to the next generation:
hof = tools.HallOfFame(HALL_OF_FAME_SIZE)population, logbook = elitism.eaSimpleWithElitism(population,
toolbox,
cxpb=P_CROSSOVER,
mutpb=P_MUTATION,
ngen=MAX_GENERATIONS,
stats=stats,
halloffame=hof,
verbose=True)
Results
By running the algorithm for 50 generations with a population size of 250, we get the following outcome:
gen nevals min avg
0 250 27.0973 371.661
1 232 25.8277 290.744
2 225 25.8277 225.889
3 236 24.8788 181.067
4 233 24.8788 160.216
5 231 24.8788 166.897
…….
47 224 23.8077 74.2515
48 232 23.8008 73.5593
49 235 23.8008 82.8774
50 234 23.8008 84.3727
— Best Individual = [0.0412993085185044, 81.01473661569246, 184.95018480338263, 9.293609161332556, 14.465039211270776, 9.235358866413463, 7.998131384548541, 116.590780891431, 62.13405099204592]
— Best Fitness = 23.800805434444403
Double check:
Ttens_tonnef: 23.800805434444403
TTS_ratio: 0.5998947240981475 < 0.6
TopS_ratio: 0.8462065818374703 < 0.9
Fig.4 depicting the min (in red) and average (in green) fitness over the generations, indicates that the best solution was approach in less than 5 generations and then only gradually decreased.
The full code for the article can be found in [4]. Please, also visit Gigala page to support my project and leave some comments, [5].
To keep up with the project please visit https://gigala.io/
[1] Comparisons Study of S-Lay and J-Lay Methods for Pipeline Installation in Ultra Deep Water. Master’s thesis by Jihan Herdiyanti
[2] Hands-On Genetic Algorithms with Python: Applying genetic algorithms to solve real-world deep learning and artificial intelligence problems. Wirsansky, Eyal.
[3] https://deap.readthedocs.io/en/master/
