@conference {bisbas2020IPDPStbf,
	title = {Temporal blocking of finite-difference stencil operators with sparse "off-the-grid" sources},
	booktitle = {IEEE International Parallel and Distributed Processing Symposium},
	year = {2021},
	note = {(IPDPS, virtual)},
	month = {5},
	abstract = {Stencil kernels dominate a range of scientific applications including seismic and medical imaging, image processing, and neural networks. Temporal blocking is a performance optimisation that aims to reduce the required memory bandwidth of stencil computations by re-using data from the cache for multiple time steps. It has already been shown to be beneficial for this class of algorithms. However, optimising stencils for practical applications remains challenging. These computations often include sparsely located operators, not aligned with the computational grid ("off-the-grid"). For example, our work is motivated by sources that inject a wavefield and measurements interpolating grid values. The resulting data dependencies make the adoption of temporal blocking much more challenging. We propose a methodology to inspect these data dependencies and reorder the computation, leading to performance gains in stencil codes where temporal blocking has not been applicable. We implement this novel scheme in the Devito domain-specific compiler toolchain. Devito implements a domain-specific language embedded in Python to generate optimised partial differential equation solvers using the finite-difference method from high-level symbolic problem definitions. We evaluate our scheme using isotropic acoustic, anisotropic acoustic and isotropic elastic wave propagators of industrial significance. Performance evaluation, after auto-tuning, shows that this enables substantial performance improvement through temporal blocking, over highly-optimised vectorized spatially-blocked code of up to 1.6x.},
	keywords = {finite-difference, HPC, performance, wave-equation},
	doi = {10.1109/IPDPS49936.2021.00058},
	url = {https://arxiv.org/pdf/2010.10248.pdf},
	author = {George Bisbas and Fabio Luporini and Mathias Louboutin and Rhodri Nelson and Gerard Gorman and Paul H. J. Kelly}
}
@article {luporini2018aap,
	title = {Architecture and performance of Devito, a system for automated stencil computation},
	journal = {ACM Trans. Math. Softw.},
	volume = {46},
	number = {1},
	year = {2020},
	note = {(ACM Trans. Math. Softw.)},
	month = {04},
	abstract = {Stencil computations are a key part of many high-performance computing applications, such as image processing, convolutional neural networks, and finite-difference solvers for partial differential equations. Devito is a framework capable of generating highly-optimized code given symbolic equations expressed in Python, specialized in, but not limited to, affine (stencil) codes. The lowering process {\textendash} from mathematical equations down to C++ code {\textendash} is performed by the Devito compiler through a series of intermediate representations. Several performance optimizations are introduced, including advanced common sub-expressions elimination, tiling and parallelization. Some of these are obtained through well-established stencil optimizers, integrated in the back-end of the Devito compiler. The architecture of the Devito compiler, as well as the performance optimizations that are applied when generating code, are presented. The effectiveness of such performance optimizations is demonstrated using operators drawn from seismic imaging applications.},
	keywords = {compiler, finite difference method, performance optimization, stencil, structured grid, symbolic processing},
	doi = {10.1145/3374916},
	url = {https://slim.gatech.edu/Publications/Public/Journals/ACMTOMS/2020/luporini2018aap/luporini2018aap.pdf},
	author = {Fabio Luporini and Mathias Louboutin and Michael Lange and Navjot Kukreja and Philipp A. Witte and Jan H{\"u}ckelheim and Charles Yount and Paul H. J. Kelly and Felix J. Herrmann and Gerard J. Gorman}
}
@techreport {louboutin2020SCsta,
	title = {Scaling through abstractions {\textendash} high-performance vectorial wave simulations for seismic inversion with Devito},
	number = {TR-CSE-2020-3},
	year = {2020},
	month = {4},
	institution = {Georgia Institute of Technology},
	abstract = {[Devito] is an open-source Python project based on domain-specific language and compiler technology. Driven by the requirements of rapid HPC applications development in exploration seismology, the language and compiler have evolved significantly since inception. Sophisticated boundary conditions, tensor contractions, sparse operations and features such as staggered grids and sub-domains are all supported; operators of essentially arbitrary complexity can be generated. To accommodate this flexibility whilst ensuring performance, data dependency analysis is utilized to schedule loops and detect computational-properties such as parallelism. In this article, the generation and simulation of MPI-parallel propagators (along with their adjoints) for the pseudo-acoustic wave-equation in tilted transverse isotropic media and the elastic wave-equation are presented. Simulations are carried out on industry scale synthetic models in a HPC Cloud system and reach a performance of 28TFLOP/s, hence demonstrating Devito{\textquoteright}s suitability for production-grade seismic inversion problems.},
	keywords = {devito, elastic, finite-difference, HPC, large-scale, RTM, TTI},
	url = {https://slim.gatech.edu/Publications/Public/TechReport/2020/louboutin2020SCsta/louboutin2020SCsta.html},
	author = {Mathias Louboutin and Fabio Luporini and Philipp A. Witte and Rhodri Nelson and George Bisbas and Jan Thorbecke and Felix J. Herrmann and Gerard Gorman}
}
@conference {herrmann2019EAGEHPCaii,
	title = {Accelerating ideation and innovation cheaply in the Cloud the power of abstraction, collaboration and reproducibility},
	booktitle = {4th EAGE Workshop on High-performance Computing},
	year = {2019},
	note = {(EAGE HPC Workshop, Dubai)},
	month = {10},
	keywords = {cloud, devito, EAGE, HPC, JUDI},
	presentation = {https://slim.gatech.edu/Publications/Public/Conferences/EAGEHPC/2019/herrmann2019EAGEHPCaii/herrmann2019EAGEHPCaii_pres.pdf},
	author = {Felix J. Herrmann and Charles Jones and Gerard Gorman and Jan H{\"u}ckelheim and Keegan Lensink and Paul H. J. Kelly and Navjot Kukreja and Henryk Modzelewski and Michael Lange and Mathias Louboutin and Fabio Luporini and James Selvages and Philipp A. Witte}
}
@conference {witte2019SIAMCSEclsmft,
	title = {Compressive least squares migration with on-the-fly Fourier transforms},
	booktitle = {SIAM Conference on Computational Science and Engineering},
	year = {2019},
	note = {(SIAM CSE)},
	month = {03},
	abstract = {Least-squares seismic imaging is an inversion-based approach for accurately imaging the earth{\textquoteright}s subsurface. However, in the time-domain, the computational cost and memory requirements of this approach scale with the size and recording length of the seismic experiment, thus making this approach often prohibitively expensive in practice. To overcome these issues, we borrow ideas from compressive sensing and signal processing and introduce an algorithm for sparsity-promoting seismic imaging using on-the-fly Fourier transforms. By computing gradients and functions values for random subsets of source locations and frequencies, we considerably limit the number of wave equation solves, while on-the-fly Fourier transforms allow computing an arbitrary number of monochromatic frequency-domain wavefields with a time-domain modeling code and without having to solve large-scale Helmholtz equations. The memory requirements of this approach are independent of the number of time steps and solely depend on the number of frequencies, which determine the amount of crosstalk and subsampling artifacts in the image. We show the application of our approach to several large-scale open source data sets and compare the results to a conventional time-domain approach with optimal checkpointing.},
	keywords = {Fourier, Imaging, least-squares, migration, on-the-fly},
	presentation = {https://slim.gatech.edu/Publications/Public/Conferences/SIAMCSE/2019/witte2019SIAMCSEclsmft/witte2019SIAMCSEclsmft.pdf},
	author = {Philipp A. Witte and Mathias Louboutin and Fabio Luporini and Gerard J. Gorman and Felix J. Herrmann}
}
@article {witte2018cls,
	title = {Compressive least-squares migration with on-the-fly Fourier transforms},
	journal = {Geophysics},
	volume = {84},
	number = {5},
	year = {2019},
	note = {(Geophysics)},
	month = {08},
	pages = {R655-R672},
	abstract = {Least-squares reverse-time migration is a powerful approach for true amplitude seismic imaging of complex geological structures, but the successful application of this method is currently hindered by its enormous computational cost, as well as high memory requirements for computing the gradient of the objective function. We tackle these problems by introducing an algorithm for low-cost sparsity-promoting least-squares migration using on-the-fly Fourier transforms. We formulate the least-squares migration objective function in the frequency domain and compute gradients for randomized subsets of shot records and frequencies, thus significantly reducing data movement and the number of overall wave equations solves. By using on-the-fly Fourier transforms, we can compute an arbitrary number of monochromatic frequency-domain wavefields with a time-domain modeling code, instead of having to solve individual Helmholtz equations for each frequency, which quickly becomes computationally infeasible when moving to high frequencies. Our numerical examples demonstrate that compressive imaging with on-the-fly Fourier transforms provides a fast and memory-efficient alternative to time-domain imaging with optimal checkpointing, whose memory requirements for a fixed background model and source wavelet is independent of the number of time steps. Instead, memory and additional computational cost grow with the number of frequencies and determine the amount of subsampling artifacts and crosstalk. In contrast to optimal checkpointing, this offers the possibility to trade both memory and computational cost for image quality or a larger number of iterations and is advantageous in new computing environments such as the cloud, where compute is often cheaper than memory and data movement.},
	keywords = {Fourier, least squares migration, sparsity-promotion},
	doi = {10.1190/geo2018-0490.1},
	url = {https://slim.gatech.edu/Publications/Public/Journals/Geophysics/2019/witte2018cls/witte2018cls.pdf},
	author = {Philipp A. Witte and Mathias Louboutin and Fabio Luporini and Gerard J. Gorman and Felix J. Herrmann}
}
@article {louboutin2018dae,
	title = {Devito (v3.1.0): an embedded domain-specific language for finite differences and geophysical exploration},
	journal = {Geoscientific Model Development},
	year = {2019},
	note = {(Geoscientific Model Development)},
	abstract = {We introduce Devito, a new domain-specific language for implementing high-performance finite difference partial differential equation solvers. The motivating application is exploration seismology where methods such as Full-Waveform Inversion and Reverse-Time Migration are used to invert terabytes of seismic data to create images of the earth{\textquoteright}s subsurface. Even using modern supercomputers, it can take weeks to process a single seismic survey and create a useful subsurface image. The computational cost is dominated by the numerical solution of wave equations and their corresponding adjoints. Therefore, a great deal of effort is invested in aggressively optimizing the performance of these wave-equation propagators for different computer architectures. Additionally, the actual set of partial differential equations being solved and their numerical discretization is under constant innovation as increasingly realistic representations of the physics are developed, further ratcheting up the cost of practical solvers. By embedding a domain-specific language within Python and making heavy use of SymPy, a symbolic mathematics library, we make it possible to develop finite difference simulators quickly using a syntax that strongly resembles the mathematics. The Devito compiler reads this code and applies a wide range of analysis to generate highly optimized and parallel code. This approach can reduce the development time of a verified and optimized solver from months to days.},
	keywords = {finite-differences, HPC, Modeling, wave-equation},
	doi = {10.5194/gmd-12-1165-2019},
	url = {https://slim.gatech.edu/Publications/Public/Journals/GMD/2019/louboutin2018dae/louboutin2018dae.pdf},
	author = {Mathias Louboutin and Michael Lange and Fabio Luporini and Navjot Kukreja and Philipp A. Witte and Felix J. Herrmann and Paulius Velesko and Gerard J. Gorman}
}
@article {witte2019ecl,
	title = {Geophysics Bright Spots: Efficient coding of large-scale seismic inversion algorithms},
	journal = {The Leading Edge},
	volume = {38},
	number = {6},
	year = {2019},
	note = {(The Leading Edge)},
	pages = {482-484},
	abstract = {In {\textquotedblleft}A large-scale framework for symbolic implementations of seismic inversion algorithms in Julia,{\textquotedblright} Witte et al. describe new developments in how to code complex geophysical algorithms in a concise way. Subsurface seismic imaging and parameter estimation are among the most computationally challenging problems in the scientific community. Codes for solving seismic inverse problems, such as FWI or least-squares reverse time migration (LS-RTM), need to be highly optimized, but at the same time, facilitate the implementation of complex optimization algorithms. Traditionally, production-level codes in the oil and gas industry were exclusively written in low-level languages, such as C or Fortran, with extensive amounts of manual performance optimizations, thus making code maintenance, debugging, and adoption of new algorithms prohibitively challenging. Witte et al. present a paradigm of software engineering for seismic inverse problems based on symbolic user interfaces and code generation with automated performance optimization. Inspired by recent deep learning frameworks, the Julia Devito inversion framework (JUDI; an open-source software package) combines high-level abstractions for expressing seismic inversion algorithms with a domain-specific language compiler called Devito for solving the underlying wave equations. Devito{\textquoteright}s generated code is compiled just in time and outperforms codes with manual performance optimizations. JUDI utilizes Julia{\textquoteright}s high-level parallelization, making the software easily adaptable to a variety of computing environments such as densely connected HPC clusters or the cloud. The numerical examples (Figure 3) demonstrate the ability to implement a variety of complex algorithms for FWI and LS-RTM in a few lines of Julia code and run it on large-scale 3D models. The paper concludes that abstractions and performance are not mutually exclusive, and use of symbolic user interfaces can facilitate the implementation of new and innovative seismic inversion algorithms.},
	keywords = {bright spots, inversion, Julia, large-scale},
	doi = {10.1190/tle38060482.1},
	url = {https://library.seg.org/doi/10.1190/tle38060482.1},
	author = {Philipp A. Witte and Mathias Louboutin and Navjot Kukreja and Fabio Luporini and Michael Lange and Gerard J. Gorman and Felix J. Herrmann}
}
@article {witte2018alf,
	title = {A large-scale framework for symbolic implementations of seismic inversion algorithms in Julia},
	journal = {Geophysics},
	volume = {84},
	number = {3},
	year = {2019},
	note = {(Geophysics)},
	month = {03},
	pages = {F57-F71},
	abstract = {Writing software packages for seismic inversion is a very challenging task, since problems such as full-waveform inversion or least-squares imaging are both algorithmically and computationally demanding due to the large number of unknown parameters and the fact that we are propagating waves over many wavelengths. Software frameworks therefore need to combine both versatility and performance to provide geophysicists with the means and flexibility to implement complex algorithms that scale to exceedingly large 3D problems. Following these principles, we introduce the Julia Devito Inversion framework, an open-source software package in Julia for large-scale seismic modeling and inversion based on Devito, a domain-specific language compiler for automatic code generation. The framework consists of matrix-free linear operators for implementing seismic inversion algorithms that closely resembles the mathematical notation, a flexible resilient parallelization and an interface to Devito for generating optimized stencil code to solve the underlying wave equations. In comparison to many manually optimized industry codes written in low-level languages, our software is built on the idea of independent layers of abstractions and user interfaces with symbolic operators, making it possible to manage both the complexity of algorithms and performance optimizations, while preserving modularity, which allows for a level of expressiveness needed to formulate a broad range of wave-equation-based inversion problems. Through a series of numerical examples, we demonstrate that this allows users to implement algorithms for waveform inversion and imaging as simple Julia scripts that scale to large-scale 3D problems; thus providing a truly performant research and production framework.},
	keywords = {FWI, inversion, LSRTM, Modeling, software},
	doi = {10.1190/geo2018-0174.1},
	url = {https://slim.gatech.edu/Publications/Public/Journals/Geophysics/2019/witte2018alf/witte2018alf.pdf},
	author = {Philipp A. Witte and Mathias Louboutin and Navjot Kukreja and Fabio Luporini and Michael Lange and Gerard J. Gorman and Felix J. Herrmann}
}
@article {louboutin2017fwip2,
	title = {Full-Waveform Inversion - Part 2: adjoint modeling},
	journal = {The Leading Edge},
	volume = {37},
	number = {1},
	year = {2018},
	note = {(The Leading Edge)},
	month = {1},
	pages = {69-72},
	abstract = {This tutorial is the second part of a three part tutorial series on full-waveform inversion (FWI), in which we provide a step by step walk through of setting up forward and adjoint wave equation solvers and an optimization framework for inversion. In part 1 (Louboutin et al., 2017), we demonstrated how to discretize the acoustic wave equation and how to set up a basic forward modeling scheme using Devito, a domain-specific language (DSL) in Python for automated finite-difference (FD) computations (Lange et al., 2016). Devito allows us to define wave equations as symbolic Python expressions (Meurer et al., 2017), from which optimized FD stencil code is automatically generated at run time. In part 1, we show how we can use Devito to set up and solve acoustic wave equations with (impulsive) seismic sources and sample wavefields at the receiver locations to model shot records.},
	keywords = {acoustic, devito, finite-difference, FWI, tutorial},
	doi = {10.1190/tle37010069.1},
	url = {https://slim.gatech.edu/Publications/Public/Journals/TheLeadingEdge/2018/louboutin2017fwip2/louboutin2017fwip2.html},
	author = {Mathias Louboutin and Philipp A. Witte and Michael Lange and Navjot Kukreja and Fabio Luporini and Gerard Gorman and Felix J. Herrmann}
}
@article {witte2018fwip3,
	title = {Full-Waveform Inversion - Part 3: optimization},
	journal = {The Leading Edge},
	volume = {37},
	number = {2},
	year = {2018},
	note = {(The Leading Edge)},
	month = {1},
	pages = {142-145},
	abstract = {This tutorial is the third part of a full-waveform inversion (FWI) tutorial series with a step-by-step walkthrough of setting up forward and adjoint wave equations and building a basic FWI inversion framework. For discretizing and solving wave equations, we use Devito, a Python-based domain-specific language for automated generation of finite-difference code (Lange et al., 2016). The first two parts of this tutorial (Louboutin et al., 2017, 2018) demonstrated how to solve the acoustic wave equation for modeling seismic shot records and how to compute the gradient of the FWI objective function using the adjoint-state method. With these two key ingredients, we will now build an inversion framework that can be used to minimize the FWI least-squares objective function.},
	keywords = {devito, finite-differences, FWI, inversion, Modeling, tutorial},
	doi = {10.1190/tle37020142.1},
	url = {https://slim.gatech.edu/Publications/Public/Journals/TheLeadingEdge/2018/witte2018fwip3/witte2018fwip3.html},
	author = {Philipp A. Witte and Mathias Louboutin and Keegan Lensink and Michael Lange and Navjot Kukreja and Fabio Luporini and Gerard Gorman and Felix J. Herrmann}
}
@conference {herrmann2018SMCtpa,
	title = {The power of abstraction in Computational Exploration Seismology},
	booktitle = {Smoky Mountains Computational Sciences and Engineering Conference},
	year = {2018},
	month = {08},
	abstract = {The field of Computational Exploration Seismology has over the years benefited tremendously from developments in HPC. Back in the 80{\textquoteright}s and early 90{\textquoteright}s, the oil \& gas industry was among the main drivers of HPC technology with a resurgence about ten years ago with the advent of full-waveform inversion-i.e., an adjoint-state method for inverse problems that involve the wave equation. While the combination of hardware developments and tedious manual coding efforts have resulted in major improvements, the rate of innovations is slow in part because of the inherent complexities of the mostly monolithic code bases. As a result, innovations make it too slowly into these optimized codes. This stifles innovation and could prevent adaptation of important developments such as machine learning with deep convolutional neural networks into existing workflows. In comparison, the technological advances in the academic as well as commercial machine learning communities have been much faster in part because of robust and well abstracted code bases such as PyTorch and TensorFlow. Since both machine learning and adjoint-state methods rely on back propagation strong similarities exist ready to be exploited. During my talk, I will discuss lessons we learned in finding the appropriate abstractions, read Domain Specific Language, for time-stepping stencil-based finite differences in Devito, and how this is relevant for machine learning with deep networks. I will also share a vision on how ideas from machine learning can be merged into the development of the next-generation of wave-equation based imaging codes. In particular, I will demonstrate the remarkable ability of deep convolutional networks to map low-fidelity dispersed numerical wave simulations to high-fidelity ones. I feel that this apparently generalizable capability of neural nets opens a complete new approach to tackle fundamental problems in computational exploration seismology.},
	keywords = {SMC},
	presentation = {https://slim.gatech.edu/Publications/Public/Conferences/SMC/2018/herrmann2018SMCtpa/herrmann2018SMCtpa_pres.pdf},
	author = {Felix J. Herrmann and Gerard J. Gorman and Jan H{\"u}ckelheim and Keegan Lensink and Paul H. J. Kelly and Navjot Kukreja and Henryk Modzelewski and Michael Lange and Mathias Louboutin and Fabio Luporini and Ali Siahkoohi and Philipp A. Witte}
}
@conference {kukreja2017SIAMdsm,
	title = {Devito: symbolic math for automated fast finite difference computations},
	booktitle = {SIAM Conference on Computational Science and Engineering},
	year = {2017},
	note = {(SIAM Conference on Computational Science and Engineering, Atlanta)},
	month = {02-03},
	keywords = {acoustic, compiler, devito, finite differences, high performance computing, Modelling, SIAM, stencil},
	url = {https://slim.gatech.edu/Publications/Public/Conferences/SIAM/2017/kukreja2017SIAMdsm/kukreja2017SIAMdsm_pres.mov},
	presentation = {https://slim.gatech.edu/Publications/Public/Conferences/SIAM/2017/kukreja2017SIAMdsm/kukreja2017SIAMdsm_pres.pdf},
	author = {Navjot Kukreja and Michael Lange and Mathias Louboutin and Fabio Luporini and Gerard Gorman}
}
@article {louboutin2017fwi,
	title = {Full-Waveform Inversion - Part 1: forward modeling},
	journal = {The Leading Edge},
	volume = {36},
	number = {12},
	year = {2017},
	note = {(The Leading Edge)},
	month = {12},
	pages = {1033-1036},
	abstract = {Since its re-introduction by Pratt (1999), full-waveform inversion (FWI) has gained a lot of attention in geophysical exploration because of its ability to build high resolution velocity models more or less automatically in areas of complex geology. While there is an extensive and growing literature on the topic, publications focus mostly on technical aspects, making this topic inaccessible for a broader audience due to the lack of simple introductory resources for newcomers to geophysics. We will accomplish this by providing a hands-on walkthrough of FWI using Devito (Lange et al. 2016), a system based on domain-specific languages that automatically generates code for time-domainfinite-differences.},
	keywords = {devito, finite-differences, FWI, Modeling, tutorial},
	doi = {10.1190/tle36121033.1},
	url = {https://slim.gatech.edu/Publications/Public/Journals/TheLeadingEdge/2017/louboutin2017fwi/louboutin2017fwi.html},
	author = {Mathias Louboutin and Philipp A. Witte and Michael Lange and Navjot Kukreja and Fabio Luporini and Gerard Gorman and Felix J. Herrmann}
}
@presentation {louboutin2017SINBADFldi,
	title = {Latest developments in Devito},
	year = {2017},
	publisher = {SINBAD},
	abstract = {We present an overview of the latest developments in Devito. We introduced Devito in the previous meeting as a prototype finite-difference DSL for seismic modelling and inversion. We are presenting here the latest improvements and functionalities of Devito. We will also discuss the current future plans as well as non-supported features that the audience may be interested in. This presentation will be followed by/mixed with a hands-in tutorial if the time and resources allows it.},
	keywords = {Presentation, SINBAD, SINBADFALL2017, SLIM},
	url = {https://slim.gatech.edu/Publications/Public/Conferences/SINBAD/2017/Fall/louboutin2017SINBADFldi/louboutin2017SINBADFldi.pdf},
	url2 = {https://slim.gatech.edu/Publications/Public/Conferences/SINBAD/2017/Fall/louboutin2017SINBADFldi/louboutin2017SINBADFldi.mov},
	author = {Mathias Louboutin and Michael Lange and Fabio Luporini and Navjot Kurjeka and Jan Hueckelheim and Gerard Gorman and Philipp A. Witte and Felix J. Herrmann}
}
@conference {kukreja2016OGHPClsm,
	title = {Leveraging symbolic math for rapid development of applications for seismic modeling},
	booktitle = {OGHPC},
	year = {2017},
	note = {(Oil and Gas HPC Conference, Rice University)},
	month = {03},
	abstract = {Wave propagation kernels are the core of many commonly used algorithms for inverse problems in exploration geophysics. While they are easy to write and analyze for the simplied cases, the code quickly becomes complex when the physics needs to be made more precise or the performance of these codes is to be optimized. Signicant eort is repeated every time new forms of physics need to be implemented, or a new computing platform to be supported. The use of symbolic mathematics as a domain specic language (DSL) for input, combined with automatic generation of high performance code customized for the target hardware platform is a promising approach to maximize code reuse. Devito is a DSL for nite dierence that uses symbolic mathematics to generate optimized code for wave propagation based on a provided wave equation. It enables rapid application development in a eld where the average time spent on development has historically been in weeks and months. The Devito DSL system is completely wrapped within the Python programming language and the fact that the running code is in C is completely transparent, making it simple to include Devito as part of a larger work ow including multiple applications over a large cluster.},
	keywords = {finite differences, HPC, Modelling, OGHPC, time domain},
	url = {https://slim.gatech.edu/Publications/Public/Conferences/OGHPC/2017/kukreja2016OGHPClsm/kukreja2016OGHPClsm.pdf},
	presentation = {https://slim.gatech.edu/Publications/Public/Conferences/OGHPC/2017/kukreja2016OGHPClsm/kukreja2016OGHPClsm_pres.pdf},
	author = {Navjot Kukreja and Mathias Louboutin and Michael Lange and Fabio Luporini and Gerard Gorman}
}
@conference {lange2017SCIPYofd,
	title = {Optimised finite difference computation from symbolic equations},
	booktitle = {Python in Science Conference Proceedings},
	year = {2017},
	note = {(SciPy, Texas)},
	month = {07},
	pages = {89-96},
	abstract = {Domain-specific high-productivity environments are playing an increasingly important role in scientific computing due to the levels of abstraction and automation they provide. In this paper we introduce Devito, an open-source domain-specific framework for solving partial differential equations from symbolic problem definitions by the finite difference method. We highlight the generation and automated execution of highly optimized stencil code from only a few lines of high-level symbolic Python for a set of scientific equations, before exploring the use of Devito operators in seismic inversion problems.},
	keywords = {domain-specific languages, finite difference, symbolic Python},
	url = {http://conference.scipy.org/proceedings/scipy2017/michael_lange.html},
	presentation = {https://slim.gatech.edu/Publications/Public/Conferences/SciPy/2017/lange2017SCIPYofd/lange2017SCIPYofd_pres.pdf},
	author = {Michael Lange and Navjot Kukreja and Fabio Luporini and Mathias Louboutin and Charles Yount and Jan H{\"u}ckelheim and Gerard Gorman}
}
@conference {louboutin2017SIAMras,
	title = {Raising the abstraction to separate concerns: enabling different physics for geophysical exploration},
	booktitle = {SIAM Conference on Computational Science and Engineering},
	year = {2017},
	note = {(SIAM Conference on Computational Science and Engineering, Atlanta)},
	month = {02-03},
	abstract = {Full-waveform inversion is a PDE-constrained optimisation problem involving massive amounts of data (petabytes) and large numbers of unknowns (O(10^9)). This well known compute-intensive and data-intensive is extremely challenging for several reasons. First, there is the complexity of having to handle extremely large data volumes with metadata related to experimental details in the field, and the discretization of the unknown earth parameters and approximate physics. Second, reduced or adjoint-state methods call for computationally intensive PDE solves for each source experiment (of which there are thousands) for each iteration of a gradient-based optimization scheme. The talks will give an overview how carefully chosen layers of abstraction can help manage both the complexity and scale of inversion while still achieving the high degree of computational performance required to make full-waveform a practical tool. Specifically, the presentations will focus on domain specific stencil language for time-stepping methods to solve various types of wave equations and on abstracts for large-scale parallel optimization frameworks.},
	keywords = {finite differences, HPC, Modelling, SIAM, time domain},
	url = {https://slim.gatech.edu/Publications/Public/Conferences/SIAM/2017/louboutin2017SIAMras/louboutin2017SIAMras_pres.mov},
	presentation = {https://slim.gatech.edu/Publications/Public/Conferences/SIAM/2017/louboutin2017SIAMras/louboutin2017SIAMras_pres.pdf},
	author = {Mathias Louboutin and Michael Lange and Navjot Kukreja and Fabio Luporini and Felix J. Herrmann and Gerard Gorman}
}
@conference {kukreja2016WOLFHPCdaf,
	title = {Devito: automated fast finite difference computation},
	booktitle = {WOLFHPC 2016 Workshop (Super Computing)},
	year = {2016},
	note = {(WOLFHPC Workshop (SC16), Utah)},
	month = {11},
	abstract = {Domain specific languages have successfully been used in a variety of fields to cleanly express scientific problems as well as to simplify implementation and performance optimization on different computer architectures. Although a large number of stencil languages are available, finite difference domain specific languages have proved challenging to design because most practical use cases require additional features that fall outside the finite difference abstraction. Inspired by the complexity of real-world seismic imaging problems, we introduce Devito, a domain specific language in which high level equations are expressed using symbolic expressions from the SymPy package. Complex equations are automatically manipulated, optimized, and translated into highly optimized C code that aims to perform comparably or better than hand-tuned code. All this is transparent to users, who only see concise symbolic mathematical expressions.},
	keywords = {acoustic, compiler, finite differences, high performance computing, Modelling, stencil},
	url = {https://slim.gatech.edu/Publications/Public/Conferences/SC/2016/WOLFHPC/kukreja2016WOLFHPCdaf/kukreja2016WOLFHPCdaf.pdf},
	url2 = {https://slim.gatech.edu/Publications/Public/Conferences/SC/2016/WOLFHPC/kukreja2016WOLFHPCdaf/kukreja2016WOLFHPCdaf_pres.pdf},
	author = {Navjot Kukreja and Mathias Louboutin and Felippe Vieira Zacarias and Fabio Luporini and Michael Lange and Gerard Gorman}
}
@conference {lange2016dtg,
	title = {Devito: Towards a generic finite difference DSL using symbolic python},
	booktitle = {6th Workshop on Python for High-Performance and Scientific Computing},
	year = {2016},
	note = {(PyHPC, Utah)},
	month = {11},
	pages = {67-75},
	abstract = {Domain specific languages (DSL) have been used in a variety of fields to express complex scientific problems in a concise manner and provide automated performance optimization for a range of computational architectures. As such DSLs provide a powerful mechanism to speed up scientific Python computation that goes beyond traditional vectorization and pre-compilation approaches, while allowing domain scientists to build applications within the comforts of the Python software ecosystem. In this paper we present Devito, a new finite difference DSL that provides optimized stencil computation from high-level problem specifications based on symbolic Python expressions. We demonstrate Devito{\textquoteright}s symbolic API and performance advantages over traditional Python acceleration methods before highlighting its use in the scientific context of seismic inversion problems.},
	keywords = {acoustic, finite differences, HPC, inversion, Modelling, python, software optimization},
	doi = {10.1109/PyHPC.2016.9},
	url = {https://slim.gatech.edu/Publications/Public/Conferences/PyHPC/2016/lange2016dtg/lange2016dtg.pdf},
	url2 = {https://slim.gatech.edu/Publications/Public/Conferences/PyHPC/2016/lange2016dtg/lange2016dtg_pres.pdf},
	author = {Michael Lange and Navjot Kukreja and Mathias Louboutin and Fabio Luporini and Felippe Vieira Zacarias and Vincenzo Pandolfo and Paulius Velesko and Paulius Kazakas and Gerard Gorman}
}
@presentation {gorman2016SINBADFopp,
	title = {Open Performance portablE SeismiC Imaging{\textendash}-OPESCI},
	year = {2016},
	publisher = {SINBAD},
	abstract = {In this project, we introduce OPESCI-FD, a Python package built on symbolic mathematics to automatically generate Finite Difference models from a high-level description of the model equations. We investigate applying this framework to generate the propagator program used in seismic imaging. We implement the 3D acoustic and anisotropic FD scheme as an example and demonstrate the advantages of usability, flexibility and accuracy of the framework. The design of OPESCI-FD aims to allow rapid development, analysis and optimisation of Finite Difference programs. OPESCI-FD is the foundation for continuing development by the OPESCI project team, building on the research presented in this report. This talk concludes by reviewing the further developments that are already under way, as well as the scope for extension to cater for other equations and numerical schemes. This joint work with SINBAD and SENAI CIMATEC and has received additional funding from Intel.},
	keywords = {Presentation, private, SINBAD, SINBADFALL2016, SLIM},
	url = {https://slim.gatech.edu/Publications/Public/Conferences/SINBAD/2016/Fall/gorman2016SINBADFopp/gorman2016SINBADFopp.pdf},
	url2 = {https://slim.gatech.edu/Publications/Private/Conferences/SINBAD/2016/Fall/gorman2016SINBADFopp/gorman2016SINBADFopp.mov},
	author = {Gerard Gorman and Marcos de Aguiar and David Ham and Felix J. Herrmann and Paul H. J. Kelly and Navjot Kukreja and Michael Lange and Mathias Louboutin and Fabio Luporini and Paulius Velesko and Vincenzo Pandolfo and Felippe Vieira Zacarias}
}
