@manual {hennenfent08MNrap,
	title = {Repro: a Python package for automating reproducible research in scientific computing},
	year = {2008},
	month = {08},
	abstract = {Repro is a Python package for automating reproducible research in scientific computing. Repro works in combination with SCons, a next-generation build tool. The package is freely available over the Internet. Downloading and installation instructions are provided in this gui de. The repro package is documented in various ways (many comments in source code, this guide{\textendash}-written using repro itself!{\textendash}-and a reference guide). In this user{\textquoteright}s guide, we present a few pedagogical examples that uses Matlab, Python, Seismic Unix (SU), and Madagascar. We also include demo pa pers. These papers are written in LaTeX and compiled using repro. The figures they contain are automatically generated from the source codes prov ided. In that sense, the demo papers are a model of self-contained documents that are fully reproducible. The repro package is largely inspired by some parts of Madagascar, a geophysical software package for reproducible research. However, the repro package is intended for a broad audience co ming from a wide spectrum of interest areas.},
	keywords = {SLIM},
	url = {http://repro.sourceforge.net/Site/Home.html},
	author = {Gilles Hennenfent and Sean Ross-Ross}
}
@conference {ross2008SINBADsit,
	title = {Seismic inversion through operator overloading},
	booktitle = {SINBAD 2008},
	year = {2008},
	abstract = {Geophysical processing is dominated by many different out of core memory software environments (OOCE). Such environments include Madagascar and SU and are designed to handle data that can not be operated on in memory. Each base operation is created as a main program that reads data from disk and writes the result to disk. The main programs can also be chained together on stdin/out pipes using a shell only writing data to disk at the end. To be efficient, the algorithm using an OOCE must chain together the longest pipe to avoid disk I/O, as a result it is very difficult to use iterative techniques. The algorithms are written in shell scripts can be difficult to read and understand. SLIMpy is a software library that contains definitions of coordinate free vectors and linear operators. It allows the user to design and run algorithms with any out of core package, in a Matlab style interface while maintaining optimal efficiency and speed. SLIMpy looks at each main program of each OOCE as a Matrix vector operation or vector reduction/transformation operation. It uses operator overloading to generate an abstract syntax tree (AST) which can be optimized in many ways before executing its commands. The AST also provides a pathway for embarrassingly parallel applications by splitting the tree over different nodes and processors. SLIMpy provides an interface to these OOCE that allows for optimal construction of commands and allows for iterative techniques. It smoothes the transition from other languages such as Matlab and allows the algorithm designer to write readable and reusable code. SLIMpy also adds to OOCE by allowing for easy parallelization.},
	keywords = {Presentation, SINBAD, SLIM},
	url = {https://slim.gatech.edu/Publications/Public/Conferences/SINBAD/2008/ross2008SINBADsit/ross2008SINBADsit.pdf},
	author = {Sean Ross-Ross}
}
@manual {rossross07MNsda,
	title = {SLIMpy development and programming interface for seismic processing},
	year = {2007},
	abstract = {Inverse problems in (exploration) seismology are known for their large to very large scale. For instance, certain sparsity-promoting inversion techniques involve vectors that easily exceed unknowns while seismic imaging involves the construction and application of matrix-free discretized operators where single matrix-vector evaluations may require hours, days or even weeks on large compute clusters. For these reasons, software development in this field has remained the domain of highly technical codes programmed in low-level languages with little eye for easy development, code reuse and integration with (nonlinear) programs that solve inverse problems.Following ideas from the Symes{\textquoteright} Rice Vector Library and Bartlett{\textquoteright}s C++ object-oriented interface, Thyra, and Reduction/Transformation operators (both part of the Trilinos software package), we developed a software-development environment based on overloading. This environment provides a pathway from in-core prototype development to out-of-core and MPI {\textquoteright}production{\textquoteright} code with a high level of code reuse. This code reuse is accomplished by integrating the out-of-core and MPI functionality into the dynamic object-oriented programming language Python. This integration is implemented through operator overloading and allows for the development of a coordinate-free solver framework that (i) promotes code reuse; (ii) analyses the statements in an abstract syntax tree and (iii) generates executable statements. In the current implementation, we developed an interface to generate executable statements for the out-of-core unix-pipe based (seismic) processing package RSF-Madagascar (rsf.sf.net). The modular design allows for interfaces to other seismic processing packages and to in-core Python packages such as numpy. So far, the implementation overloads linear operators and element-wise reduction/transformation operators. We are planning extensions towards nonlinear operators and integration with existing (parallel) solver frameworks such as Trilinos.},
	keywords = {SLIM, software},
	url = {https://slim.gatech.edu/Software/SLIM/SLIMpy/},
	author = {Sean Ross-Ross and Henryk Modzelewski and Cody R. Brown and Felix J. Herrmann}
}
