@presentation {fang2013SINBADsfwi,
	title = {Swift FWI},
	year = {2013},
	publisher = {SINBAD},
	abstract = {In 3D case, there is much more data and modeling is much more expensive. As a result, parallel computing is very important for 3D full-waveform inversion. Both domain decomposition and data decomposition need a large number of parallel computing resources. However, programs based on parallel MATLAB suffer from the limitation of licenses. In order to obtain a MATLAB licenses free solution, we use SWIFT, which is a fast and easy parallel scripting language. Once the original Mat file is complied to an executable file, SWIFT can run the code inside the executable file in parallel without using parallel MATLAB. We use the SWIFT to compute the object functions and gradients of different shots in parallel, and test the parallel 3D FWI code with overthrust data. This is joint work with Thomas Lai, Harsh Juneja, Bas Peters.},
	keywords = {Presentation, SINBAD, SINBADFALL2013, SLIM},
	url = {https://slim.gatech.edu/Publications/Public/Conferences/SINBAD/2013/Fall/fang2013SINBADsfwi/fang2013SINBADsfwi.pdf},
	author = {Zhilong Fang and Henryk Modzelewski and Tristan van Leeuwen and Thomas Lai and Harsh Juneja and Bas Peters and Felix J. Herrmann}
}
@presentation {modzelewski2010SINBADsra,
	title = {Software releases and architecture},
	year = {2010},
	publisher = {SINBAD},
	keywords = {Presentation, SINBAD, SINBADFALL2010, SLIM},
	url = {https://slim.gatech.edu/Publications/Public/Conferences/SINBAD/2010/Fall/modzelewski2010SINBADsra/modzelewski2010SINBADsra_pres.pdf},
	author = {Henryk Modzelewski}
}
@manual {rossross08MNsai,
	title = {SLIMPy: a python interface for unix-pipe based coordinate-free scientific computing},
	year = {2008},
	month = {07},
	abstract = {SLIMpy is a Python interface that exposes the functionality of seismic data processing packages, such as MADAGASCAR, through oper ator overloading. SLIMpy provides a concrete coordinate-free implementation of classes for out-of-core linear (implicit matrix-vector), and element-wise operations, including calculation of norms and other basic vector operations. The library is intended to provide the user with an abstract sc ripting language to program iterative algorithms from numerical linear algebra. These algorithms require repeated evaluation of operators that were initially designed to be run as part of batch-oriented processing flows. The current implementation supports a plugin for Madagascar{\textquoteright}s out-of-core UNIX pipe-based applications and is extenable to pipe-based collections of programs such as Seismic Unix, SEPLib, and FreeUSP. To optimize perform ance, SLIMpy uses an Abstract Syntax Tree that parses the algorithm and optimizes the pipes.},
	url = {https://slim.gatech.edu/Software/SLIM/SLIMpy/},
	author = {Sean Ross-Ross and Henryk Modzelewski and Felix J. Herrmann}
}
@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}
}
