GMSimViz is an automation tool that produces an animated 3D visualization of geological faults, ground motion and other earthquake related data. Typically ground motion simulations are computed by a High Performance Computing (HPC) facility, and its verification involves various data visualization methods. A 3D animation of the ground motion is an excellent media to understand the nature of an earthquake, and to communicate with the general public. However, its production has been largely left to time-consuming manual interaction with a 3D visualization software package, such as Paraview as no existing solution provides a fully-automated workflow.

This paper presents the computational components and results of the May 2018 version (v18.5) of probabilistic seismic hazard analysis (PSHA) in New Zealand based on physics-based ground motion simulations (`Cybershake NZ'). A total of 11,362 finite fault simulations are undertaken and seismic hazard results are computed on a spatiallyvariable grid of 27,481 stationswith distributed seismicity sources considered via conventional empirical ground motion models. In the current work completed to datethe Graves and Pitarka ( 20102015) hybrid broadband ground motion simulation approach is utilized considering a transition frequency of 0.25 Hza detailed crustal model with a grid spacing of 0.4 kmand an empirically-calibrated local site response model. A Monte Carlo scheme is used to sample variability in the seismic source parametrization (by varying the hypocenter location and slip distribution per each hypocenter realization)with the total number of ruptures for each fault being a function of the rupture magnitude. The generated uniform hazard maps across the country are presented. Treatment of uncertainty in the context of simulation-based PSHA and improvements for future versions of the ongoing effort are discussed.

Ground Motion (GM) Simulation involves complex calculations that produce a large collection of numerical data, which needs a good visual presentation to help better understanding of the complex dynamics of the earthquake. In this poster, we present a visualisation workflow that we developed to produce a 3D animation from the simulation data of the 2016 M7.8 Kaikoura earthquake as a case study, and discuss how it facilitated scientific discovery and communication.

We present efficient sequential and parallel algorithms for the maximum sum (MS) problem, which is to maximize the sum of some shape in the data array. We deal with two MS problems; the maximum subarray (MSA) problem and the maximum convex sum (MCS) problem. In the MSA problem, we find a rectangular part within the given data array that maximizes the sum in it. The MCS problem is to find a convex shape rather than a rectangular shape that maximizes the sum. Thus, MCS is a generalization of MSA. For the MSA problem, O ( n ) time parallel algorithms are already known on an ( n , n ) 2D array of processors. We improve the communication steps from 2 n − 1 to n, which is optimal. For the MCS problem, we achieve the asymptotic time bound of O ( n ) on an ( n , n ) 2D array of processors. We provide rigorous proofs for the correctness of our parallel algorithm based on Hoare logic and also provide some experimental results of our algorithm that are gathered from the Blue Gene/P super computer. Furthermore, we briefly describe how to compute the actual shape of the maximum convex sum.

This paper discusses simulated ground motion intensity, and its underlying modelling assumptions, for great earthquakes on the Alpine Fault. The simulations utilise the latest understanding of wave propagation physics, kinematic earthquake rupture descriptions and the three-dimensional nature of the Earth's crust in the South Island of New Zealand. The effect of hypocentre location is explicitly examined, which is found to lead to significant differences in ground motion intensities (quantified in the form of peak ground velocity, PGV) over the northern half and southwest of the South Island. Comparison with previously adopted empirical ground motion models also illustrates that the simulations, which explicitly model rupture directivity and basin-generated surface waves, lead to notably larger PGV amplitudes than the empirical predictions in the northern half of the South Island and Canterbury. The simulations performed in this paper have been adopted, as one possible ground motion prediction, in the Project AF8' Civil Defence Emergency Management exercise scenario. The similarity of the modelled ground motion features with those observed in recent worldwide earthquakes as well as similar simulations in other regions, and the notably higher simulated amplitudes than those from empirical predictions, may warrant a re-examination of regional impact assessments for major Alpine Fault earthquakes.

We break the long standing cubic time bound of $$O(n^3)$$ for the Minimum Weight Polygon Triangulation problem by showing that the well known dynamic programming algorithm, reported independently by Gilbert and Klincsek, can be optimized with a faster algorithm for the $$(min,+)$$ -product using look-up tables. In doing so, we also show that the well known Floyd-Warshall algorithm can be optimized in a similar manner to achieve a sub-cubic time bound for the All Pairs Shortest Paths problem without having to resort to recursion in the semi-ring theory.

Matrix multiplication is a fundamental mathematical operation that has numerous applications across most scientific fields. Cannon's distributed algorithm to multiply two n-by-n matrices on a two dimensional square mesh array with n2 cells takes exactly 3n − 2 communication steps to complete. We show that it is possible to perform matrix multiplication in just 1.5n − 1 communication steps on a two dimensional square mesh array of the same size, thus halving the number of steps required.

We design a faster algorithm for the k-maximum sub-array problem under the conventional RAM model, based on distance matrix multiplication (DMM). Specifically we achieve O(n^3√(loglog n/log n) + klog n) for a general problem where overlapping is allowed for solution arrays. This complexity is sub-cubic when k = o(n 3/logn). The best known complexities of this problem are O(n 3 + klogn), which is cubic when k = O(n 3/logn), and O(kn^3√(loglog n/log n)) , which is sub-cubic when k=o(√(log n/loglog n)) .

The maximum subarray problem (MSP) involves selection of a segment of consecutive array elements that has the largest possible sum over all other segments in a given array. The efficient algorithms for the MSP and related problems are expected to contribute to various applications in genomic sequence analysis, data mining or in computer vision etc. The MSP is a conceptually simple problem, and several linear time optimal algorithms for 1D version of the problem are already known. For 2D version, the currently known upper bounds are cubic or near-cubic time. For the wider applications, it would be interesting if multiple maximum subarrays are computed instead of just one, which motivates the work in the first half of the thesis. The generalized problem of K-maximum subarray involves finding K segments of the largest sum in sorted order. Two subcategories of the problem can be defined, which are K-overlapping maximum subarray problem (K-OMSP), and K-disjoint maximum subarray problem (K-DMSP). Studies on the K-OMSP have not been undertaken previously, hence the thesis explores various techniques to speed up the computation, and several new algorithms. The first algorithm for the 1D problem is of O(Kn) time, and increasingly efficient algorithms of O(K + n logK) time, O((n+K) logK) time and O(n+K logmin(K,n)) time are presented. Considerations on extending these results to higher dimensions are made, which contributes to establishing O(n) time for 2D version of the problem where K is bounded by a certain range. Ruzzo and Tompa studied the problem of all maximal scoring subsequences, whose definition is almost identical to that of the K-DMSP with a few subtle differences. Despite slight differences, their linear time algorithm is readily capable of computing the 1D K-DMSP, but it is not easily extended to higher dimensions. This observation motivates a new algorithm based on the tournament data structure, which is of O(n+K logmin(K,n)) worst-case time. The extended version of the new algorithm is capable of processing a 2D problem in O(n + min(K,n) · n logmin(K,n)) time, that is O(n) for K ≤ n log n . For the 2D MSP, the cubic time sequential computation is still expensive for practical purposes considering potential applications in computer vision and data mining. The second half of the thesis investigates a speed-up option through parallel computation. Previous parallel algorithms for the 2D MSP have huge demand for hardware resources, or their target parallel computation models are in the realm of pure theoretics. A nice compromise between speed and cost can be realized through utilizing a mesh topology. Two mesh algorithms for the 2D MSP with O(n) running time that require a network of size O(n) are designed and analyzed, and various techniques are considered to maximize the practicality to their full potential.

The maximum subarray problem is to find the array portion that maximizes the sum of array elements in it. For K disjoint maximum subarrays, Ruzzo and Tompa gave an O(n) time solution for one-dimension. This solution is, however, difficult to extend to two-dimensions. While a trivial solution of O(Kn 3) time is easily obtainable for two-dimensions, little study has been undertaken to better this. We first propose an O(n+Klog K) time solution for one-dimension. This is equivalent to Ruzzo and Tompa’s when order is considered. Based on this, we achieve O(n 3+Kn 2log n) time for two-dimensions. This is cubic time when K≤ n/log n.

We design a simple algorithm that ranks K largest in Cartesian sums X + Y in O(m + K logK) time. Based on this, K-maximum subarrays can be computed in O(n+K logK) time (1D) and O(n +K logK) time (2D) for input array of size n and n × n respectively.

The maximum subarray problem for a one- or two-dimensional array is to find the array portion that maiximizes the sum of array elements in it. The K-maximum subarray problem is to find the K subarrays with largest sums. We improve the time complexity for the one-dimensional case from $O(min\{K+n\log^2 n, n\sqrt{K}\})$ for 0 ≤ K ≤ n(n–1)/2 to O(nlog K + K2) for K ≤ n. The latter is better when $K \le \sqrt n\log n$. If we simply extend this result to the two-dimensional case, we will have the complexity of O(n3log K + K2n2). We improve this complexity to O(n3) for $K \le \sqrt{n}$.

Given an array of positive and negative values, we consider the problem of K maximum sums. When an overlapping property needs to be observed, previous algorithms for the maximum sum are not directly applicable. We designed an O(K * n) algorithm for the K maximum subsequences problem. This was then modified to solve the K maximum subarrays problem in O(K * n/sup 3/) time. Finally, we present a VLSI K maximum subarrays algorithm with O(K * n) steps and a circuit size of O(n/sup 2/), which is cost-optimal in parallelisation of the sequential algorithm.