https://www.reproducibility.org/wiki2020/api.php?action=feedcontributions&user=Jgodwin&feedformat=atomMadagascar - User contributions [en]2024-03-29T14:05:52ZUser contributionsMediaWiki 1.34.0https://www.reproducibility.org/wiki2020/index.php?title=Tutorial_-_Users_2_-_Plotting&diff=1697Tutorial - Users 2 - Plotting2011-04-26T06:04:24Z<p>Jgodwin: Created page with "Madagascar also has a robust package of tools for plotting the results of your computations in multi-dimensions! These plots are created using a vector plotting library original..."</p>
<hr />
<div>Madagascar also has a robust package of tools for plotting the results of your computations in multi-dimensions! These plots are created using a vector plotting library originally developed by Joe Dellinger at SEP called VPLOT. VPLOT provides a method for making plots that are small in size, aesthetically pleasing, and easily compatible with Latex for rapid creation of production quality images. <br />
<br />
= VPLOT file format =<br />
<br />
The VPLOT file format ('''.vpl suffix''') is a self-contained binary data format that describes how to draw the plot on the screen using an interpreter. Since VPLOT is not a standard imaging format, VPLOT files must be viewed with third-party interpreters which we call '''pens'''. Each '''pen''' interfaces VPLOT with a third-party graphing library such as X11, plplot, opengl, and others. This flexibility makes VPLOT files almost as portable as standard image formats such as: jpeg, png, and gif. Unlike rasterized formats, VPLOT files can be scaled to any size without losing image quality. This feature alone makes VPLOT worth the work, because you don't have to regenerate your images each time you want to change their size! <br />
<br />
= Plotting programs = <br />
<br />
To generate VPLOT files, we need to pass our computed RSF files through vplot filters, that convert RSF files to VPLOT files. The vplot filters are named by the type of plot that they produce. The full list of available vplot filters is:<br />
<br />
*sfgraph -<br />
*sfgrey<br />
*sfgrey3<br />
*sfbyte<br />
*sfbox<br />
*sfcontour<br />
*sfcontour3<br />
*sfcubeplot<br />
<br />
<bash><br />
sfgrey < junk.rsf > junk.vpl<br />
</bash></div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorials&diff=1696Tutorials2011-04-26T05:48:37Z<p>Jgodwin: /* Users */</p>
<hr />
<div>Learn Madagascar by completing the tutorial series below. The tutorials are aimed at a few types of individuals: <br />
<br />
1 - Users - Individuals who want to know how to use Madagascar immediately for data processing.<br />
<br />
2 - Developers - Individuals who are already Users, who want to write their own programs and/or contribute to Madagascar.<br />
<br />
3 - Authors - Individuals interested in creating reproducible documents using Madagascar.<br />
<br />
Additionally, we have a series of tutorials that show users how to perform common tasks, such as SEG-Y read/write, and conversion to and from SU formats. <br />
<br />
'''All tutorials are documented by examples in the Madagascar release. You can work alongside the examples!'''<br />
<br />
'''Tutorials are organized into levels. Higher level courses in a section require the lower level courses to be completed first.'''<br />
<br />
= Users =<br />
<br />
The user tutorials are focused on getting a new user running Madagascar from the ground up. These tutorials cover everything from: the command line interface, to advanced SCons functionality. By the end of these tutorials, you should be able to process large datasets using Madagascar very quickly, and write powerful Python scripts that are reproducible.<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|-<br />
| [[Tutorial_-_Users_0_-_RSF_file_format | RSF file format]] || 0 || An introduction to Madagascar and the RSF file format<br />
|-<br />
| [[Tutorial_-_Users_1_-_Command_line_interface | Command line interface]] || 1 || Using the command line interface<br />
|-<br />
| [[Tutorial_-_Users_2_-_Plotting | Plotting]] || 2 || Creating and viewing vplot files<br />
|-<br />
| Intro to SCons || 3 || Creating simple SCons scripts for build control<br />
|-<br />
| Advanced SCons || 4 || Creating advanced SCons scripts<br />
|-<br />
| Advanced SCons II || 5 || Abusing SCons<br />
|- <br />
| Python || 6 || Loops, flow control, functions<br />
|- <br />
| Advanced visualization || 6 || 3D visualization using the Mines JTK and VTK<br />
|}<br />
<br />
= Developers = <br />
<br />
The developer tutorials are targeted to people who are already familiar with processing data in Madagascar. You should have completed the User tutorial series before beginning this tutorial series. This tutorial set covers: designing and developing simple programs in Madagascar, using the various language APIs, and parallel programming. Following completion of this tutorial series, you should be able to write advanced programs in Madagascar that can be contributed back to the community for others to use!<br />
<br />
{| border="1"<br />
! Name !! Level !! Description <br />
|-<br />
| Intro to Development || 0 || Learn how to write simple C programs using Madagascar<br />
|-<br />
| Advanced development || 1 || Learn how to link against other libraries <br />
|- <br />
| API development || 1 || Learn how to write a program in another API (Java, Python, Matlab, Fortran)<br />
|- <br />
| Parallel computing || 2 || Write a program that uses MPI or OpenMP <br />
|- <br />
| High performance Madagascar || 3 || Maximize your program's performance in Madagascar<br />
|}<br />
<br />
= Authors =<br />
<br />
The author tutorials are targeted at those who want to create reproducible documents using Madagascar. You should have completed the User tutorial before attempting these tutorials. This tutorial covers: combining Latex and Madagascar in a reproducible fashion, adding your own Latex style-sheets and macros, and building an SEG expanded abstract.<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|- <br />
| Intro to Reproducible documents || 0 || Introduction to reproducible documents and the framework <br />
|-<br />
| Using Latex || 1 || Create a simple document that uses Latex and Madagascar together.<br />
|-<br />
| Slides || 2 || Create a Beamer presentation using Madagascar.<br />
|-<br />
| SEG || 2 || Create an SEG abstract using Madagascar.<br />
|-<br />
| Geophysics || 3 || Create a Geophysics paper using Madagascar.<br />
|-<br />
| Reproduce past research || 3 || Reproduce someone else's research using Madagascar and Latex.<br />
|-<br />
| Adding custom macros || 4 || Adding your own macros for Latex documents using Madagascar.<br />
|- <br />
| Adding custom style sheets || 5 || Add or change style sheets to suit your own purposes easily using Madagascar.<br />
|}<br />
<br />
= Tasks = <br />
<br />
These tutorials are side tutorials that show how to perform specific tasks. You should have completed the Users tutorials before using these tutorials.<br />
<br />
{| border="1"<br />
! Name || Description<br />
|-<br />
| SEG-Y conversion || Read and write SEG-Y data to and from RSF format<br />
|-<br />
| Finite difference modeling || Create physical models and synthesize seismograms using a finite difference modeling code.<br />
|}</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorial_-_Users_1_-_Command_line_interface&diff=1695Tutorial - Users 1 - Command line interface2011-04-26T05:47:26Z<p>Jgodwin: </p>
<hr />
<div>Madagascar is designed to be used from the command line. Programmers create Madagascar programs (prefixed with the sf designation) that read and write Madagascar files. These programs are designed to be as general as possible, each one operates on any dataset provided in RSF format, provided you also provide the correct parameters and have the right type of data for the program. Thus, each Madagascar program can be used in even ways that the original developer may not have foreseen, which makes your life easier as a user!<br />
<br />
= Command line interface = <br />
Madagascar programs follow the standard UNIX conventions for reading and writing RSF files to and from STDIN and STDOUT. This is also the same convention that SeismicUnix uses, so for those of you who are SU fans, this should be an easy conversion. <br />
<br />
For example: the program sfattr allows us to get attributes about an RSF file (mean, standard deviation, min, max, etc.) To get the attributes for a pre-computed file, we might use:<br />
<bash><br />
sfattr < junk.rsf <br />
</bash><br />
which outputs:<br />
<code><br />
rms = 1.41316 <br />
mean = 0.999667 <br />
2-norm = 357.503 <br />
variance = 0.997693 <br />
std dev = 0.998846 <br />
max = 5.05567 at 36 8 27 <br />
min = -3.59936 at 18 9 6 <br />
nonzero samples = 64000 <br />
total samples = 64000 <br />
</code><br />
For an example of reading and writing an RSF file I'm going to demonstrate the use of sfwindow which is a program that allows us to select portions of an RSF file. When sfwindow is used without any additional parameters, we are able to make a copy of a file with a different filename. For example:<br />
<bash><br />
sfwindow < junk.rsf > junk2.rsf<br />
</bash><br />
gives us two files, junk.rsf and junk2.rsf which are identical but not the same file.<br />
<br />
In addition to specifying files to read in and out on the command line we can specify the parameters for each program that are necessary for it to run, or to produce the desired result. The general format for specifying parameters on the command line is key=val, where key is the name of the parameter that you want to set, and val is the value of the parameter. There are four (4) different types of values that are acceptable: int, float, boolean, or string. Going back to the window program, we can specify the number of traces or pieces of the file that we want to keep like:<br />
<br />
<bash><br />
sfwindow < junk.rsf n1=10 > junk-win.rsf<br />
</bash><br />
<br />
= Self-documentation =<br />
<br />
Of course, we can specify as many parameters as we'd like on the command line. To figure out which parameters are needed for a specific program, just type the name of the program with no input files our output files on the command line as follows:<br />
<br />
sfwindow<br />
<br />
which brings up the self-documentation, which looks something like the following:<br />
<br />
NAME<br />
sfwindow<br />
DESCRIPTION<br />
Window a portion of a dataset. <br />
SYNOPSIS<br />
sfwindow < in.rsf > out.rsf verb=n squeeze=y j#=(1,...) d#=(d1,d2,...) f#=(0,...) min#=(o1,o2,,...) n#=(0,...) max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...)<br />
PARAMETERS<br />
float d#=(d1,d2,...) sampling in #-th dimension <br />
largeint f#=(0,...) window start in #-th dimension <br />
int j#=(1,...) jump in #-th dimension <br />
float max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...) maximum in #-th dimension <br />
float min#=(o1,o2,,...) minimum in #-th dimension <br />
largeint n#=(0,...) window size in #-th dimension <br />
bool squeeze=y [y/n] if y, squeeze dimensions equal to 1 to the end <br />
bool verb=n [y/n] Verbosity flag<br />
USED IN<br />
bei/dpmv/krchdmo<br />
bei/dpmv/matt<br />
bei/dwnc/sigmoid<br />
bei/fdm/kjartjac<br />
bei/fld/cube<br />
bei/fld/shotmovie<br />
bei/fld/synmarine<br />
bei/fld/yc<br />
bei/ft1/autocor<br />
<br />
The self-documentation tells us the function of the program, as well as the parameters that are available to be specified. The parameter format is type - name=default value [options] and then a short description of the parameter. File parameters request a name of a file. For example: file=junk.rsf<br />
<br />
= Piping =<br />
<br />
Sometimes we want to chain multiple commands together without writing intermediate Madagascar RSF files in the process. Fortunately, we can do this using another standard UNIX construct, Pipes. Pipes allow us to connect the standard output from one Madagascar program to the standard input to another program without first writing to a file. For example we could do the following without pipes:<br />
<br />
sfwindow < junk.rsf > junk-win.rsf<br />
sftransp < junk-win.rsf > junk2.rsf<br />
<br />
Or we could do the equivalent using pipes on one line:<br />
<br />
sfwindow < junk.rsf | sftransp > junk2.rsf<br />
<br />
Pipes simply make these statements more compact, and allow us to reduce the number of files that we need to save to disk. If you're doing something many times over, then pipes will make your life significantly easier. I highly recommend that you use pipes! Also, you should know that you can chain as many commands together as necessary using Pipes. <br />
<br />
Note: Madagascar uses a trick to make sure that you can send as much data as you want through the pipes because a conventional UNIX pipe has a maximum amount of data that can be sent through it. To avoid this limitation, Madagascar writes the data to temporary files before sending it through a pipe.<br />
<br />
= Interacting with files =<br />
<br />
Ultimately though, 95% of your time using Madagascar on the command line will be to inspect and view files that are output by your scripts. Some of the key commands that are used to interact with files on the command line are:<br />
<br />
'''sfin - get header information''' <br />
<br />
SFIN is the most used program on the command line, because most often we simply need to check the dimensionality of our files to make sure that we have them in the correct order.<br />
<br />
<bash><br />
sfin junk.rsf<br />
<br />
junk.rsf:<br />
in="/var/tmp/junk.rsf@"<br />
esize=4 type=float form=native <br />
n1=100 d1=0.004 o1=0 label1="Time" unit1="s" <br />
n2=34 d2=0.1 o2=0 label2="Distance" unit2="km" <br />
3400 elements 13600 bytes<br />
</bash><br />
<br />
'''sfattr - get file attributes'''<br />
<br />
SFATTR is also commonly used from the command line to check files for correct values. Most often, we use sfattr to ensure that files are not filled with zeros, or with NaN's after a long computation, or to make sure that the values are reasonable. sfattr can be used to obtain basic statistics about the files as well. <br />
<br />
<bash><br />
sfattr < junk.rsf <br />
<br />
******************************************* <br />
rms = 1 <br />
mean = 1 <br />
2-norm = 58.3095 <br />
variance = 0 <br />
std dev = 0 <br />
max = 1 at 1 1 <br />
min = 1 at 1 1 <br />
nonzero samples = 3400 <br />
total samples = 3400 <br />
*******************************************<br />
</bash><br />
<br />
'''sfwindow - window out specific portions of a file to be used elsewhere '''<br />
<br />
SFWINDOW is one of the most versatile programs to use. Typically, it is used to select subsets of the data contained in an RSF file for computation elsewhere. Typically, you specify the data subset you want to keep using, the n, j, and f parameters which specify indices in the arrays to keep. For example if we want to keep the 15th-30th time samples for each distance in junk.rsf, we might use the following command:<br />
<br />
<bash><br />
sfwindow < junk.rsf f1=15 n1=15 j1=1 > junk-win.rsf<br />
</bash><br />
<br />
'''sftransp - transpose the dataset axes'''<br />
<br />
SFTRANSP is also very versatile, and used to reorder RSF files for other programs to be used. For example:<br />
<br />
<bash><br />
sftransp < junk.rsf plane=12 > junk-transposed.rsf<br />
</bash><br />
<br />
swaps the first and second axes, so that now the first axis is distance and the second axis is time. <br />
<br />
= Scripting = <br />
<br />
While you could use Madagascar solely from the command line, you'll probably find that it is far too tedious to do so. Especially, when you want to change the value of a parameter and then rerun the same task. To avoid some of that nastiness, you could use shell scripting to automate portions of your processing flow, but shell scripts quickly become cumbersome and are not optimal scripts (shell language is ugly). Fortunately, Madagascar comes batteries included, and has its own scripting language available for you to use called SCons. SCons is incredibly powerful as we will see in later tutorials, so please don't rush out and start writing shell scripts. Read the next few tutorials then decide whether you still want to do so.<br />
<br />
<br />
''' Back to [[Tutorial]]'''</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorial_-_Users_1_-_Command_line_interface&diff=1694Tutorial - Users 1 - Command line interface2011-04-26T05:45:13Z<p>Jgodwin: /* Interacting with files */</p>
<hr />
<div>Madagascar is designed to be used from the command line. Programmers create Madagascar programs (prefixed with the sf designation) that read and write Madagascar files. These programs are designed to be as general as possible, each one operates on any dataset provided in RSF format, provided you also provide the correct parameters and have the right type of data for the program. Thus, each Madagascar program can be used in even ways that the original developer may not have foreseen, which makes your life easier as a user!<br />
<br />
= Command line interface = <br />
Madagascar programs follow the standard UNIX conventions for reading and writing RSF files to and from STDIN and STDOUT. This is also the same convention that SeismicUnix uses, so for those of you who are SU fans, this should be an easy conversion. <br />
<br />
For example: the program sfattr allows us to get attributes about an RSF file (mean, standard deviation, min, max, etc.) To get the attributes for a pre-computed file, we might use:<br />
<bash><br />
sfattr < junk.rsf <br />
</bash><br />
which outputs:<br />
<code><br />
rms = 1.41316 <br />
mean = 0.999667 <br />
2-norm = 357.503 <br />
variance = 0.997693 <br />
std dev = 0.998846 <br />
max = 5.05567 at 36 8 27 <br />
min = -3.59936 at 18 9 6 <br />
nonzero samples = 64000 <br />
total samples = 64000 <br />
</code><br />
For an example of reading and writing an RSF file I'm going to demonstrate the use of sfwindow which is a program that allows us to select portions of an RSF file. When sfwindow is used without any additional parameters, we are able to make a copy of a file with a different filename. For example:<br />
<bash><br />
sfwindow < junk.rsf > junk2.rsf<br />
</bash><br />
gives us two files, junk.rsf and junk2.rsf which are identical but not the same file.<br />
<br />
In addition to specifying files to read in and out on the command line we can specify the parameters for each program that are necessary for it to run, or to produce the desired result. The general format for specifying parameters on the command line is key=val, where key is the name of the parameter that you want to set, and val is the value of the parameter. There are four (4) different types of values that are acceptable: int, float, boolean, or string. Going back to the window program, we can specify the number of traces or pieces of the file that we want to keep like:<br />
<br />
<bash><br />
sfwindow < junk.rsf n1=10 > junk-win.rsf<br />
</bash><br />
<br />
= Self-documentation =<br />
<br />
Of course, we can specify as many parameters as we'd like on the command line. To figure out which parameters are needed for a specific program, just type the name of the program with no input files our output files on the command line as follows:<br />
<br />
sfwindow<br />
<br />
which brings up the self-documentation, which looks something like the following:<br />
<br />
NAME<br />
sfwindow<br />
DESCRIPTION<br />
Window a portion of a dataset. <br />
SYNOPSIS<br />
sfwindow < in.rsf > out.rsf verb=n squeeze=y j#=(1,...) d#=(d1,d2,...) f#=(0,...) min#=(o1,o2,,...) n#=(0,...) max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...)<br />
PARAMETERS<br />
float d#=(d1,d2,...) sampling in #-th dimension <br />
largeint f#=(0,...) window start in #-th dimension <br />
int j#=(1,...) jump in #-th dimension <br />
float max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...) maximum in #-th dimension <br />
float min#=(o1,o2,,...) minimum in #-th dimension <br />
largeint n#=(0,...) window size in #-th dimension <br />
bool squeeze=y [y/n] if y, squeeze dimensions equal to 1 to the end <br />
bool verb=n [y/n] Verbosity flag<br />
USED IN<br />
bei/dpmv/krchdmo<br />
bei/dpmv/matt<br />
bei/dwnc/sigmoid<br />
bei/fdm/kjartjac<br />
bei/fld/cube<br />
bei/fld/shotmovie<br />
bei/fld/synmarine<br />
bei/fld/yc<br />
bei/ft1/autocor<br />
<br />
The self-documentation tells us the function of the program, as well as the parameters that are available to be specified. The parameter format is type - name=default value [options] and then a short description of the parameter. File parameters request a name of a file. For example: file=junk.rsf<br />
<br />
= Piping =<br />
<br />
Sometimes we want to chain multiple commands together without writing intermediate Madagascar RSF files in the process. Fortunately, we can do this using another standard UNIX construct, Pipes. Pipes allow us to connect the standard output from one Madagascar program to the standard input to another program without first writing to a file. For example we could do the following without pipes:<br />
<br />
sfwindow < junk.rsf > junk-win.rsf<br />
sftransp < junk-win.rsf > junk2.rsf<br />
<br />
Or we could do the equivalent using pipes on one line:<br />
<br />
sfwindow < junk.rsf | sftransp > junk2.rsf<br />
<br />
Pipes simply make these statements more compact, and allow us to reduce the number of files that we need to save to disk. If you're doing something many times over, then pipes will make your life significantly easier. I highly recommend that you use pipes! Also, you should know that you can chain as many commands together as necessary using Pipes. <br />
<br />
Note: Madagascar uses a trick to make sure that you can send as much data as you want through the pipes because a conventional UNIX pipe has a maximum amount of data that can be sent through it. To avoid this limitation, Madagascar writes the data to temporary files before sending it through a pipe.<br />
<br />
= Interacting with files =<br />
<br />
Ultimately though, 95% of your time using Madagascar on the command line will be to inspect and view files that are output by your scripts. Some of the key commands that are used to interact with files on the command line are:<br />
<br />
'''sfin - get header information''' <br />
<br />
SFIN is the most used program on the command line, because most often we simply need to check the dimensionality of our files to make sure that we have them in the correct order.<br />
<br />
<bash><br />
sfin junk.rsf<br />
<br />
junk.rsf:<br />
in="/var/tmp/junk.rsf@"<br />
esize=4 type=float form=native <br />
n1=100 d1=0.004 o1=0 label1="Time" unit1="s" <br />
n2=34 d2=0.1 o2=0 label2="Distance" unit2="km" <br />
3400 elements 13600 bytes<br />
</bash><br />
<br />
'''sfattr - get file attributes'''<br />
<br />
SFATTR is also commonly used from the command line to check files for correct values. Most often, we use sfattr to ensure that files are not filled with zeros, or with NaN's after a long computation, or to make sure that the values are reasonable. sfattr can be used to obtain basic statistics about the files as well. <br />
<br />
<bash><br />
sfattr < junk.rsf <br />
<br />
******************************************* <br />
rms = 1 <br />
mean = 1 <br />
2-norm = 58.3095 <br />
variance = 0 <br />
std dev = 0 <br />
max = 1 at 1 1 <br />
min = 1 at 1 1 <br />
nonzero samples = 3400 <br />
total samples = 3400 <br />
*******************************************<br />
</bash><br />
<br />
'''sfwindow - window out specific portions of a file to be used elsewhere '''<br />
<br />
SFWINDOW is one of the most versatile programs to use. Typically, it is used to select subsets of the data contained in an RSF file for computation elsewhere. Typically, you specify the data subset you want to keep using, the n, j, and f parameters which specify indices in the arrays to keep. For example if we want to keep the 15th-30th time samples for each distance in junk.rsf, we might use the following command:<br />
<br />
<bash><br />
sfwindow < junk.rsf f1=15 n1=15 j1=1 > junk-win.rsf<br />
</bash><br />
<br />
'''sftransp - transpose the dataset axes'''<br />
<br />
SFTRANSP is also very versatile, and used to reorder RSF files for other programs to be used. For example:<br />
<br />
<bash><br />
sftransp < junk.rsf plane=12 > junk-transposed.rsf<br />
</bash><br />
<br />
swaps the first and second axes, so that now the first axis is distance and the second axis is time. <br />
<br />
= Scripting = <br />
<br />
While you could use Madagascar solely from the command line, you'll probably find that it is far too tedious to do so. Especially, when you want to change the value of a parameter and then rerun the same task. To avoid some of that nastiness, you could use shell scripting to automate portions of your processing flow, but shell scripts quickly become cumbersome and are not optimal scripts (shell language is ugly). Fortunately, Madagascar comes batteries included, and has its own scripting language available for you to use called SCons. SCons is incredibly powerful as we will see in later tutorials, so please don't rush out and start writing shell scripts. Read the next few tutorials then decide whether you still want to do so.</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorial_-_Users_1_-_Command_line_interface&diff=1693Tutorial - Users 1 - Command line interface2011-04-26T05:32:42Z<p>Jgodwin: /* Commonly used programs */</p>
<hr />
<div>Madagascar is designed to be used from the command line. Programmers create Madagascar programs (prefixed with the sf designation) that read and write Madagascar files. These programs are designed to be as general as possible, each one operates on any dataset provided in RSF format, provided you also provide the correct parameters and have the right type of data for the program. Thus, each Madagascar program can be used in even ways that the original developer may not have foreseen, which makes your life easier as a user!<br />
<br />
= Command line interface = <br />
Madagascar programs follow the standard UNIX conventions for reading and writing RSF files to and from STDIN and STDOUT. This is also the same convention that SeismicUnix uses, so for those of you who are SU fans, this should be an easy conversion. <br />
<br />
For example: the program sfattr allows us to get attributes about an RSF file (mean, standard deviation, min, max, etc.) To get the attributes for a pre-computed file, we might use:<br />
<bash><br />
sfattr < junk.rsf <br />
</bash><br />
which outputs:<br />
<code><br />
rms = 1.41316 <br />
mean = 0.999667 <br />
2-norm = 357.503 <br />
variance = 0.997693 <br />
std dev = 0.998846 <br />
max = 5.05567 at 36 8 27 <br />
min = -3.59936 at 18 9 6 <br />
nonzero samples = 64000 <br />
total samples = 64000 <br />
</code><br />
For an example of reading and writing an RSF file I'm going to demonstrate the use of sfwindow which is a program that allows us to select portions of an RSF file. When sfwindow is used without any additional parameters, we are able to make a copy of a file with a different filename. For example:<br />
<bash><br />
sfwindow < junk.rsf > junk2.rsf<br />
</bash><br />
gives us two files, junk.rsf and junk2.rsf which are identical but not the same file.<br />
<br />
In addition to specifying files to read in and out on the command line we can specify the parameters for each program that are necessary for it to run, or to produce the desired result. The general format for specifying parameters on the command line is key=val, where key is the name of the parameter that you want to set, and val is the value of the parameter. There are four (4) different types of values that are acceptable: int, float, boolean, or string. Going back to the window program, we can specify the number of traces or pieces of the file that we want to keep like:<br />
<br />
<bash><br />
sfwindow < junk.rsf n1=10 > junk-win.rsf<br />
</bash><br />
<br />
= Self-documentation =<br />
<br />
Of course, we can specify as many parameters as we'd like on the command line. To figure out which parameters are needed for a specific program, just type the name of the program with no input files our output files on the command line as follows:<br />
<br />
sfwindow<br />
<br />
which brings up the self-documentation, which looks something like the following:<br />
<br />
NAME<br />
sfwindow<br />
DESCRIPTION<br />
Window a portion of a dataset. <br />
SYNOPSIS<br />
sfwindow < in.rsf > out.rsf verb=n squeeze=y j#=(1,...) d#=(d1,d2,...) f#=(0,...) min#=(o1,o2,,...) n#=(0,...) max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...)<br />
PARAMETERS<br />
float d#=(d1,d2,...) sampling in #-th dimension <br />
largeint f#=(0,...) window start in #-th dimension <br />
int j#=(1,...) jump in #-th dimension <br />
float max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...) maximum in #-th dimension <br />
float min#=(o1,o2,,...) minimum in #-th dimension <br />
largeint n#=(0,...) window size in #-th dimension <br />
bool squeeze=y [y/n] if y, squeeze dimensions equal to 1 to the end <br />
bool verb=n [y/n] Verbosity flag<br />
USED IN<br />
bei/dpmv/krchdmo<br />
bei/dpmv/matt<br />
bei/dwnc/sigmoid<br />
bei/fdm/kjartjac<br />
bei/fld/cube<br />
bei/fld/shotmovie<br />
bei/fld/synmarine<br />
bei/fld/yc<br />
bei/ft1/autocor<br />
<br />
The self-documentation tells us the function of the program, as well as the parameters that are available to be specified. The parameter format is type - name=default value [options] and then a short description of the parameter. File parameters request a name of a file. For example: file=junk.rsf<br />
<br />
= Piping =<br />
<br />
Sometimes we want to chain multiple commands together without writing intermediate Madagascar RSF files in the process. Fortunately, we can do this using another standard UNIX construct, Pipes. Pipes allow us to connect the standard output from one Madagascar program to the standard input to another program without first writing to a file. For example we could do the following without pipes:<br />
<br />
sfwindow < junk.rsf > junk-win.rsf<br />
sftransp < junk-win.rsf > junk2.rsf<br />
<br />
Or we could do the equivalent using pipes on one line:<br />
<br />
sfwindow < junk.rsf | sftransp > junk2.rsf<br />
<br />
Pipes simply make these statements more compact, and allow us to reduce the number of files that we need to save to disk. If you're doing something many times over, then pipes will make your life significantly easier. I highly recommend that you use pipes! Also, you should know that you can chain as many commands together as necessary using Pipes. <br />
<br />
Note: Madagascar uses a trick to make sure that you can send as much data as you want through the pipes because a conventional UNIX pipe has a maximum amount of data that can be sent through it. To avoid this limitation, Madagascar writes the data to temporary files before sending it through a pipe.<br />
<br />
= Interacting with files =</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorial_-_Users_1_-_Command_line_interface&diff=1692Tutorial - Users 1 - Command line interface2011-04-26T05:31:40Z<p>Jgodwin: /* Commonly used programs */</p>
<hr />
<div>Madagascar is designed to be used from the command line. Programmers create Madagascar programs (prefixed with the sf designation) that read and write Madagascar files. These programs are designed to be as general as possible, each one operates on any dataset provided in RSF format, provided you also provide the correct parameters and have the right type of data for the program. Thus, each Madagascar program can be used in even ways that the original developer may not have foreseen, which makes your life easier as a user!<br />
<br />
= Command line interface = <br />
Madagascar programs follow the standard UNIX conventions for reading and writing RSF files to and from STDIN and STDOUT. This is also the same convention that SeismicUnix uses, so for those of you who are SU fans, this should be an easy conversion. <br />
<br />
For example: the program sfattr allows us to get attributes about an RSF file (mean, standard deviation, min, max, etc.) To get the attributes for a pre-computed file, we might use:<br />
<bash><br />
sfattr < junk.rsf <br />
</bash><br />
which outputs:<br />
<code><br />
rms = 1.41316 <br />
mean = 0.999667 <br />
2-norm = 357.503 <br />
variance = 0.997693 <br />
std dev = 0.998846 <br />
max = 5.05567 at 36 8 27 <br />
min = -3.59936 at 18 9 6 <br />
nonzero samples = 64000 <br />
total samples = 64000 <br />
</code><br />
For an example of reading and writing an RSF file I'm going to demonstrate the use of sfwindow which is a program that allows us to select portions of an RSF file. When sfwindow is used without any additional parameters, we are able to make a copy of a file with a different filename. For example:<br />
<bash><br />
sfwindow < junk.rsf > junk2.rsf<br />
</bash><br />
gives us two files, junk.rsf and junk2.rsf which are identical but not the same file.<br />
<br />
In addition to specifying files to read in and out on the command line we can specify the parameters for each program that are necessary for it to run, or to produce the desired result. The general format for specifying parameters on the command line is key=val, where key is the name of the parameter that you want to set, and val is the value of the parameter. There are four (4) different types of values that are acceptable: int, float, boolean, or string. Going back to the window program, we can specify the number of traces or pieces of the file that we want to keep like:<br />
<br />
<bash><br />
sfwindow < junk.rsf n1=10 > junk-win.rsf<br />
</bash><br />
<br />
= Self-documentation =<br />
<br />
Of course, we can specify as many parameters as we'd like on the command line. To figure out which parameters are needed for a specific program, just type the name of the program with no input files our output files on the command line as follows:<br />
<br />
sfwindow<br />
<br />
which brings up the self-documentation, which looks something like the following:<br />
<br />
NAME<br />
sfwindow<br />
DESCRIPTION<br />
Window a portion of a dataset. <br />
SYNOPSIS<br />
sfwindow < in.rsf > out.rsf verb=n squeeze=y j#=(1,...) d#=(d1,d2,...) f#=(0,...) min#=(o1,o2,,...) n#=(0,...) max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...)<br />
PARAMETERS<br />
float d#=(d1,d2,...) sampling in #-th dimension <br />
largeint f#=(0,...) window start in #-th dimension <br />
int j#=(1,...) jump in #-th dimension <br />
float max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...) maximum in #-th dimension <br />
float min#=(o1,o2,,...) minimum in #-th dimension <br />
largeint n#=(0,...) window size in #-th dimension <br />
bool squeeze=y [y/n] if y, squeeze dimensions equal to 1 to the end <br />
bool verb=n [y/n] Verbosity flag<br />
USED IN<br />
bei/dpmv/krchdmo<br />
bei/dpmv/matt<br />
bei/dwnc/sigmoid<br />
bei/fdm/kjartjac<br />
bei/fld/cube<br />
bei/fld/shotmovie<br />
bei/fld/synmarine<br />
bei/fld/yc<br />
bei/ft1/autocor<br />
<br />
The self-documentation tells us the function of the program, as well as the parameters that are available to be specified. The parameter format is type - name=default value [options] and then a short description of the parameter. File parameters request a name of a file. For example: file=junk.rsf<br />
<br />
= Piping =<br />
<br />
Sometimes we want to chain multiple commands together without writing intermediate Madagascar RSF files in the process. Fortunately, we can do this using another standard UNIX construct, Pipes. Pipes allow us to connect the standard output from one Madagascar program to the standard input to another program without first writing to a file. For example we could do the following without pipes:<br />
<br />
sfwindow < junk.rsf > junk-win.rsf<br />
sftransp < junk-win.rsf > junk2.rsf<br />
<br />
Or we could do the equivalent using pipes on one line:<br />
<br />
sfwindow < junk.rsf | sftransp > junk2.rsf<br />
<br />
Pipes simply make these statements more compact, and allow us to reduce the number of files that we need to save to disk. If you're doing something many times over, then pipes will make your life significantly easier. I highly recommend that you use pipes! Also, you should know that you can chain as many commands together as necessary using Pipes. <br />
<br />
Note: Madagascar uses a trick to make sure that you can send as much data as you want through the pipes because a conventional UNIX pipe has a maximum amount of data that can be sent through it. To avoid this limitation, Madagascar writes the data to temporary files before sending it through a pipe.<br />
<br />
= Commonly used programs =<br />
<br />
Here's a short list of commonly used programs, their usage:<br />
<br />
sfwindow - window out portions of a dataset<br />
sftransp - transpose the axes of a dataset<br />
sfin - see the shape of a file (axes)<br />
sfattr - common attributes of files<br />
sfspike - create files<br />
sfmath - basic mathematical operations (add subtract multiply)<br />
sfadd - like sfmath but easier to use<br />
sfgrey - raster plots<br />
sfgraph - line plots<br />
sfwiggle - wiggle plots<br />
<br />
For more information see [[Guide_to_madagascar_programs | Program guide]].<br />
<br />
= Interacting with files =</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorial_-_Users_1_-_Command_line_interface&diff=1691Tutorial - Users 1 - Command line interface2011-04-26T05:31:03Z<p>Jgodwin: /* Commonly used programs */</p>
<hr />
<div>Madagascar is designed to be used from the command line. Programmers create Madagascar programs (prefixed with the sf designation) that read and write Madagascar files. These programs are designed to be as general as possible, each one operates on any dataset provided in RSF format, provided you also provide the correct parameters and have the right type of data for the program. Thus, each Madagascar program can be used in even ways that the original developer may not have foreseen, which makes your life easier as a user!<br />
<br />
= Command line interface = <br />
Madagascar programs follow the standard UNIX conventions for reading and writing RSF files to and from STDIN and STDOUT. This is also the same convention that SeismicUnix uses, so for those of you who are SU fans, this should be an easy conversion. <br />
<br />
For example: the program sfattr allows us to get attributes about an RSF file (mean, standard deviation, min, max, etc.) To get the attributes for a pre-computed file, we might use:<br />
<bash><br />
sfattr < junk.rsf <br />
</bash><br />
which outputs:<br />
<code><br />
rms = 1.41316 <br />
mean = 0.999667 <br />
2-norm = 357.503 <br />
variance = 0.997693 <br />
std dev = 0.998846 <br />
max = 5.05567 at 36 8 27 <br />
min = -3.59936 at 18 9 6 <br />
nonzero samples = 64000 <br />
total samples = 64000 <br />
</code><br />
For an example of reading and writing an RSF file I'm going to demonstrate the use of sfwindow which is a program that allows us to select portions of an RSF file. When sfwindow is used without any additional parameters, we are able to make a copy of a file with a different filename. For example:<br />
<bash><br />
sfwindow < junk.rsf > junk2.rsf<br />
</bash><br />
gives us two files, junk.rsf and junk2.rsf which are identical but not the same file.<br />
<br />
In addition to specifying files to read in and out on the command line we can specify the parameters for each program that are necessary for it to run, or to produce the desired result. The general format for specifying parameters on the command line is key=val, where key is the name of the parameter that you want to set, and val is the value of the parameter. There are four (4) different types of values that are acceptable: int, float, boolean, or string. Going back to the window program, we can specify the number of traces or pieces of the file that we want to keep like:<br />
<br />
<bash><br />
sfwindow < junk.rsf n1=10 > junk-win.rsf<br />
</bash><br />
<br />
= Self-documentation =<br />
<br />
Of course, we can specify as many parameters as we'd like on the command line. To figure out which parameters are needed for a specific program, just type the name of the program with no input files our output files on the command line as follows:<br />
<br />
sfwindow<br />
<br />
which brings up the self-documentation, which looks something like the following:<br />
<br />
NAME<br />
sfwindow<br />
DESCRIPTION<br />
Window a portion of a dataset. <br />
SYNOPSIS<br />
sfwindow < in.rsf > out.rsf verb=n squeeze=y j#=(1,...) d#=(d1,d2,...) f#=(0,...) min#=(o1,o2,,...) n#=(0,...) max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...)<br />
PARAMETERS<br />
float d#=(d1,d2,...) sampling in #-th dimension <br />
largeint f#=(0,...) window start in #-th dimension <br />
int j#=(1,...) jump in #-th dimension <br />
float max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...) maximum in #-th dimension <br />
float min#=(o1,o2,,...) minimum in #-th dimension <br />
largeint n#=(0,...) window size in #-th dimension <br />
bool squeeze=y [y/n] if y, squeeze dimensions equal to 1 to the end <br />
bool verb=n [y/n] Verbosity flag<br />
USED IN<br />
bei/dpmv/krchdmo<br />
bei/dpmv/matt<br />
bei/dwnc/sigmoid<br />
bei/fdm/kjartjac<br />
bei/fld/cube<br />
bei/fld/shotmovie<br />
bei/fld/synmarine<br />
bei/fld/yc<br />
bei/ft1/autocor<br />
<br />
The self-documentation tells us the function of the program, as well as the parameters that are available to be specified. The parameter format is type - name=default value [options] and then a short description of the parameter. File parameters request a name of a file. For example: file=junk.rsf<br />
<br />
= Piping =<br />
<br />
Sometimes we want to chain multiple commands together without writing intermediate Madagascar RSF files in the process. Fortunately, we can do this using another standard UNIX construct, Pipes. Pipes allow us to connect the standard output from one Madagascar program to the standard input to another program without first writing to a file. For example we could do the following without pipes:<br />
<br />
sfwindow < junk.rsf > junk-win.rsf<br />
sftransp < junk-win.rsf > junk2.rsf<br />
<br />
Or we could do the equivalent using pipes on one line:<br />
<br />
sfwindow < junk.rsf | sftransp > junk2.rsf<br />
<br />
Pipes simply make these statements more compact, and allow us to reduce the number of files that we need to save to disk. If you're doing something many times over, then pipes will make your life significantly easier. I highly recommend that you use pipes! Also, you should know that you can chain as many commands together as necessary using Pipes. <br />
<br />
Note: Madagascar uses a trick to make sure that you can send as much data as you want through the pipes because a conventional UNIX pipe has a maximum amount of data that can be sent through it. To avoid this limitation, Madagascar writes the data to temporary files before sending it through a pipe.<br />
<br />
= Commonly used programs =<br />
<br />
Here's a short list of commonly used programs, their usage:<br />
<br />
sfwindow - window out portions of a dataset<br />
sftransp - transpose the axes of a dataset<br />
sfin - see the shape of a file (axes)<br />
sfattr - common attributes of files<br />
sfspike - create files<br />
sfmath - basic mathematical operations (add subtract multiply)<br />
sfadd - like sfmath but easier to use<br />
sfgrey - raster plots<br />
sfgraph - line plots<br />
sfwiggle - wiggle plots<br />
<br />
For more information see [[Guide_to_madagascar_programs | Program guide]].<br />
<br />
= Interacting with files =</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorial_-_Users_1_-_Command_line_interface&diff=1690Tutorial - Users 1 - Command line interface2011-04-26T05:30:33Z<p>Jgodwin: /* Piping */</p>
<hr />
<div>Madagascar is designed to be used from the command line. Programmers create Madagascar programs (prefixed with the sf designation) that read and write Madagascar files. These programs are designed to be as general as possible, each one operates on any dataset provided in RSF format, provided you also provide the correct parameters and have the right type of data for the program. Thus, each Madagascar program can be used in even ways that the original developer may not have foreseen, which makes your life easier as a user!<br />
<br />
= Command line interface = <br />
Madagascar programs follow the standard UNIX conventions for reading and writing RSF files to and from STDIN and STDOUT. This is also the same convention that SeismicUnix uses, so for those of you who are SU fans, this should be an easy conversion. <br />
<br />
For example: the program sfattr allows us to get attributes about an RSF file (mean, standard deviation, min, max, etc.) To get the attributes for a pre-computed file, we might use:<br />
<bash><br />
sfattr < junk.rsf <br />
</bash><br />
which outputs:<br />
<code><br />
rms = 1.41316 <br />
mean = 0.999667 <br />
2-norm = 357.503 <br />
variance = 0.997693 <br />
std dev = 0.998846 <br />
max = 5.05567 at 36 8 27 <br />
min = -3.59936 at 18 9 6 <br />
nonzero samples = 64000 <br />
total samples = 64000 <br />
</code><br />
For an example of reading and writing an RSF file I'm going to demonstrate the use of sfwindow which is a program that allows us to select portions of an RSF file. When sfwindow is used without any additional parameters, we are able to make a copy of a file with a different filename. For example:<br />
<bash><br />
sfwindow < junk.rsf > junk2.rsf<br />
</bash><br />
gives us two files, junk.rsf and junk2.rsf which are identical but not the same file.<br />
<br />
In addition to specifying files to read in and out on the command line we can specify the parameters for each program that are necessary for it to run, or to produce the desired result. The general format for specifying parameters on the command line is key=val, where key is the name of the parameter that you want to set, and val is the value of the parameter. There are four (4) different types of values that are acceptable: int, float, boolean, or string. Going back to the window program, we can specify the number of traces or pieces of the file that we want to keep like:<br />
<br />
<bash><br />
sfwindow < junk.rsf n1=10 > junk-win.rsf<br />
</bash><br />
<br />
= Self-documentation =<br />
<br />
Of course, we can specify as many parameters as we'd like on the command line. To figure out which parameters are needed for a specific program, just type the name of the program with no input files our output files on the command line as follows:<br />
<br />
sfwindow<br />
<br />
which brings up the self-documentation, which looks something like the following:<br />
<br />
NAME<br />
sfwindow<br />
DESCRIPTION<br />
Window a portion of a dataset. <br />
SYNOPSIS<br />
sfwindow < in.rsf > out.rsf verb=n squeeze=y j#=(1,...) d#=(d1,d2,...) f#=(0,...) min#=(o1,o2,,...) n#=(0,...) max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...)<br />
PARAMETERS<br />
float d#=(d1,d2,...) sampling in #-th dimension <br />
largeint f#=(0,...) window start in #-th dimension <br />
int j#=(1,...) jump in #-th dimension <br />
float max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...) maximum in #-th dimension <br />
float min#=(o1,o2,,...) minimum in #-th dimension <br />
largeint n#=(0,...) window size in #-th dimension <br />
bool squeeze=y [y/n] if y, squeeze dimensions equal to 1 to the end <br />
bool verb=n [y/n] Verbosity flag<br />
USED IN<br />
bei/dpmv/krchdmo<br />
bei/dpmv/matt<br />
bei/dwnc/sigmoid<br />
bei/fdm/kjartjac<br />
bei/fld/cube<br />
bei/fld/shotmovie<br />
bei/fld/synmarine<br />
bei/fld/yc<br />
bei/ft1/autocor<br />
<br />
The self-documentation tells us the function of the program, as well as the parameters that are available to be specified. The parameter format is type - name=default value [options] and then a short description of the parameter. File parameters request a name of a file. For example: file=junk.rsf<br />
<br />
= Piping =<br />
<br />
Sometimes we want to chain multiple commands together without writing intermediate Madagascar RSF files in the process. Fortunately, we can do this using another standard UNIX construct, Pipes. Pipes allow us to connect the standard output from one Madagascar program to the standard input to another program without first writing to a file. For example we could do the following without pipes:<br />
<br />
sfwindow < junk.rsf > junk-win.rsf<br />
sftransp < junk-win.rsf > junk2.rsf<br />
<br />
Or we could do the equivalent using pipes on one line:<br />
<br />
sfwindow < junk.rsf | sftransp > junk2.rsf<br />
<br />
Pipes simply make these statements more compact, and allow us to reduce the number of files that we need to save to disk. If you're doing something many times over, then pipes will make your life significantly easier. I highly recommend that you use pipes! Also, you should know that you can chain as many commands together as necessary using Pipes. <br />
<br />
Note: Madagascar uses a trick to make sure that you can send as much data as you want through the pipes because a conventional UNIX pipe has a maximum amount of data that can be sent through it. To avoid this limitation, Madagascar writes the data to temporary files before sending it through a pipe.<br />
<br />
= Commonly used programs =<br />
<br />
Here's a short list of commonly used programs, their usage:<br />
<br />
sfwindow - window out portions of a dataset<br />
sftransp - transpose the axes of a dataset<br />
sfin - see the shape of a file (axes)<br />
sfattr - common attributes of files<br />
sfspike - create files<br />
sfmath - basic mathematical operations (add subtract multiply)<br />
sfadd - like sfmath but easier to use<br />
sfgrey - raster plots<br />
sfgraph - line plots<br />
sfwiggle - wiggle plots<br />
<br />
For more information see [[Guide_to_madagascar_programs | Program guide]].<br />
<br />
= Interacting with files =</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorial_-_Users_1_-_Command_line_interface&diff=1689Tutorial - Users 1 - Command line interface2011-04-26T05:30:11Z<p>Jgodwin: /* Command line interface */</p>
<hr />
<div>Madagascar is designed to be used from the command line. Programmers create Madagascar programs (prefixed with the sf designation) that read and write Madagascar files. These programs are designed to be as general as possible, each one operates on any dataset provided in RSF format, provided you also provide the correct parameters and have the right type of data for the program. Thus, each Madagascar program can be used in even ways that the original developer may not have foreseen, which makes your life easier as a user!<br />
<br />
= Command line interface = <br />
Madagascar programs follow the standard UNIX conventions for reading and writing RSF files to and from STDIN and STDOUT. This is also the same convention that SeismicUnix uses, so for those of you who are SU fans, this should be an easy conversion. <br />
<br />
For example: the program sfattr allows us to get attributes about an RSF file (mean, standard deviation, min, max, etc.) To get the attributes for a pre-computed file, we might use:<br />
<bash><br />
sfattr < junk.rsf <br />
</bash><br />
which outputs:<br />
<code><br />
rms = 1.41316 <br />
mean = 0.999667 <br />
2-norm = 357.503 <br />
variance = 0.997693 <br />
std dev = 0.998846 <br />
max = 5.05567 at 36 8 27 <br />
min = -3.59936 at 18 9 6 <br />
nonzero samples = 64000 <br />
total samples = 64000 <br />
</code><br />
For an example of reading and writing an RSF file I'm going to demonstrate the use of sfwindow which is a program that allows us to select portions of an RSF file. When sfwindow is used without any additional parameters, we are able to make a copy of a file with a different filename. For example:<br />
<bash><br />
sfwindow < junk.rsf > junk2.rsf<br />
</bash><br />
gives us two files, junk.rsf and junk2.rsf which are identical but not the same file.<br />
<br />
In addition to specifying files to read in and out on the command line we can specify the parameters for each program that are necessary for it to run, or to produce the desired result. The general format for specifying parameters on the command line is key=val, where key is the name of the parameter that you want to set, and val is the value of the parameter. There are four (4) different types of values that are acceptable: int, float, boolean, or string. Going back to the window program, we can specify the number of traces or pieces of the file that we want to keep like:<br />
<br />
<bash><br />
sfwindow < junk.rsf n1=10 > junk-win.rsf<br />
</bash><br />
<br />
= Self-documentation =<br />
<br />
Of course, we can specify as many parameters as we'd like on the command line. To figure out which parameters are needed for a specific program, just type the name of the program with no input files our output files on the command line as follows:<br />
<br />
sfwindow<br />
<br />
which brings up the self-documentation, which looks something like the following:<br />
<br />
NAME<br />
sfwindow<br />
DESCRIPTION<br />
Window a portion of a dataset. <br />
SYNOPSIS<br />
sfwindow < in.rsf > out.rsf verb=n squeeze=y j#=(1,...) d#=(d1,d2,...) f#=(0,...) min#=(o1,o2,,...) n#=(0,...) max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...)<br />
PARAMETERS<br />
float d#=(d1,d2,...) sampling in #-th dimension <br />
largeint f#=(0,...) window start in #-th dimension <br />
int j#=(1,...) jump in #-th dimension <br />
float max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...) maximum in #-th dimension <br />
float min#=(o1,o2,,...) minimum in #-th dimension <br />
largeint n#=(0,...) window size in #-th dimension <br />
bool squeeze=y [y/n] if y, squeeze dimensions equal to 1 to the end <br />
bool verb=n [y/n] Verbosity flag<br />
USED IN<br />
bei/dpmv/krchdmo<br />
bei/dpmv/matt<br />
bei/dwnc/sigmoid<br />
bei/fdm/kjartjac<br />
bei/fld/cube<br />
bei/fld/shotmovie<br />
bei/fld/synmarine<br />
bei/fld/yc<br />
bei/ft1/autocor<br />
<br />
The self-documentation tells us the function of the program, as well as the parameters that are available to be specified. The parameter format is type - name=default value [options] and then a short description of the parameter. File parameters request a name of a file. For example: file=junk.rsf<br />
<br />
= Piping =<br />
<br />
Sometimes we want to chain multiple commands together without writing intermediate Madagascar RSF files in the process. Fortunately, we can do this using another standard UNIX construct, Pipes. Pipes allow us to connect the standard output from one Madagascar program to the standard input to another program without first writing to a file. For example we could do the following without pipes:<br />
<br />
sfwindow < junk.rsf > junk-win.rsf<br />
sftransp < junk-win.rsf > junk2.rsf<br />
<br />
Or we could do the equivalent using pipes on one line:<br />
<br />
sfwindow < junk.rsf | sftransp > junk2.rsf<br />
<br />
Pipes simply make these statements more compact, and allow us to reduce the number of files that we need to save to disk. If you're doing something many times over, then pipes will make your life significantly easier. I highly recommend that you use pipes! Also, you should know that you can chain as many commands together as necessary using Pipes. <br />
<br />
Note: Madagascar uses a trick to make sure that you can send as much data as you want through the pipes because a conventional UNIX pipe has a maximum amount of data that can be sent through it. To avoid this limitation, Madagascar writes the data to temporary files before sending it through a pipe. <br />
<br />
= Commonly used programs =<br />
<br />
Here's a short list of commonly used programs, their usage:<br />
<br />
sfwindow - window out portions of a dataset<br />
sftransp - transpose the axes of a dataset<br />
sfin - see the shape of a file (axes)<br />
sfattr - common attributes of files<br />
sfspike - create files<br />
sfmath - basic mathematical operations (add subtract multiply)<br />
sfadd - like sfmath but easier to use<br />
sfgrey - raster plots<br />
sfgraph - line plots<br />
sfwiggle - wiggle plots<br />
<br />
For more information see [[Guide_to_madagascar_programs | Program guide]].<br />
<br />
= Interacting with files =</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorial_-_Users_1_-_Command_line_interface&diff=1688Tutorial - Users 1 - Command line interface2011-04-26T05:29:39Z<p>Jgodwin: /* Command line interface */</p>
<hr />
<div>Madagascar is designed to be used from the command line. Programmers create Madagascar programs (prefixed with the sf designation) that read and write Madagascar files. These programs are designed to be as general as possible, each one operates on any dataset provided in RSF format, provided you also provide the correct parameters and have the right type of data for the program. Thus, each Madagascar program can be used in even ways that the original developer may not have foreseen, which makes your life easier as a user!<br />
<br />
= Command line interface = <br />
Madagascar programs follow the standard UNIX conventions for reading and writing RSF files to and from STDIN and STDOUT. This is also the same convention that SeismicUnix uses, so for those of you who are SU fans, this should be an easy conversion. <br />
<br />
For example: the program sfattr allows us to get attributes about an RSF file (mean, standard deviation, min, max, etc.) To get the attributes for a pre-computed file, we might use:<br />
<bash><br />
sfattr < junk.rsf <br />
</bash><br />
which outputs:<br />
<code><br />
rms = 1.41316 <br />
mean = 0.999667 <br />
2-norm = 357.503 <br />
variance = 0.997693 <br />
std dev = 0.998846 <br />
max = 5.05567 at 36 8 27 <br />
min = -3.59936 at 18 9 6 <br />
nonzero samples = 64000 <br />
total samples = 64000 <br />
</code><br />
For an example of reading and writing an RSF file I'm going to demonstrate the use of sfwindow which is a program that allows us to select portions of an RSF file. When sfwindow is used without any additional parameters, we are able to make a copy of a file with a different filename. For example:<br />
<br />
sfwindow < junk.rsf > junk2.rsf<br />
<br />
gives us two files, junk.rsf and junk2.rsf which are identical but not the same file.<br />
<br />
In addition to specifying files to read in and out on the command line we can specify the parameters for each program that are necessary for it to run, or to produce the desired result. The general format for specifying parameters on the command line is key=val, where key is the name of the parameter that you want to set, and val is the value of the parameter. There are four (4) different types of values that are acceptable: int, float, boolean, or string. Going back to the window program, we can specify the number of traces or pieces of the file that we want to keep like:<br />
<br />
sfwindow < junk.rsf n1=10 > junk-win.rsf<br />
<br />
= Self-documentation =<br />
<br />
Of course, we can specify as many parameters as we'd like on the command line. To figure out which parameters are needed for a specific program, just type the name of the program with no input files our output files on the command line as follows:<br />
<br />
sfwindow<br />
<br />
which brings up the self-documentation, which looks something like the following:<br />
<br />
NAME<br />
sfwindow<br />
DESCRIPTION<br />
Window a portion of a dataset. <br />
SYNOPSIS<br />
sfwindow < in.rsf > out.rsf verb=n squeeze=y j#=(1,...) d#=(d1,d2,...) f#=(0,...) min#=(o1,o2,,...) n#=(0,...) max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...)<br />
PARAMETERS<br />
float d#=(d1,d2,...) sampling in #-th dimension <br />
largeint f#=(0,...) window start in #-th dimension <br />
int j#=(1,...) jump in #-th dimension <br />
float max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...) maximum in #-th dimension <br />
float min#=(o1,o2,,...) minimum in #-th dimension <br />
largeint n#=(0,...) window size in #-th dimension <br />
bool squeeze=y [y/n] if y, squeeze dimensions equal to 1 to the end <br />
bool verb=n [y/n] Verbosity flag<br />
USED IN<br />
bei/dpmv/krchdmo<br />
bei/dpmv/matt<br />
bei/dwnc/sigmoid<br />
bei/fdm/kjartjac<br />
bei/fld/cube<br />
bei/fld/shotmovie<br />
bei/fld/synmarine<br />
bei/fld/yc<br />
bei/ft1/autocor<br />
<br />
The self-documentation tells us the function of the program, as well as the parameters that are available to be specified. The parameter format is type - name=default value [options] and then a short description of the parameter. File parameters request a name of a file. For example: file=junk.rsf<br />
<br />
= Piping =<br />
<br />
Sometimes we want to chain multiple commands together without writing intermediate Madagascar RSF files in the process. Fortunately, we can do this using another standard UNIX construct, Pipes. Pipes allow us to connect the standard output from one Madagascar program to the standard input to another program without first writing to a file. For example we could do the following without pipes:<br />
<br />
sfwindow < junk.rsf > junk-win.rsf<br />
sftransp < junk-win.rsf > junk2.rsf<br />
<br />
Or we could do the equivalent using pipes on one line:<br />
<br />
sfwindow < junk.rsf | sftransp > junk2.rsf<br />
<br />
Pipes simply make these statements more compact, and allow us to reduce the number of files that we need to save to disk. If you're doing something many times over, then pipes will make your life significantly easier. I highly recommend that you use pipes! Also, you should know that you can chain as many commands together as necessary using Pipes. <br />
<br />
Note: Madagascar uses a trick to make sure that you can send as much data as you want through the pipes because a conventional UNIX pipe has a maximum amount of data that can be sent through it. To avoid this limitation, Madagascar writes the data to temporary files before sending it through a pipe. <br />
<br />
= Commonly used programs =<br />
<br />
Here's a short list of commonly used programs, their usage:<br />
<br />
sfwindow - window out portions of a dataset<br />
sftransp - transpose the axes of a dataset<br />
sfin - see the shape of a file (axes)<br />
sfattr - common attributes of files<br />
sfspike - create files<br />
sfmath - basic mathematical operations (add subtract multiply)<br />
sfadd - like sfmath but easier to use<br />
sfgrey - raster plots<br />
sfgraph - line plots<br />
sfwiggle - wiggle plots<br />
<br />
For more information see [[Guide_to_madagascar_programs | Program guide]].<br />
<br />
= Interacting with files =</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorial_-_Users_1_-_Command_line_interface&diff=1687Tutorial - Users 1 - Command line interface2011-04-26T05:29:12Z<p>Jgodwin: /* Command line interface */</p>
<hr />
<div>Madagascar is designed to be used from the command line. Programmers create Madagascar programs (prefixed with the sf designation) that read and write Madagascar files. These programs are designed to be as general as possible, each one operates on any dataset provided in RSF format, provided you also provide the correct parameters and have the right type of data for the program. Thus, each Madagascar program can be used in even ways that the original developer may not have foreseen, which makes your life easier as a user!<br />
<br />
= Command line interface = <br />
Madagascar programs follow the standard UNIX conventions for reading and writing RSF files to and from STDIN and STDOUT. This is also the same convention that SeismicUnix uses, so for those of you who are SU fans, this should be an easy conversion. <br />
<br />
For example: the program sfattr allows us to get attributes about an RSF file (mean, standard deviation, min, max, etc.) To get the attributes for a pre-computed file, we might use:<br />
<br />
sfattr < junk.rsf <br />
<br />
which outputs:<br />
<code><br />
rms = 1.41316 <br />
mean = 0.999667 <br />
2-norm = 357.503 <br />
variance = 0.997693 <br />
std dev = 0.998846 <br />
max = 5.05567 at 36 8 27 <br />
min = -3.59936 at 18 9 6 <br />
nonzero samples = 64000 <br />
total samples = 64000 <br />
</code><br />
For an example of reading and writing an RSF file I'm going to demonstrate the use of sfwindow which is a program that allows us to select portions of an RSF file. When sfwindow is used without any additional parameters, we are able to make a copy of a file with a different filename. For example:<br />
<br />
sfwindow < junk.rsf > junk2.rsf<br />
<br />
gives us two files, junk.rsf and junk2.rsf which are identical but not the same file.<br />
<br />
In addition to specifying files to read in and out on the command line we can specify the parameters for each program that are necessary for it to run, or to produce the desired result. The general format for specifying parameters on the command line is key=val, where key is the name of the parameter that you want to set, and val is the value of the parameter. There are four (4) different types of values that are acceptable: int, float, boolean, or string. Going back to the window program, we can specify the number of traces or pieces of the file that we want to keep like:<br />
<br />
sfwindow < junk.rsf n1=10 > junk-win.rsf<br />
<br />
= Self-documentation =<br />
<br />
Of course, we can specify as many parameters as we'd like on the command line. To figure out which parameters are needed for a specific program, just type the name of the program with no input files our output files on the command line as follows:<br />
<br />
sfwindow<br />
<br />
which brings up the self-documentation, which looks something like the following:<br />
<br />
NAME<br />
sfwindow<br />
DESCRIPTION<br />
Window a portion of a dataset. <br />
SYNOPSIS<br />
sfwindow < in.rsf > out.rsf verb=n squeeze=y j#=(1,...) d#=(d1,d2,...) f#=(0,...) min#=(o1,o2,,...) n#=(0,...) max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...)<br />
PARAMETERS<br />
float d#=(d1,d2,...) sampling in #-th dimension <br />
largeint f#=(0,...) window start in #-th dimension <br />
int j#=(1,...) jump in #-th dimension <br />
float max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...) maximum in #-th dimension <br />
float min#=(o1,o2,,...) minimum in #-th dimension <br />
largeint n#=(0,...) window size in #-th dimension <br />
bool squeeze=y [y/n] if y, squeeze dimensions equal to 1 to the end <br />
bool verb=n [y/n] Verbosity flag<br />
USED IN<br />
bei/dpmv/krchdmo<br />
bei/dpmv/matt<br />
bei/dwnc/sigmoid<br />
bei/fdm/kjartjac<br />
bei/fld/cube<br />
bei/fld/shotmovie<br />
bei/fld/synmarine<br />
bei/fld/yc<br />
bei/ft1/autocor<br />
<br />
The self-documentation tells us the function of the program, as well as the parameters that are available to be specified. The parameter format is type - name=default value [options] and then a short description of the parameter. File parameters request a name of a file. For example: file=junk.rsf<br />
<br />
= Piping =<br />
<br />
Sometimes we want to chain multiple commands together without writing intermediate Madagascar RSF files in the process. Fortunately, we can do this using another standard UNIX construct, Pipes. Pipes allow us to connect the standard output from one Madagascar program to the standard input to another program without first writing to a file. For example we could do the following without pipes:<br />
<br />
sfwindow < junk.rsf > junk-win.rsf<br />
sftransp < junk-win.rsf > junk2.rsf<br />
<br />
Or we could do the equivalent using pipes on one line:<br />
<br />
sfwindow < junk.rsf | sftransp > junk2.rsf<br />
<br />
Pipes simply make these statements more compact, and allow us to reduce the number of files that we need to save to disk. If you're doing something many times over, then pipes will make your life significantly easier. I highly recommend that you use pipes! Also, you should know that you can chain as many commands together as necessary using Pipes. <br />
<br />
Note: Madagascar uses a trick to make sure that you can send as much data as you want through the pipes because a conventional UNIX pipe has a maximum amount of data that can be sent through it. To avoid this limitation, Madagascar writes the data to temporary files before sending it through a pipe. <br />
<br />
= Commonly used programs =<br />
<br />
Here's a short list of commonly used programs, their usage:<br />
<br />
sfwindow - window out portions of a dataset<br />
sftransp - transpose the axes of a dataset<br />
sfin - see the shape of a file (axes)<br />
sfattr - common attributes of files<br />
sfspike - create files<br />
sfmath - basic mathematical operations (add subtract multiply)<br />
sfadd - like sfmath but easier to use<br />
sfgrey - raster plots<br />
sfgraph - line plots<br />
sfwiggle - wiggle plots<br />
<br />
For more information see [[Guide_to_madagascar_programs | Program guide]].<br />
<br />
= Interacting with files =</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorial_-_Users_1_-_Command_line_interface&diff=1685Tutorial - Users 1 - Command line interface2011-04-26T05:28:46Z<p>Jgodwin: /* Command line interface */</p>
<hr />
<div>Madagascar is designed to be used from the command line. Programmers create Madagascar programs (prefixed with the sf designation) that read and write Madagascar files. These programs are designed to be as general as possible, each one operates on any dataset provided in RSF format, provided you also provide the correct parameters and have the right type of data for the program. Thus, each Madagascar program can be used in even ways that the original developer may not have foreseen, which makes your life easier as a user!<br />
<br />
= Command line interface = <br />
Madagascar programs follow the standard UNIX conventions for reading and writing RSF files to and from STDIN and STDOUT. This is also the same convention that SeismicUnix uses, so for those of you who are SU fans, this should be an easy conversion. <br />
<br />
For example: the program sfattr allows us to get attributes about an RSF file (mean, standard deviation, min, max, etc.) To get the attributes for a pre-computed file, we might use:<br />
<br />
sfattr < junk.rsf <br />
<br />
which outputs:<br />
<code><br />
rms = 1.41316 <br />
mean = 0.999667 <br />
2-norm = 357.503 <br />
variance = 0.997693 <br />
std dev = 0.998846 <br />
max = 5.05567 at 36 8 27 <br />
min = -3.59936 at 18 9 6 <br />
nonzero samples = 64000 <br />
total samples = 64000 <br />
</code><br />
For an example of reading and writing an RSF file I'm going to demonstrate the use of sfwindow which is a program that allows us to select portions of an RSF file. When sfwindow is used without any additional parameters, we are able to make a copy of a file with a different filename. For example:<br />
<br />
sfwindow < junk.rsf > junk2.rsf<br />
<br />
gives us two files, junk.rsf and junk2.rsf which are identical but not the same file.<br />
<br />
In addition to specifying files to read in and out on the command line we can specify the parameters for each program that are necessary for it to run, or to produce the desired result. The general format for specifying parameters on the command line is key=val, where key is the name of the parameter that you want to set, and val is the value of the parameter. There are four (4) different types of values that are acceptable: int, float, boolean, or string. Going back to the window program, we can specify the number of traces or pieces of the file that we want to keep like:<br />
<br />
sfwindow < junk.rsf n1=10 > junk-win.rsf<br />
<br />
= Self-documentation =<br />
<br />
Of course, we can specify as many parameters as we'd like on the command line. To figure out which parameters are needed for a specific program, just type the name of the program with no input files our output files on the command line as follows:<br />
<br />
sfwindow<br />
<br />
which brings up the self-documentation, which looks something like the following:<br />
<br />
NAME<br />
sfwindow<br />
DESCRIPTION<br />
Window a portion of a dataset. <br />
SYNOPSIS<br />
sfwindow < in.rsf > out.rsf verb=n squeeze=y j#=(1,...) d#=(d1,d2,...) f#=(0,...) min#=(o1,o2,,...) n#=(0,...) max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...)<br />
PARAMETERS<br />
float d#=(d1,d2,...) sampling in #-th dimension <br />
largeint f#=(0,...) window start in #-th dimension <br />
int j#=(1,...) jump in #-th dimension <br />
float max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...) maximum in #-th dimension <br />
float min#=(o1,o2,,...) minimum in #-th dimension <br />
largeint n#=(0,...) window size in #-th dimension <br />
bool squeeze=y [y/n] if y, squeeze dimensions equal to 1 to the end <br />
bool verb=n [y/n] Verbosity flag<br />
USED IN<br />
bei/dpmv/krchdmo<br />
bei/dpmv/matt<br />
bei/dwnc/sigmoid<br />
bei/fdm/kjartjac<br />
bei/fld/cube<br />
bei/fld/shotmovie<br />
bei/fld/synmarine<br />
bei/fld/yc<br />
bei/ft1/autocor<br />
<br />
The self-documentation tells us the function of the program, as well as the parameters that are available to be specified. The parameter format is type - name=default value [options] and then a short description of the parameter. File parameters request a name of a file. For example: file=junk.rsf<br />
<br />
= Piping =<br />
<br />
Sometimes we want to chain multiple commands together without writing intermediate Madagascar RSF files in the process. Fortunately, we can do this using another standard UNIX construct, Pipes. Pipes allow us to connect the standard output from one Madagascar program to the standard input to another program without first writing to a file. For example we could do the following without pipes:<br />
<br />
sfwindow < junk.rsf > junk-win.rsf<br />
sftransp < junk-win.rsf > junk2.rsf<br />
<br />
Or we could do the equivalent using pipes on one line:<br />
<br />
sfwindow < junk.rsf | sftransp > junk2.rsf<br />
<br />
Pipes simply make these statements more compact, and allow us to reduce the number of files that we need to save to disk. If you're doing something many times over, then pipes will make your life significantly easier. I highly recommend that you use pipes! Also, you should know that you can chain as many commands together as necessary using Pipes. <br />
<br />
Note: Madagascar uses a trick to make sure that you can send as much data as you want through the pipes because a conventional UNIX pipe has a maximum amount of data that can be sent through it. To avoid this limitation, Madagascar writes the data to temporary files before sending it through a pipe. <br />
<br />
= Commonly used programs =<br />
<br />
Here's a short list of commonly used programs, their usage:<br />
<br />
sfwindow - window out portions of a dataset<br />
sftransp - transpose the axes of a dataset<br />
sfin - see the shape of a file (axes)<br />
sfattr - common attributes of files<br />
sfspike - create files<br />
sfmath - basic mathematical operations (add subtract multiply)<br />
sfadd - like sfmath but easier to use<br />
sfgrey - raster plots<br />
sfgraph - line plots<br />
sfwiggle - wiggle plots<br />
<br />
For more information see [[Guide_to_madagascar_programs | Program guide]].<br />
<br />
= Interacting with files =</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorial_-_Users_1_-_Command_line_interface&diff=1684Tutorial - Users 1 - Command line interface2011-04-26T05:26:13Z<p>Jgodwin: </p>
<hr />
<div>Madagascar is designed to be used from the command line. Programmers create Madagascar programs (prefixed with the sf designation) that read and write Madagascar files. These programs are designed to be as general as possible, each one operates on any dataset provided in RSF format, provided you also provide the correct parameters and have the right type of data for the program. Thus, each Madagascar program can be used in even ways that the original developer may not have foreseen, which makes your life easier as a user!<br />
<br />
= Command line interface = <br />
Madagascar programs follow the standard UNIX conventions for reading and writing RSF files to and from STDIN and STDOUT. This is also the same convention that SeismicUnix uses, so for those of you who are SU fans, this should be an easy conversion. <br />
<br />
For example: the program sfattr allows us to get attributes about an RSF file (mean, standard deviation, min, max, etc.) To get the attributes for a pre-computed file, we might use:<br />
<br />
sfattr < junk.rsf <br />
<br />
which outputs:<br />
{{{<br />
rms = 1.41316 <br />
mean = 0.999667 <br />
2-norm = 357.503 <br />
variance = 0.997693 <br />
std dev = 0.998846 <br />
max = 5.05567 at 36 8 27 <br />
min = -3.59936 at 18 9 6 <br />
nonzero samples = 64000 <br />
total samples = 64000 <br />
}}}<br />
For an example of reading and writing an RSF file I'm going to demonstrate the use of sfwindow which is a program that allows us to select portions of an RSF file. When sfwindow is used without any additional parameters, we are able to make a copy of a file with a different filename. For example:<br />
<br />
sfwindow < junk.rsf > junk2.rsf<br />
<br />
gives us two files, junk.rsf and junk2.rsf which are identical but not the same file.<br />
<br />
In addition to specifying files to read in and out on the command line we can specify the parameters for each program that are necessary for it to run, or to produce the desired result. The general format for specifying parameters on the command line is key=val, where key is the name of the parameter that you want to set, and val is the value of the parameter. There are four (4) different types of values that are acceptable: int, float, boolean, or string. Going back to the window program, we can specify the number of traces or pieces of the file that we want to keep like:<br />
<br />
sfwindow < junk.rsf n1=10 > junk-win.rsf <br />
<br />
<br />
= Self-documentation =<br />
<br />
Of course, we can specify as many parameters as we'd like on the command line. To figure out which parameters are needed for a specific program, just type the name of the program with no input files our output files on the command line as follows:<br />
<br />
sfwindow<br />
<br />
which brings up the self-documentation, which looks something like the following:<br />
<br />
NAME<br />
sfwindow<br />
DESCRIPTION<br />
Window a portion of a dataset. <br />
SYNOPSIS<br />
sfwindow < in.rsf > out.rsf verb=n squeeze=y j#=(1,...) d#=(d1,d2,...) f#=(0,...) min#=(o1,o2,,...) n#=(0,...) max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...)<br />
PARAMETERS<br />
float d#=(d1,d2,...) sampling in #-th dimension <br />
largeint f#=(0,...) window start in #-th dimension <br />
int j#=(1,...) jump in #-th dimension <br />
float max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...) maximum in #-th dimension <br />
float min#=(o1,o2,,...) minimum in #-th dimension <br />
largeint n#=(0,...) window size in #-th dimension <br />
bool squeeze=y [y/n] if y, squeeze dimensions equal to 1 to the end <br />
bool verb=n [y/n] Verbosity flag<br />
USED IN<br />
bei/dpmv/krchdmo<br />
bei/dpmv/matt<br />
bei/dwnc/sigmoid<br />
bei/fdm/kjartjac<br />
bei/fld/cube<br />
bei/fld/shotmovie<br />
bei/fld/synmarine<br />
bei/fld/yc<br />
bei/ft1/autocor<br />
<br />
The self-documentation tells us the function of the program, as well as the parameters that are available to be specified. The parameter format is type - name=default value [options] and then a short description of the parameter. File parameters request a name of a file. For example: file=junk.rsf<br />
<br />
= Piping =<br />
<br />
Sometimes we want to chain multiple commands together without writing intermediate Madagascar RSF files in the process. Fortunately, we can do this using another standard UNIX construct, Pipes. Pipes allow us to connect the standard output from one Madagascar program to the standard input to another program without first writing to a file. For example we could do the following without pipes:<br />
<br />
sfwindow < junk.rsf > junk-win.rsf<br />
sftransp < junk-win.rsf > junk2.rsf<br />
<br />
Or we could do the equivalent using pipes on one line:<br />
<br />
sfwindow < junk.rsf | sftransp > junk2.rsf<br />
<br />
Pipes simply make these statements more compact, and allow us to reduce the number of files that we need to save to disk. If you're doing something many times over, then pipes will make your life significantly easier. I highly recommend that you use pipes! Also, you should know that you can chain as many commands together as necessary using Pipes. <br />
<br />
Note: Madagascar uses a trick to make sure that you can send as much data as you want through the pipes because a conventional UNIX pipe has a maximum amount of data that can be sent through it. To avoid this limitation, Madagascar writes the data to temporary files before sending it through a pipe. <br />
<br />
= Commonly used programs =<br />
<br />
Here's a short list of commonly used programs, their usage:<br />
<br />
sfwindow - window out portions of a dataset<br />
sftransp - transpose the axes of a dataset<br />
sfin - see the shape of a file (axes)<br />
sfattr - common attributes of files<br />
sfspike - create files<br />
sfmath - basic mathematical operations (add subtract multiply)<br />
sfadd - like sfmath but easier to use<br />
sfgrey - raster plots<br />
sfgraph - line plots<br />
sfwiggle - wiggle plots<br />
<br />
For more information see [[Guide_to_madagascar_programs | Program guide]].<br />
<br />
= Interacting with files =</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorial_-_Users_1_-_Command_line_interface&diff=1683Tutorial - Users 1 - Command line interface2011-04-26T05:22:59Z<p>Jgodwin: </p>
<hr />
<div>Madagascar is designed to be used from the command line. Programmers create Madagascar programs (prefixed with the sf designation) that read and write Madagascar files. These programs are designed to be as general as possible, each one operates on any dataset provided in RSF format, provided you also provide the correct parameters and have the right type of data for the program. Thus, each Madagascar program can be used in even ways that the original developer may not have foreseen, which makes your life easier as a user!<br />
<br />
Madagascar programs follow the standard UNIX conventions for reading and writing RSF files to and from STDIN and STDOUT. This is also the same convention that SeismicUnix uses, so for those of you who are SU fans, this should be an easy conversion. <br />
<br />
For example: the program sfattr allows us to get attributes about an RSF file (mean, standard deviation, min, max, etc.) To get the attributes for a pre-computed file, we might use:<br />
<br />
sfattr < junk.rsf <br />
<br />
which outputs:<br />
<br />
rms = 1.41316 <br />
mean = 0.999667 <br />
2-norm = 357.503 <br />
variance = 0.997693 <br />
std dev = 0.998846 <br />
max = 5.05567 at 36 8 27 <br />
min = -3.59936 at 18 9 6 <br />
nonzero samples = 64000 <br />
total samples = 64000 <br />
<br />
For an example of reading and writing an RSF file I'm going to demonstrate the use of sfwindow which is a program that allows us to select portions of an RSF file. When sfwindow is used without any additional parameters, we are able to make a copy of a file with a different filename. For example:<br />
<br />
sfwindow < junk.rsf > junk2.rsf<br />
<br />
gives us two files, junk.rsf and junk2.rsf which are identical but not the same file.<br />
<br />
In addition to specifying files to read in and out on the command line we can specify the parameters for each program that are necessary for it to run, or to produce the desired result. The general format for specifying parameters on the command line is key=val, where key is the name of the parameter that you want to set, and val is the value of the parameter. There are four (4) different types of values that are acceptable: int, float, boolean, or string. Going back to the window program, we can specify the number of traces or pieces of the file that we want to keep like:<br />
<br />
sfwindow < junk.rsf n1=10 > junk-win.rsf <br />
<br />
<br />
= Self-documentation =<br />
<br />
Of course, we can specify as many parameters as we'd like on the command line. To figure out which parameters are needed for a specific program, just type the name of the program with no input files our output files on the command line as follows:<br />
<br />
sfwindow<br />
<br />
which brings up the self-documentation, which looks something like the following:<br />
<br />
NAME<br />
sfwindow<br />
DESCRIPTION<br />
Window a portion of a dataset. <br />
SYNOPSIS<br />
sfwindow < in.rsf > out.rsf verb=n squeeze=y j#=(1,...) d#=(d1,d2,...) f#=(0,...) min#=(o1,o2,,...) n#=(0,...) max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...)<br />
PARAMETERS<br />
float d#=(d1,d2,...) sampling in #-th dimension <br />
largeint f#=(0,...) window start in #-th dimension <br />
int j#=(1,...) jump in #-th dimension <br />
float max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...) maximum in #-th dimension <br />
float min#=(o1,o2,,...) minimum in #-th dimension <br />
largeint n#=(0,...) window size in #-th dimension <br />
bool squeeze=y [y/n] if y, squeeze dimensions equal to 1 to the end <br />
bool verb=n [y/n] Verbosity flag<br />
USED IN<br />
bei/dpmv/krchdmo<br />
bei/dpmv/matt<br />
bei/dwnc/sigmoid<br />
bei/fdm/kjartjac<br />
bei/fld/cube<br />
bei/fld/shotmovie<br />
bei/fld/synmarine<br />
bei/fld/yc<br />
bei/ft1/autocor<br />
<br />
The self-documentation tells us the function of the program, as well as the parameters that are available to be specified. The parameter format is type - name=default value [options] and then a short description of the parameter. File parameters request a name of a file. For example: file=junk.rsf<br />
<br />
= Piping =<br />
<br />
Sometimes we want to chain multiple commands together without writing intermediate Madagascar RSF files in the process. Fortunately, we can do this using another standard UNIX construct, Pipes. Pipes allow us to connect the standard output from one Madagascar program to the standard input to another program without first writing to a file. For example we could do the following without pipes:<br />
<br />
sfwindow < junk.rsf > junk-win.rsf<br />
sftransp < junk-win.rsf > junk2.rsf<br />
<br />
Or we could do the equivalent using pipes on one line:<br />
<br />
sfwindow < junk.rsf | sftransp > junk2.rsf<br />
<br />
Pipes simply make these statements more compact, and allow us to reduce the number of files that we need to save to disk. If you're doing something many times over, then pipes will make your life significantly easier. I highly recommend that you use pipes! Also, you should know that you can chain as many commands together as necessary using Pipes. <br />
<br />
Note: Madagascar uses a trick to make sure that you can send as much data as you want through the pipes because a conventional UNIX pipe has a maximum amount of data that can be sent through it. To avoid this limitation, Madagascar writes the data to temporary files before sending it through a pipe. <br />
<br />
= Commonly used programs =<br />
<br />
Here's a short list of commonly used programs, their usage:<br />
<br />
sfwindow - window out portions of a dataset<br />
sftransp - transpose the axes of a dataset<br />
sfin - see the shape of a file (axes)<br />
sfattr - common attributes of files<br />
sfspike - create files<br />
sfmath - basic mathematical operations (add subtract multiply)<br />
sfadd - like sfmath but easier to use<br />
sfgrey - raster plots<br />
sfgraph - line plots<br />
sfwiggle - wiggle plots<br />
<br />
For more information see [[Guide_to_madagascar_programs | Program guide]].<br />
<br />
= Interacting with files =</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorial_-_Users_1_-_Command_line_interface&diff=1682Tutorial - Users 1 - Command line interface2011-04-26T04:41:51Z<p>Jgodwin: Created page with "Madagascar is designed to be used from the command line. Programmers create Madagascar programs (prefixed with the sf designation) that read and write Madagascar files. These p..."</p>
<hr />
<div>Madagascar is designed to be used from the command line. Programmers create Madagascar programs (prefixed with the sf designation) that read and write Madagascar files. These programs are designed to be as general as possible, each one operates on any dataset provided in RSF format, provided you also provide the correct parameters and have the right type of data for the program. Thus, each Madagascar program can be used in even ways that the original developer may not have foreseen, which makes your life easier as a user!<br />
<br />
Madagascar programs follow the standard UNIX conventions for reading and writing RSF files to and from STDIN and STDOUT. This is also the same convention that SeismicUnix uses, so for those of you who are SU fans, this should be an easy conversion. <br />
<br />
For example: the program sfattr allows us to get attributes about an RSF file (mean, standard deviation, min, max, etc.) To get the attributes for a pre-computed file, we might use:<br />
<br />
sfattr < junk.rsf <br />
<br />
which outputs:<br />
<br />
******************************************* <br />
rms = 1.41316 <br />
mean = 0.999667 <br />
2-norm = 357.503 <br />
variance = 0.997693 <br />
std dev = 0.998846 <br />
max = 5.05567 at 36 8 27 <br />
min = -3.59936 at 18 9 6 <br />
nonzero samples = 64000 <br />
total samples = 64000 <br />
******************************************* <br />
<br />
For an example of reading and writing an RSF file I'm going to demonstrate the use of sfwindow which is a program that allows us to select portions of an RSF file. When sfwindow is used without any additional parameters, we are able to make a copy of a file with a different filename. For example:<br />
<br />
sfwindow < junk.rsf > junk2.rsf<br />
<br />
gives us two files, junk.rsf and junk2.rsf which are identical but not the same file.<br />
<br />
In addition to specifying files to read in and out on the command line we can specify the parameters for each program that are necessary for it to run, or to produce the desired result. The general format for specifying parameters on the command line is key=val, where key is the name of the parameter that you want to set, and val is the value of the parameter. There are four (4) different types of values that are acceptable: int, float, boolean, or string. Going back to the window program, we can specify the number of traces or pieces of the file that we want to keep like:<br />
<br />
sfwindow < junk.rsf n1=10 > junk-win.rsf <br />
<br />
<br />
* Self-documentation<br />
<br />
Of course, we can specify as many parameters as we'd like on the command line. To figure out which parameters are needed for a specific program, just type the name of the program with no input files our output files on the command line as follows:<br />
<br />
sfwindow<br />
<br />
which brings up the self-documentation, which looks something like the following:<br />
<br />
NAME<br />
sfwindow<br />
DESCRIPTION<br />
Window a portion of a dataset. <br />
SYNOPSIS<br />
sfwindow < in.rsf > out.rsf verb=n squeeze=y j#=(1,...) d#=(d1,d2,...) f#=(0,...) min#=(o1,o2,,...) n#=(0,...) max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...)<br />
PARAMETERS<br />
float d#=(d1,d2,...) sampling in #-th dimension <br />
largeint f#=(0,...) window start in #-th dimension <br />
int j#=(1,...) jump in #-th dimension <br />
float max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...) maximum in #-th dimension <br />
float min#=(o1,o2,,...) minimum in #-th dimension <br />
largeint n#=(0,...) window size in #-th dimension <br />
bool squeeze=y [y/n] if y, squeeze dimensions equal to 1 to the end <br />
bool verb=n [y/n] Verbosity flag<br />
USED IN<br />
bei/dpmv/krchdmo<br />
bei/dpmv/matt<br />
bei/dwnc/sigmoid<br />
bei/fdm/kjartjac<br />
bei/fld/cube<br />
bei/fld/shotmovie<br />
bei/fld/synmarine<br />
bei/fld/yc<br />
bei/ft1/autocor<br />
<br />
The self-documentation tells us the function of the program, as well as the parameters that are available to be specified. The parameter format is type - name=default value [options] and then a short description of the parameter. File parameters request a name of a file. For example: file=junk.rsf<br />
<br />
* Piping<br />
<br />
Sometimes we want to chain multiple commands together without writing intermediate Madagascar RSF files in the process. Fortunately, we can do this using another standard UNIX construct, Pipes. Pipes allow us to connect the standard output from one Madagascar program to the standard input to another program without first writing to a file. For example we could do the following without pipes:<br />
<br />
sfwindow < junk.rsf > junk-win.rsf<br />
sftransp < junk-win.rsf > junk2.rsf<br />
<br />
Or we could do the equivalent using pipes on one line:<br />
<br />
sfwindow < junk.rsf | sftransp > junk2.rsf<br />
<br />
Pipes simply make these statements more compact, and allow us to reduce the number of files that we need to save to disk. If you're doing something many times over, then pipes will make your life significantly easier. I highly recommend that you use pipes! Also, you should know that you can chain as many commands together as necessary using Pipes. <br />
<br />
Note: Madagascar uses a trick to make sure that you can send as much data as you want through the pipes because a conventional UNIX pipe has a maximum amount of data that can be sent through it. To avoid this limitation, Madagascar writes the data to temporary files before sending it through a pipe. <br />
<br />
* Commonly used programs<br />
<br />
Here's a short list of commonly used programs, their usage:<br />
<br />
sfwindow - window out portions of a dataset<br />
sftransp - transpose the axes of a dataset<br />
sfin - see the shape of a file (axes)<br />
sfattr - common attributes of files<br />
sfspike - create files<br />
sfmath - basic mathematical operations (add subtract multiply)<br />
sfadd - like sfmath but easier to use<br />
sfgrey - raster plots<br />
sfgraph - line plots<br />
sfwiggle - wiggle plots<br />
<br />
For more information see: http://reproducibility.org/wiki/Guide_to_madagascar_programs<br />
<br />
* Interacting with files</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorials&diff=1681Tutorials2011-04-26T04:38:20Z<p>Jgodwin: /* Users */</p>
<hr />
<div>Learn Madagascar by completing the tutorial series below. The tutorials are aimed at a few types of individuals: <br />
<br />
1 - Users - Individuals who want to know how to use Madagascar immediately for data processing.<br />
<br />
2 - Developers - Individuals who are already Users, who want to write their own programs and/or contribute to Madagascar.<br />
<br />
3 - Authors - Individuals interested in creating reproducible documents using Madagascar.<br />
<br />
Additionally, we have a series of tutorials that show users how to perform common tasks, such as SEG-Y read/write, and conversion to and from SU formats. <br />
<br />
'''All tutorials are documented by examples in the Madagascar release. You can work alongside the examples!'''<br />
<br />
'''Tutorials are organized into levels. Higher level courses in a section require the lower level courses to be completed first.'''<br />
<br />
= Users =<br />
<br />
The user tutorials are focused on getting a new user running Madagascar from the ground up. These tutorials cover everything from: the command line interface, to advanced SCons functionality. By the end of these tutorials, you should be able to process large datasets using Madagascar very quickly, and write powerful Python scripts that are reproducible.<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|-<br />
| [[Tutorial_-_Users_0_-_RSF_file_format | RSF file format]] || 0 || An introduction to Madagascar and the RSF file format<br />
|-<br />
| Command line interface || 1 || Using the command line interface<br />
|-<br />
| Plotting || 2 || Creating and viewing vplot files<br />
|-<br />
| Intro to SCons || 3 || Creating simple SCons scripts for build control<br />
|-<br />
| Advanced SCons || 4 || Creating advanced SCons scripts<br />
|-<br />
| Advanced SCons II || 5 || Abusing SCons<br />
|- <br />
| Python || 6 || Loops, flow control, functions<br />
|- <br />
| Advanced visualization || 6 || 3D visualization using the Mines JTK and VTK<br />
|}<br />
<br />
= Developers = <br />
<br />
The developer tutorials are targeted to people who are already familiar with processing data in Madagascar. You should have completed the User tutorial series before beginning this tutorial series. This tutorial set covers: designing and developing simple programs in Madagascar, using the various language APIs, and parallel programming. Following completion of this tutorial series, you should be able to write advanced programs in Madagascar that can be contributed back to the community for others to use!<br />
<br />
{| border="1"<br />
! Name !! Level !! Description <br />
|-<br />
| Intro to Development || 0 || Learn how to write simple C programs using Madagascar<br />
|-<br />
| Advanced development || 1 || Learn how to link against other libraries <br />
|- <br />
| API development || 1 || Learn how to write a program in another API (Java, Python, Matlab, Fortran)<br />
|- <br />
| Parallel computing || 2 || Write a program that uses MPI or OpenMP <br />
|- <br />
| High performance Madagascar || 3 || Maximize your program's performance in Madagascar<br />
|}<br />
<br />
= Authors =<br />
<br />
The author tutorials are targeted at those who want to create reproducible documents using Madagascar. You should have completed the User tutorial before attempting these tutorials. This tutorial covers: combining Latex and Madagascar in a reproducible fashion, adding your own Latex style-sheets and macros, and building an SEG expanded abstract.<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|- <br />
| Intro to Reproducible documents || 0 || Introduction to reproducible documents and the framework <br />
|-<br />
| Using Latex || 1 || Create a simple document that uses Latex and Madagascar together.<br />
|-<br />
| Slides || 2 || Create a Beamer presentation using Madagascar.<br />
|-<br />
| SEG || 2 || Create an SEG abstract using Madagascar.<br />
|-<br />
| Geophysics || 3 || Create a Geophysics paper using Madagascar.<br />
|-<br />
| Reproduce past research || 3 || Reproduce someone else's research using Madagascar and Latex.<br />
|-<br />
| Adding custom macros || 4 || Adding your own macros for Latex documents using Madagascar.<br />
|- <br />
| Adding custom style sheets || 5 || Add or change style sheets to suit your own purposes easily using Madagascar.<br />
|}<br />
<br />
= Tasks = <br />
<br />
These tutorials are side tutorials that show how to perform specific tasks. You should have completed the Users tutorials before using these tutorials.<br />
<br />
{| border="1"<br />
! Name || Description<br />
|-<br />
| SEG-Y conversion || Read and write SEG-Y data to and from RSF format<br />
|-<br />
| Finite difference modeling || Create physical models and synthesize seismograms using a finite difference modeling code.<br />
|}</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorials&diff=1680Tutorials2011-04-26T04:38:06Z<p>Jgodwin: /* Users */</p>
<hr />
<div>Learn Madagascar by completing the tutorial series below. The tutorials are aimed at a few types of individuals: <br />
<br />
1 - Users - Individuals who want to know how to use Madagascar immediately for data processing.<br />
<br />
2 - Developers - Individuals who are already Users, who want to write their own programs and/or contribute to Madagascar.<br />
<br />
3 - Authors - Individuals interested in creating reproducible documents using Madagascar.<br />
<br />
Additionally, we have a series of tutorials that show users how to perform common tasks, such as SEG-Y read/write, and conversion to and from SU formats. <br />
<br />
'''All tutorials are documented by examples in the Madagascar release. You can work alongside the examples!'''<br />
<br />
'''Tutorials are organized into levels. Higher level courses in a section require the lower level courses to be completed first.'''<br />
<br />
= Users =<br />
<br />
The user tutorials are focused on getting a new user running Madagascar from the ground up. These tutorials cover everything from: the command line interface, to advanced SCons functionality. By the end of these tutorials, you should be able to process large datasets using Madagascar very quickly, and write powerful Python scripts that are reproducible.<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|-<br />
| [Tutorial_-_Users_0_-_RSF_file_format | RSF file format] || 0 || An introduction to Madagascar and the RSF file format<br />
|-<br />
| Command line interface || 1 || Using the command line interface<br />
|-<br />
| Plotting || 2 || Creating and viewing vplot files<br />
|-<br />
| Intro to SCons || 3 || Creating simple SCons scripts for build control<br />
|-<br />
| Advanced SCons || 4 || Creating advanced SCons scripts<br />
|-<br />
| Advanced SCons II || 5 || Abusing SCons<br />
|- <br />
| Python || 6 || Loops, flow control, functions<br />
|- <br />
| Advanced visualization || 6 || 3D visualization using the Mines JTK and VTK<br />
|}<br />
<br />
= Developers = <br />
<br />
The developer tutorials are targeted to people who are already familiar with processing data in Madagascar. You should have completed the User tutorial series before beginning this tutorial series. This tutorial set covers: designing and developing simple programs in Madagascar, using the various language APIs, and parallel programming. Following completion of this tutorial series, you should be able to write advanced programs in Madagascar that can be contributed back to the community for others to use!<br />
<br />
{| border="1"<br />
! Name !! Level !! Description <br />
|-<br />
| Intro to Development || 0 || Learn how to write simple C programs using Madagascar<br />
|-<br />
| Advanced development || 1 || Learn how to link against other libraries <br />
|- <br />
| API development || 1 || Learn how to write a program in another API (Java, Python, Matlab, Fortran)<br />
|- <br />
| Parallel computing || 2 || Write a program that uses MPI or OpenMP <br />
|- <br />
| High performance Madagascar || 3 || Maximize your program's performance in Madagascar<br />
|}<br />
<br />
= Authors =<br />
<br />
The author tutorials are targeted at those who want to create reproducible documents using Madagascar. You should have completed the User tutorial before attempting these tutorials. This tutorial covers: combining Latex and Madagascar in a reproducible fashion, adding your own Latex style-sheets and macros, and building an SEG expanded abstract.<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|- <br />
| Intro to Reproducible documents || 0 || Introduction to reproducible documents and the framework <br />
|-<br />
| Using Latex || 1 || Create a simple document that uses Latex and Madagascar together.<br />
|-<br />
| Slides || 2 || Create a Beamer presentation using Madagascar.<br />
|-<br />
| SEG || 2 || Create an SEG abstract using Madagascar.<br />
|-<br />
| Geophysics || 3 || Create a Geophysics paper using Madagascar.<br />
|-<br />
| Reproduce past research || 3 || Reproduce someone else's research using Madagascar and Latex.<br />
|-<br />
| Adding custom macros || 4 || Adding your own macros for Latex documents using Madagascar.<br />
|- <br />
| Adding custom style sheets || 5 || Add or change style sheets to suit your own purposes easily using Madagascar.<br />
|}<br />
<br />
= Tasks = <br />
<br />
These tutorials are side tutorials that show how to perform specific tasks. You should have completed the Users tutorials before using these tutorials.<br />
<br />
{| border="1"<br />
! Name || Description<br />
|-<br />
| SEG-Y conversion || Read and write SEG-Y data to and from RSF format<br />
|-<br />
| Finite difference modeling || Create physical models and synthesize seismograms using a finite difference modeling code.<br />
|}</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorials&diff=1679Tutorials2011-04-26T04:37:50Z<p>Jgodwin: /* Users */</p>
<hr />
<div>Learn Madagascar by completing the tutorial series below. The tutorials are aimed at a few types of individuals: <br />
<br />
1 - Users - Individuals who want to know how to use Madagascar immediately for data processing.<br />
<br />
2 - Developers - Individuals who are already Users, who want to write their own programs and/or contribute to Madagascar.<br />
<br />
3 - Authors - Individuals interested in creating reproducible documents using Madagascar.<br />
<br />
Additionally, we have a series of tutorials that show users how to perform common tasks, such as SEG-Y read/write, and conversion to and from SU formats. <br />
<br />
'''All tutorials are documented by examples in the Madagascar release. You can work alongside the examples!'''<br />
<br />
'''Tutorials are organized into levels. Higher level courses in a section require the lower level courses to be completed first.'''<br />
<br />
= Users =<br />
<br />
The user tutorials are focused on getting a new user running Madagascar from the ground up. These tutorials cover everything from: the command line interface, to advanced SCons functionality. By the end of these tutorials, you should be able to process large datasets using Madagascar very quickly, and write powerful Python scripts that are reproducible.<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|-<br />
| [Tutorial_-_Users_0_-_RSF_file_format | RSF file format ] || 0 || An introduction to Madagascar and the RSF file format<br />
|-<br />
| Command line interface || 1 || Using the command line interface<br />
|-<br />
| Plotting || 2 || Creating and viewing vplot files<br />
|-<br />
| Intro to SCons || 3 || Creating simple SCons scripts for build control<br />
|-<br />
| Advanced SCons || 4 || Creating advanced SCons scripts<br />
|-<br />
| Advanced SCons II || 5 || Abusing SCons<br />
|- <br />
| Python || 6 || Loops, flow control, functions<br />
|- <br />
| Advanced visualization || 6 || 3D visualization using the Mines JTK and VTK<br />
|}<br />
<br />
= Developers = <br />
<br />
The developer tutorials are targeted to people who are already familiar with processing data in Madagascar. You should have completed the User tutorial series before beginning this tutorial series. This tutorial set covers: designing and developing simple programs in Madagascar, using the various language APIs, and parallel programming. Following completion of this tutorial series, you should be able to write advanced programs in Madagascar that can be contributed back to the community for others to use!<br />
<br />
{| border="1"<br />
! Name !! Level !! Description <br />
|-<br />
| Intro to Development || 0 || Learn how to write simple C programs using Madagascar<br />
|-<br />
| Advanced development || 1 || Learn how to link against other libraries <br />
|- <br />
| API development || 1 || Learn how to write a program in another API (Java, Python, Matlab, Fortran)<br />
|- <br />
| Parallel computing || 2 || Write a program that uses MPI or OpenMP <br />
|- <br />
| High performance Madagascar || 3 || Maximize your program's performance in Madagascar<br />
|}<br />
<br />
= Authors =<br />
<br />
The author tutorials are targeted at those who want to create reproducible documents using Madagascar. You should have completed the User tutorial before attempting these tutorials. This tutorial covers: combining Latex and Madagascar in a reproducible fashion, adding your own Latex style-sheets and macros, and building an SEG expanded abstract.<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|- <br />
| Intro to Reproducible documents || 0 || Introduction to reproducible documents and the framework <br />
|-<br />
| Using Latex || 1 || Create a simple document that uses Latex and Madagascar together.<br />
|-<br />
| Slides || 2 || Create a Beamer presentation using Madagascar.<br />
|-<br />
| SEG || 2 || Create an SEG abstract using Madagascar.<br />
|-<br />
| Geophysics || 3 || Create a Geophysics paper using Madagascar.<br />
|-<br />
| Reproduce past research || 3 || Reproduce someone else's research using Madagascar and Latex.<br />
|-<br />
| Adding custom macros || 4 || Adding your own macros for Latex documents using Madagascar.<br />
|- <br />
| Adding custom style sheets || 5 || Add or change style sheets to suit your own purposes easily using Madagascar.<br />
|}<br />
<br />
= Tasks = <br />
<br />
These tutorials are side tutorials that show how to perform specific tasks. You should have completed the Users tutorials before using these tutorials.<br />
<br />
{| border="1"<br />
! Name || Description<br />
|-<br />
| SEG-Y conversion || Read and write SEG-Y data to and from RSF format<br />
|-<br />
| Finite difference modeling || Create physical models and synthesize seismograms using a finite difference modeling code.<br />
|}</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorials&diff=1678Tutorials2011-04-26T04:37:32Z<p>Jgodwin: /* Users */</p>
<hr />
<div>Learn Madagascar by completing the tutorial series below. The tutorials are aimed at a few types of individuals: <br />
<br />
1 - Users - Individuals who want to know how to use Madagascar immediately for data processing.<br />
<br />
2 - Developers - Individuals who are already Users, who want to write their own programs and/or contribute to Madagascar.<br />
<br />
3 - Authors - Individuals interested in creating reproducible documents using Madagascar.<br />
<br />
Additionally, we have a series of tutorials that show users how to perform common tasks, such as SEG-Y read/write, and conversion to and from SU formats. <br />
<br />
'''All tutorials are documented by examples in the Madagascar release. You can work alongside the examples!'''<br />
<br />
'''Tutorials are organized into levels. Higher level courses in a section require the lower level courses to be completed first.'''<br />
<br />
= Users =<br />
<br />
The user tutorials are focused on getting a new user running Madagascar from the ground up. These tutorials cover everything from: the command line interface, to advanced SCons functionality. By the end of these tutorials, you should be able to process large datasets using Madagascar very quickly, and write powerful Python scripts that are reproducible.<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|-<br />
| [RSF file format | Tutorial_-_Users_0_-_RSF_file_format] || 0 || An introduction to Madagascar and the RSF file format<br />
|-<br />
| Command line interface || 1 || Using the command line interface<br />
|-<br />
| Plotting || 2 || Creating and viewing vplot files<br />
|-<br />
| Intro to SCons || 3 || Creating simple SCons scripts for build control<br />
|-<br />
| Advanced SCons || 4 || Creating advanced SCons scripts<br />
|-<br />
| Advanced SCons II || 5 || Abusing SCons<br />
|- <br />
| Python || 6 || Loops, flow control, functions<br />
|- <br />
| Advanced visualization || 6 || 3D visualization using the Mines JTK and VTK<br />
|}<br />
<br />
= Developers = <br />
<br />
The developer tutorials are targeted to people who are already familiar with processing data in Madagascar. You should have completed the User tutorial series before beginning this tutorial series. This tutorial set covers: designing and developing simple programs in Madagascar, using the various language APIs, and parallel programming. Following completion of this tutorial series, you should be able to write advanced programs in Madagascar that can be contributed back to the community for others to use!<br />
<br />
{| border="1"<br />
! Name !! Level !! Description <br />
|-<br />
| Intro to Development || 0 || Learn how to write simple C programs using Madagascar<br />
|-<br />
| Advanced development || 1 || Learn how to link against other libraries <br />
|- <br />
| API development || 1 || Learn how to write a program in another API (Java, Python, Matlab, Fortran)<br />
|- <br />
| Parallel computing || 2 || Write a program that uses MPI or OpenMP <br />
|- <br />
| High performance Madagascar || 3 || Maximize your program's performance in Madagascar<br />
|}<br />
<br />
= Authors =<br />
<br />
The author tutorials are targeted at those who want to create reproducible documents using Madagascar. You should have completed the User tutorial before attempting these tutorials. This tutorial covers: combining Latex and Madagascar in a reproducible fashion, adding your own Latex style-sheets and macros, and building an SEG expanded abstract.<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|- <br />
| Intro to Reproducible documents || 0 || Introduction to reproducible documents and the framework <br />
|-<br />
| Using Latex || 1 || Create a simple document that uses Latex and Madagascar together.<br />
|-<br />
| Slides || 2 || Create a Beamer presentation using Madagascar.<br />
|-<br />
| SEG || 2 || Create an SEG abstract using Madagascar.<br />
|-<br />
| Geophysics || 3 || Create a Geophysics paper using Madagascar.<br />
|-<br />
| Reproduce past research || 3 || Reproduce someone else's research using Madagascar and Latex.<br />
|-<br />
| Adding custom macros || 4 || Adding your own macros for Latex documents using Madagascar.<br />
|- <br />
| Adding custom style sheets || 5 || Add or change style sheets to suit your own purposes easily using Madagascar.<br />
|}<br />
<br />
= Tasks = <br />
<br />
These tutorials are side tutorials that show how to perform specific tasks. You should have completed the Users tutorials before using these tutorials.<br />
<br />
{| border="1"<br />
! Name || Description<br />
|-<br />
| SEG-Y conversion || Read and write SEG-Y data to and from RSF format<br />
|-<br />
| Finite difference modeling || Create physical models and synthesize seismograms using a finite difference modeling code.<br />
|}</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorial_-_Users_0_-_RSF_file_format&diff=1676Tutorial - Users 0 - RSF file format2011-04-19T07:01:55Z<p>Jgodwin: /* Recap */</p>
<hr />
<div>= Objectives = <br />
<br />
*Overview of Madagascar<br />
*Madagascar's file format (RSF).<br />
*Where and how data is stored in Madagascar.<br />
<br />
= Overview of Madagascar = <br />
<br />
== What Madagascar is == <br />
<br />
Madagascar is a modern, open-source data processing package primarily used for geophysical data processing and signal processing. Madagascar is powerful, allowing users to leverage hundreds of previously developed algorithms and programs for signal processing. Some Madagascar programs leverage advanced computing technologies such as: Message Passing Interface (MPI) and OpenMP, bringing high-performance computing out of the box. Madagascar is flexible, users can import data from many different formats into a simple data structure used for all Madagascar programs. If you can't find what you need, you can write a Madagascar program using the language of your choice (C, C++, Fortran, Python, Java, Octave, Matlab,...). Madagascar is focused on computational reproduciblity, using Python and Latex documents and numerical experiments can be easily reproduced on other machines, allowing greater collaboration and preserving your contribution to the scientific community for years to come. Greater reproducibility increases transparency in research, and greatly reduces time spent by others reimplementing your work. <br />
<br />
== What Madagascar is NOT ==<br />
<br />
Madagascar is not a package for symbolic computation (e.g. Mathematica). Madagascar is not designed to replace commercial processing packages. Madagascar is not highly optimized for specific hardware.<br />
<br />
=Madagascar's file format (RSF) =<br />
<br />
To truly understand Madagascar, one has to understand the basic building block of Madagascar: the RSF file format. The RSF file format, is a common file format, that all Madagascar programs must use and output files to. Besides that criterion, Madagascar programs can do whatever they like. Individual programs can use MPI for parallel processing, link to various scientific or graphics libraries, or whatever else you might want to do. However, all programs must read and/or write RSF files to be considered part of the Madagascar processing package. Thus, it's crucial to understand how the RSF file format works and how it is designed.<br />
<br />
RSF stands for regularly sampled format. As the name implies, RSF files correspond to arrays (hypercubes) that are rectangular, or regularly sampled. However, RSF is designed to be very flexible, and performant, so RSF files are not just stored in your local folder (unlike Seismic Unix). Instead, RSF files are usually composed of two parts: a header file and a binary file. <br />
<br />
Overview of the header/binary separation for RSF files.<br />
=== Header file ===<br />
<br />
The header file is stored in your local directory with the suffix: .rsf. All files with the .rsf suffix are automatically considered to be RSF header files. Inside the header is the following information:<br />
A pointer to the actual data file (see binary data file below)<br />
Hypercube dimensions (origin, spacing, and number of points)<br />
Hypercube parameters (labels, units)<br />
A processing workflow history. Lists all programs used to create this file with parameters and dates/times.<br />
Special flags to indicate joint header/binary RSF files (see below).<br />
Because the header file stores very little actual data, the header file is stored in plain text (ASCII). You can open up a header file with your favorite text editor and read the parameters, or edit them if you'd like (note: don't edit the values unless you know what you're doing). <br />
<br />
=== Binary file ===<br />
<br />
The binary file contains the actual data that the header file points to. The binary data file is typically stored elsewhere on your local system (or even remotely) because the binary file can be very large (many TB). Binary files have the suffix: .rsf@ . To find out where your binary files are being stored you can view the header for a specific RSF file, or you can try looking in the location specified by your DATAPATH environment variable. By default, binary files are placed in the DATAPATH environment variable location. For example: DATAPATH=/tmp/local/ would make an RSF file /tmp/local/test.rsf@. <br />
<br />
Binary files are not readable by a text-editor. The only way to manipulate them is to use the built-in Madagascar programs, or to write your own RSF reader. <br />
<br />
WARNING:<br />
There are pros and cons to this style of file storage. The pro is that we can avoid bogging down our local file system with very large files. One con is that we might pay a performance penalty for keeping our data remotely. The major issue though is that we can't just move our headers or binaries around on the file system. If we move the binary data without changing our header we no longer point to the right data, creating an orphaned data file. We can avoid this issue using combined header/binary files.<br />
<br />
=== Combined header/binary files ===<br />
<br />
Combined header/binary files are exactly as the name says, the header and binary are attached to each other, meaning that the file has both the header information as well as the binary information in it. The advantage to doing this, is that the combined header binary file (suffix: .hh) can be moved around on the filesystem without worrying about breaking the link between header and binary. Combined header/binary files can be made by specifying the parameter '''out=stdout''' for any Madagascar program.<br />
<br />
= Recap = <br />
*Header file suffix: .rsf <br />
*Binary file suffix: .rsf@<br />
*Combined file suffix: .hh<br />
*RSF files are header-binary separated (stored in different locations).<br />
*The header file contains all the information about the binary file (dimensions, etc.) and is human readable.<br />
*The binary file contains the raw binary data and is not human readable.<br />
*Don't move header or binary files without first combining them together into header/binary combined format.<br />
<br />
= Additional information =<br />
<br />
[[Guide_to_rsf_format | Official guide to the RSF file format]]</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorial_-_Users_0_-_RSF_file_format&diff=1675Tutorial - Users 0 - RSF file format2011-04-19T07:01:10Z<p>Jgodwin: /* Objectives */</p>
<hr />
<div>= Objectives = <br />
<br />
*Overview of Madagascar<br />
*Madagascar's file format (RSF).<br />
*Where and how data is stored in Madagascar.<br />
<br />
= Overview of Madagascar = <br />
<br />
== What Madagascar is == <br />
<br />
Madagascar is a modern, open-source data processing package primarily used for geophysical data processing and signal processing. Madagascar is powerful, allowing users to leverage hundreds of previously developed algorithms and programs for signal processing. Some Madagascar programs leverage advanced computing technologies such as: Message Passing Interface (MPI) and OpenMP, bringing high-performance computing out of the box. Madagascar is flexible, users can import data from many different formats into a simple data structure used for all Madagascar programs. If you can't find what you need, you can write a Madagascar program using the language of your choice (C, C++, Fortran, Python, Java, Octave, Matlab,...). Madagascar is focused on computational reproduciblity, using Python and Latex documents and numerical experiments can be easily reproduced on other machines, allowing greater collaboration and preserving your contribution to the scientific community for years to come. Greater reproducibility increases transparency in research, and greatly reduces time spent by others reimplementing your work. <br />
<br />
== What Madagascar is NOT ==<br />
<br />
Madagascar is not a package for symbolic computation (e.g. Mathematica). Madagascar is not designed to replace commercial processing packages. Madagascar is not highly optimized for specific hardware.<br />
<br />
=Madagascar's file format (RSF) =<br />
<br />
To truly understand Madagascar, one has to understand the basic building block of Madagascar: the RSF file format. The RSF file format, is a common file format, that all Madagascar programs must use and output files to. Besides that criterion, Madagascar programs can do whatever they like. Individual programs can use MPI for parallel processing, link to various scientific or graphics libraries, or whatever else you might want to do. However, all programs must read and/or write RSF files to be considered part of the Madagascar processing package. Thus, it's crucial to understand how the RSF file format works and how it is designed.<br />
<br />
RSF stands for regularly sampled format. As the name implies, RSF files correspond to arrays (hypercubes) that are rectangular, or regularly sampled. However, RSF is designed to be very flexible, and performant, so RSF files are not just stored in your local folder (unlike Seismic Unix). Instead, RSF files are usually composed of two parts: a header file and a binary file. <br />
<br />
Overview of the header/binary separation for RSF files.<br />
=== Header file ===<br />
<br />
The header file is stored in your local directory with the suffix: .rsf. All files with the .rsf suffix are automatically considered to be RSF header files. Inside the header is the following information:<br />
A pointer to the actual data file (see binary data file below)<br />
Hypercube dimensions (origin, spacing, and number of points)<br />
Hypercube parameters (labels, units)<br />
A processing workflow history. Lists all programs used to create this file with parameters and dates/times.<br />
Special flags to indicate joint header/binary RSF files (see below).<br />
Because the header file stores very little actual data, the header file is stored in plain text (ASCII). You can open up a header file with your favorite text editor and read the parameters, or edit them if you'd like (note: don't edit the values unless you know what you're doing). <br />
<br />
=== Binary file ===<br />
<br />
The binary file contains the actual data that the header file points to. The binary data file is typically stored elsewhere on your local system (or even remotely) because the binary file can be very large (many TB). Binary files have the suffix: .rsf@ . To find out where your binary files are being stored you can view the header for a specific RSF file, or you can try looking in the location specified by your DATAPATH environment variable. By default, binary files are placed in the DATAPATH environment variable location. For example: DATAPATH=/tmp/local/ would make an RSF file /tmp/local/test.rsf@. <br />
<br />
Binary files are not readable by a text-editor. The only way to manipulate them is to use the built-in Madagascar programs, or to write your own RSF reader. <br />
<br />
WARNING:<br />
There are pros and cons to this style of file storage. The pro is that we can avoid bogging down our local file system with very large files. One con is that we might pay a performance penalty for keeping our data remotely. The major issue though is that we can't just move our headers or binaries around on the file system. If we move the binary data without changing our header we no longer point to the right data, creating an orphaned data file. We can avoid this issue using combined header/binary files.<br />
<br />
=== Combined header/binary files ===<br />
<br />
Combined header/binary files are exactly as the name says, the header and binary are attached to each other, meaning that the file has both the header information as well as the binary information in it. The advantage to doing this, is that the combined header binary file (suffix: .hh) can be moved around on the filesystem without worrying about breaking the link between header and binary. Combined header/binary files can be made by specifying the parameter '''out=stdout''' for any Madagascar program.<br />
<br />
= Recap = <br />
Header file suffix: .rsf <br />
Binary file suffix: .rsf@<br />
Combined file suffix: .hh<br />
RSF files are header-binary separated (stored in different locations).<br />
The header file contains all the information about the binary file (dimensions, etc.) and is human readable.<br />
The binary file contains the raw binary data and is not human readable.<br />
Don't move header or binary files without first combining them together into header/binary combined format.<br />
<br />
= Additional information =<br />
<br />
[[Guide_to_rsf_format | Official guide to the RSF file format]]</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorial_-_Users_0_-_RSF_file_format&diff=1674Tutorial - Users 0 - RSF file format2011-04-19T06:59:58Z<p>Jgodwin: /* What Madagascar is NOT */</p>
<hr />
<div>= Objectives = <br />
<br />
'''Overview of Madagascar<br />
Madagascar's file format (RSF).<br />
Where and how data is stored in Madagascar.'''<br />
<br />
= Overview of Madagascar = <br />
<br />
== What Madagascar is == <br />
<br />
Madagascar is a modern, open-source data processing package primarily used for geophysical data processing and signal processing. Madagascar is powerful, allowing users to leverage hundreds of previously developed algorithms and programs for signal processing. Some Madagascar programs leverage advanced computing technologies such as: Message Passing Interface (MPI) and OpenMP, bringing high-performance computing out of the box. Madagascar is flexible, users can import data from many different formats into a simple data structure used for all Madagascar programs. If you can't find what you need, you can write a Madagascar program using the language of your choice (C, C++, Fortran, Python, Java, Octave, Matlab,...). Madagascar is focused on computational reproduciblity, using Python and Latex documents and numerical experiments can be easily reproduced on other machines, allowing greater collaboration and preserving your contribution to the scientific community for years to come. Greater reproducibility increases transparency in research, and greatly reduces time spent by others reimplementing your work. <br />
<br />
== What Madagascar is NOT ==<br />
<br />
Madagascar is not a package for symbolic computation (e.g. Mathematica). Madagascar is not designed to replace commercial processing packages. Madagascar is not highly optimized for specific hardware.<br />
<br />
=Madagascar's file format (RSF) =<br />
<br />
To truly understand Madagascar, one has to understand the basic building block of Madagascar: the RSF file format. The RSF file format, is a common file format, that all Madagascar programs must use and output files to. Besides that criterion, Madagascar programs can do whatever they like. Individual programs can use MPI for parallel processing, link to various scientific or graphics libraries, or whatever else you might want to do. However, all programs must read and/or write RSF files to be considered part of the Madagascar processing package. Thus, it's crucial to understand how the RSF file format works and how it is designed.<br />
<br />
RSF stands for regularly sampled format. As the name implies, RSF files correspond to arrays (hypercubes) that are rectangular, or regularly sampled. However, RSF is designed to be very flexible, and performant, so RSF files are not just stored in your local folder (unlike Seismic Unix). Instead, RSF files are usually composed of two parts: a header file and a binary file. <br />
<br />
Overview of the header/binary separation for RSF files.<br />
=== Header file ===<br />
<br />
The header file is stored in your local directory with the suffix: .rsf. All files with the .rsf suffix are automatically considered to be RSF header files. Inside the header is the following information:<br />
A pointer to the actual data file (see binary data file below)<br />
Hypercube dimensions (origin, spacing, and number of points)<br />
Hypercube parameters (labels, units)<br />
A processing workflow history. Lists all programs used to create this file with parameters and dates/times.<br />
Special flags to indicate joint header/binary RSF files (see below).<br />
Because the header file stores very little actual data, the header file is stored in plain text (ASCII). You can open up a header file with your favorite text editor and read the parameters, or edit them if you'd like (note: don't edit the values unless you know what you're doing). <br />
<br />
=== Binary file ===<br />
<br />
The binary file contains the actual data that the header file points to. The binary data file is typically stored elsewhere on your local system (or even remotely) because the binary file can be very large (many TB). Binary files have the suffix: .rsf@ . To find out where your binary files are being stored you can view the header for a specific RSF file, or you can try looking in the location specified by your DATAPATH environment variable. By default, binary files are placed in the DATAPATH environment variable location. For example: DATAPATH=/tmp/local/ would make an RSF file /tmp/local/test.rsf@. <br />
<br />
Binary files are not readable by a text-editor. The only way to manipulate them is to use the built-in Madagascar programs, or to write your own RSF reader. <br />
<br />
WARNING:<br />
There are pros and cons to this style of file storage. The pro is that we can avoid bogging down our local file system with very large files. One con is that we might pay a performance penalty for keeping our data remotely. The major issue though is that we can't just move our headers or binaries around on the file system. If we move the binary data without changing our header we no longer point to the right data, creating an orphaned data file. We can avoid this issue using combined header/binary files.<br />
<br />
=== Combined header/binary files ===<br />
<br />
Combined header/binary files are exactly as the name says, the header and binary are attached to each other, meaning that the file has both the header information as well as the binary information in it. The advantage to doing this, is that the combined header binary file (suffix: .hh) can be moved around on the filesystem without worrying about breaking the link between header and binary. Combined header/binary files can be made by specifying the parameter '''out=stdout''' for any Madagascar program.<br />
<br />
= Recap = <br />
Header file suffix: .rsf <br />
Binary file suffix: .rsf@<br />
Combined file suffix: .hh<br />
RSF files are header-binary separated (stored in different locations).<br />
The header file contains all the information about the binary file (dimensions, etc.) and is human readable.<br />
The binary file contains the raw binary data and is not human readable.<br />
Don't move header or binary files without first combining them together into header/binary combined format.<br />
<br />
= Additional information =<br />
<br />
[[Guide_to_rsf_format | Official guide to the RSF file format]]</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorial_-_Users_0_-_RSF_file_format&diff=1673Tutorial - Users 0 - RSF file format2011-04-19T06:59:24Z<p>Jgodwin: /* Additional information */</p>
<hr />
<div>= Objectives = <br />
<br />
'''Overview of Madagascar<br />
Madagascar's file format (RSF).<br />
Where and how data is stored in Madagascar.'''<br />
<br />
= Overview of Madagascar = <br />
<br />
== What Madagascar is == <br />
<br />
Madagascar is a modern, open-source data processing package primarily used for geophysical data processing and signal processing. Madagascar is powerful, allowing users to leverage hundreds of previously developed algorithms and programs for signal processing. Some Madagascar programs leverage advanced computing technologies such as: Message Passing Interface (MPI) and OpenMP, bringing high-performance computing out of the box. Madagascar is flexible, users can import data from many different formats into a simple data structure used for all Madagascar programs. If you can't find what you need, you can write a Madagascar program using the language of your choice (C, C++, Fortran, Python, Java, Octave, Matlab,...). Madagascar is focused on computational reproduciblity, using Python and Latex documents and numerical experiments can be easily reproduced on other machines, allowing greater collaboration and preserving your contribution to the scientific community for years to come. Greater reproducibility increases transparency in research, and greatly reduces time spent by others reimplementing your work. <br />
<br />
== What Madagascar is NOT ==<br />
<br />
Madagascar is not a package for symbolic computation (e.g. Mathematica). Madagascar is not designed to replace commercial processing packages. Madagascar is not highly optimized for specific hardware.<br />
<br />
Additional information:<br />
<br />
[[Why_Madagascar]]<br />
<br />
=Madagascar's file format (RSF) =<br />
<br />
To truly understand Madagascar, one has to understand the basic building block of Madagascar: the RSF file format. The RSF file format, is a common file format, that all Madagascar programs must use and output files to. Besides that criterion, Madagascar programs can do whatever they like. Individual programs can use MPI for parallel processing, link to various scientific or graphics libraries, or whatever else you might want to do. However, all programs must read and/or write RSF files to be considered part of the Madagascar processing package. Thus, it's crucial to understand how the RSF file format works and how it is designed.<br />
<br />
RSF stands for regularly sampled format. As the name implies, RSF files correspond to arrays (hypercubes) that are rectangular, or regularly sampled. However, RSF is designed to be very flexible, and performant, so RSF files are not just stored in your local folder (unlike Seismic Unix). Instead, RSF files are usually composed of two parts: a header file and a binary file. <br />
<br />
Overview of the header/binary separation for RSF files.<br />
=== Header file ===<br />
<br />
The header file is stored in your local directory with the suffix: .rsf. All files with the .rsf suffix are automatically considered to be RSF header files. Inside the header is the following information:<br />
A pointer to the actual data file (see binary data file below)<br />
Hypercube dimensions (origin, spacing, and number of points)<br />
Hypercube parameters (labels, units)<br />
A processing workflow history. Lists all programs used to create this file with parameters and dates/times.<br />
Special flags to indicate joint header/binary RSF files (see below).<br />
Because the header file stores very little actual data, the header file is stored in plain text (ASCII). You can open up a header file with your favorite text editor and read the parameters, or edit them if you'd like (note: don't edit the values unless you know what you're doing). <br />
<br />
=== Binary file ===<br />
<br />
The binary file contains the actual data that the header file points to. The binary data file is typically stored elsewhere on your local system (or even remotely) because the binary file can be very large (many TB). Binary files have the suffix: .rsf@ . To find out where your binary files are being stored you can view the header for a specific RSF file, or you can try looking in the location specified by your DATAPATH environment variable. By default, binary files are placed in the DATAPATH environment variable location. For example: DATAPATH=/tmp/local/ would make an RSF file /tmp/local/test.rsf@. <br />
<br />
Binary files are not readable by a text-editor. The only way to manipulate them is to use the built-in Madagascar programs, or to write your own RSF reader. <br />
<br />
WARNING:<br />
There are pros and cons to this style of file storage. The pro is that we can avoid bogging down our local file system with very large files. One con is that we might pay a performance penalty for keeping our data remotely. The major issue though is that we can't just move our headers or binaries around on the file system. If we move the binary data without changing our header we no longer point to the right data, creating an orphaned data file. We can avoid this issue using combined header/binary files.<br />
<br />
=== Combined header/binary files ===<br />
<br />
Combined header/binary files are exactly as the name says, the header and binary are attached to each other, meaning that the file has both the header information as well as the binary information in it. The advantage to doing this, is that the combined header binary file (suffix: .hh) can be moved around on the filesystem without worrying about breaking the link between header and binary. Combined header/binary files can be made by specifying the parameter '''out=stdout''' for any Madagascar program.<br />
<br />
= Recap = <br />
Header file suffix: .rsf <br />
Binary file suffix: .rsf@<br />
Combined file suffix: .hh<br />
RSF files are header-binary separated (stored in different locations).<br />
The header file contains all the information about the binary file (dimensions, etc.) and is human readable.<br />
The binary file contains the raw binary data and is not human readable.<br />
Don't move header or binary files without first combining them together into header/binary combined format.<br />
<br />
= Additional information =<br />
<br />
[[Guide_to_rsf_format | Official guide to the RSF file format]]</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorial_-_Users_0_-_RSF_file_format&diff=1672Tutorial - Users 0 - RSF file format2011-04-19T06:58:09Z<p>Jgodwin: /* Combined header/binary files */</p>
<hr />
<div>= Objectives = <br />
<br />
'''Overview of Madagascar<br />
Madagascar's file format (RSF).<br />
Where and how data is stored in Madagascar.'''<br />
<br />
= Overview of Madagascar = <br />
<br />
== What Madagascar is == <br />
<br />
Madagascar is a modern, open-source data processing package primarily used for geophysical data processing and signal processing. Madagascar is powerful, allowing users to leverage hundreds of previously developed algorithms and programs for signal processing. Some Madagascar programs leverage advanced computing technologies such as: Message Passing Interface (MPI) and OpenMP, bringing high-performance computing out of the box. Madagascar is flexible, users can import data from many different formats into a simple data structure used for all Madagascar programs. If you can't find what you need, you can write a Madagascar program using the language of your choice (C, C++, Fortran, Python, Java, Octave, Matlab,...). Madagascar is focused on computational reproduciblity, using Python and Latex documents and numerical experiments can be easily reproduced on other machines, allowing greater collaboration and preserving your contribution to the scientific community for years to come. Greater reproducibility increases transparency in research, and greatly reduces time spent by others reimplementing your work. <br />
<br />
== What Madagascar is NOT ==<br />
<br />
Madagascar is not a package for symbolic computation (e.g. Mathematica). Madagascar is not designed to replace commercial processing packages. Madagascar is not highly optimized for specific hardware.<br />
<br />
Additional information:<br />
<br />
[[Why_Madagascar]]<br />
<br />
=Madagascar's file format (RSF) =<br />
<br />
To truly understand Madagascar, one has to understand the basic building block of Madagascar: the RSF file format. The RSF file format, is a common file format, that all Madagascar programs must use and output files to. Besides that criterion, Madagascar programs can do whatever they like. Individual programs can use MPI for parallel processing, link to various scientific or graphics libraries, or whatever else you might want to do. However, all programs must read and/or write RSF files to be considered part of the Madagascar processing package. Thus, it's crucial to understand how the RSF file format works and how it is designed.<br />
<br />
RSF stands for regularly sampled format. As the name implies, RSF files correspond to arrays (hypercubes) that are rectangular, or regularly sampled. However, RSF is designed to be very flexible, and performant, so RSF files are not just stored in your local folder (unlike Seismic Unix). Instead, RSF files are usually composed of two parts: a header file and a binary file. <br />
<br />
Overview of the header/binary separation for RSF files.<br />
=== Header file ===<br />
<br />
The header file is stored in your local directory with the suffix: .rsf. All files with the .rsf suffix are automatically considered to be RSF header files. Inside the header is the following information:<br />
A pointer to the actual data file (see binary data file below)<br />
Hypercube dimensions (origin, spacing, and number of points)<br />
Hypercube parameters (labels, units)<br />
A processing workflow history. Lists all programs used to create this file with parameters and dates/times.<br />
Special flags to indicate joint header/binary RSF files (see below).<br />
Because the header file stores very little actual data, the header file is stored in plain text (ASCII). You can open up a header file with your favorite text editor and read the parameters, or edit them if you'd like (note: don't edit the values unless you know what you're doing). <br />
<br />
=== Binary file ===<br />
<br />
The binary file contains the actual data that the header file points to. The binary data file is typically stored elsewhere on your local system (or even remotely) because the binary file can be very large (many TB). Binary files have the suffix: .rsf@ . To find out where your binary files are being stored you can view the header for a specific RSF file, or you can try looking in the location specified by your DATAPATH environment variable. By default, binary files are placed in the DATAPATH environment variable location. For example: DATAPATH=/tmp/local/ would make an RSF file /tmp/local/test.rsf@. <br />
<br />
Binary files are not readable by a text-editor. The only way to manipulate them is to use the built-in Madagascar programs, or to write your own RSF reader. <br />
<br />
WARNING:<br />
There are pros and cons to this style of file storage. The pro is that we can avoid bogging down our local file system with very large files. One con is that we might pay a performance penalty for keeping our data remotely. The major issue though is that we can't just move our headers or binaries around on the file system. If we move the binary data without changing our header we no longer point to the right data, creating an orphaned data file. We can avoid this issue using combined header/binary files.<br />
<br />
=== Combined header/binary files ===<br />
<br />
Combined header/binary files are exactly as the name says, the header and binary are attached to each other, meaning that the file has both the header information as well as the binary information in it. The advantage to doing this, is that the combined header binary file (suffix: .hh) can be moved around on the filesystem without worrying about breaking the link between header and binary. Combined header/binary files can be made by specifying the parameter '''out=stdout''' for any Madagascar program.<br />
<br />
= Recap = <br />
Header file suffix: .rsf <br />
Binary file suffix: .rsf@<br />
Combined file suffix: .hh<br />
RSF files are header-binary separated (stored in different locations).<br />
The header file contains all the information about the binary file (dimensions, etc.) and is human readable.<br />
The binary file contains the raw binary data and is not human readable.<br />
Don't move header or binary files without first combining them together into header/binary combined format.<br />
<br />
= Additional information =<br />
<br />
[[Guide_to_rsf_format]]</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorial_-_Users_0_-_RSF_file_format&diff=1671Tutorial - Users 0 - RSF file format2011-04-19T06:51:11Z<p>Jgodwin: </p>
<hr />
<div>= Objectives = <br />
<br />
'''Overview of Madagascar<br />
Madagascar's file format (RSF).<br />
Where and how data is stored in Madagascar.'''<br />
<br />
= Overview of Madagascar = <br />
<br />
== What Madagascar is == <br />
<br />
Madagascar is a modern, open-source data processing package primarily used for geophysical data processing and signal processing. Madagascar is powerful, allowing users to leverage hundreds of previously developed algorithms and programs for signal processing. Some Madagascar programs leverage advanced computing technologies such as: Message Passing Interface (MPI) and OpenMP, bringing high-performance computing out of the box. Madagascar is flexible, users can import data from many different formats into a simple data structure used for all Madagascar programs. If you can't find what you need, you can write a Madagascar program using the language of your choice (C, C++, Fortran, Python, Java, Octave, Matlab,...). Madagascar is focused on computational reproduciblity, using Python and Latex documents and numerical experiments can be easily reproduced on other machines, allowing greater collaboration and preserving your contribution to the scientific community for years to come. Greater reproducibility increases transparency in research, and greatly reduces time spent by others reimplementing your work. <br />
<br />
== What Madagascar is NOT ==<br />
<br />
Madagascar is not a package for symbolic computation (e.g. Mathematica). Madagascar is not designed to replace commercial processing packages. Madagascar is not highly optimized for specific hardware.<br />
<br />
Additional information:<br />
<br />
[[Why_Madagascar]]<br />
<br />
=Madagascar's file format (RSF) =<br />
<br />
To truly understand Madagascar, one has to understand the basic building block of Madagascar: the RSF file format. The RSF file format, is a common file format, that all Madagascar programs must use and output files to. Besides that criterion, Madagascar programs can do whatever they like. Individual programs can use MPI for parallel processing, link to various scientific or graphics libraries, or whatever else you might want to do. However, all programs must read and/or write RSF files to be considered part of the Madagascar processing package. Thus, it's crucial to understand how the RSF file format works and how it is designed.<br />
<br />
RSF stands for regularly sampled format. As the name implies, RSF files correspond to arrays (hypercubes) that are rectangular, or regularly sampled. However, RSF is designed to be very flexible, and performant, so RSF files are not just stored in your local folder (unlike Seismic Unix). Instead, RSF files are usually composed of two parts: a header file and a binary file. <br />
<br />
Overview of the header/binary separation for RSF files.<br />
=== Header file ===<br />
<br />
The header file is stored in your local directory with the suffix: .rsf. All files with the .rsf suffix are automatically considered to be RSF header files. Inside the header is the following information:<br />
A pointer to the actual data file (see binary data file below)<br />
Hypercube dimensions (origin, spacing, and number of points)<br />
Hypercube parameters (labels, units)<br />
A processing workflow history. Lists all programs used to create this file with parameters and dates/times.<br />
Special flags to indicate joint header/binary RSF files (see below).<br />
Because the header file stores very little actual data, the header file is stored in plain text (ASCII). You can open up a header file with your favorite text editor and read the parameters, or edit them if you'd like (note: don't edit the values unless you know what you're doing). <br />
<br />
=== Binary file ===<br />
<br />
The binary file contains the actual data that the header file points to. The binary data file is typically stored elsewhere on your local system (or even remotely) because the binary file can be very large (many TB). Binary files have the suffix: .rsf@ . To find out where your binary files are being stored you can view the header for a specific RSF file, or you can try looking in the location specified by your DATAPATH environment variable. By default, binary files are placed in the DATAPATH environment variable location. For example: DATAPATH=/tmp/local/ would make an RSF file /tmp/local/test.rsf@. <br />
<br />
Binary files are not readable by a text-editor. The only way to manipulate them is to use the built-in Madagascar programs, or to write your own RSF reader. <br />
<br />
WARNING:<br />
There are pros and cons to this style of file storage. The pro is that we can avoid bogging down our local file system with very large files. One con is that we might pay a performance penalty for keeping our data remotely. The major issue though is that we can't just move our headers or binaries around on the file system. If we move the binary data without changing our header we no longer point to the right data, creating an orphaned data file. We can avoid this issue using combined header/binary files.<br />
<br />
=== Combined header/binary files ===<br />
<br />
Combined header/binary files are exactly as the name says, the header and binary are attached to each other, meaning that the file has both the header information as well as the binary information in it. The advantage to doing this, is that the combined header binary file (suffix: .hh) can be moved around on the filesystem without worrying about breaking the link between header and binary. Combined header/binary files can be made using special Madagascar commands, which I will show you later. <br />
<br />
Recap:<br />
Header file suffix: .rsf <br />
Binary file suffix: .rsf@<br />
Combined file suffix: .hh<br />
RSF files are header-binary separated (stored in different locations).<br />
The header file contains all the information about the binary file (dimensions, etc.) and is human readable.<br />
The binary file contains the raw binary data and is not human readable.<br />
Don't move header or binary files without first combining them together into header/binary combined format.<br />
<br />
= Additional information =<br />
<br />
[[Guide_to_rsf_format]]</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorial_-_Users_0_-_RSF_file_format&diff=1670Tutorial - Users 0 - RSF file format2011-04-19T06:46:56Z<p>Jgodwin: Created page with "Objectives for this lessons: Overview of Madagascar Madagascar's file format (RSF). Where and how data is stored in Madagascar. Overview of Madagascar What Madagascar is: Mad..."</p>
<hr />
<div>Objectives for this lessons:<br />
<br />
Overview of Madagascar<br />
Madagascar's file format (RSF).<br />
Where and how data is stored in Madagascar.<br />
<br />
Overview of Madagascar<br />
<br />
What Madagascar is:<br />
<br />
Madagascar is a modern, open-source data processing package primarily used for geophysical data processing and signal processing. Madagascar is powerful, allowing users to leverage hundreds of previously developed algorithms and programs for signal processing. Some Madagascar programs leverage advanced computing technologies such as: Message Passing Interface (MPI) and OpenMP, bringing high-performance computing out of the box. Madagascar is flexible, users can import data from many different formats into a simple data structure used for all Madagascar programs. If you can't find what you need, you can write a Madagascar program using the language of your choice (C, C++, Fortran, Python, Java, Octave, Matlab,...). Madagascar is focused on computational reproduciblity, using Python and Latex documents and numerical experiments can be easily reproduced on other machines, allowing greater collaboration and preserving your contribution to the scientific community for years to come. Greater reproducibility increases transparency in research, and greatly reduces time spent by others reimplementing your work. <br />
<br />
What Madagascar is NOT:<br />
<br />
Madagascar is not a package for symbolic computation (e.g. Mathematica). Madagascar is not designed to replace commercial processing packages. Madagascar is not highly optimized for specific hardware.<br />
<br />
Additional information:<br />
<br />
[[Why_Madagascar]]<br />
<br />
Madagascar's file format:<br />
<br />
To truly understand Madagascar, one has to understand the basic building block of Madagascar: the RSF file format. The RSF file format, is a common file format, that all Madagascar programs must use and output files to. Besides that criterion, Madagascar programs can do whatever they like. Individual programs can use MPI for parallel processing, link to various scientific or graphics libraries, or whatever else you might want to do. However, all programs must read and/or write RSF files to be considered part of the Madagascar processing package. Thus, it's crucial to understand how the RSF file format works and how it is designed.<br />
<br />
RSF stands for regularly sampled format. As the name implies, RSF files correspond to arrays (hypercubes) that are rectangular, or regularly sampled. However, RSF is designed to be very flexible, and performant, so RSF files are not just stored in your local folder (unlike Seismic Unix). Instead, RSF files are usually composed of two parts: a header file and a binary file. <br />
<br />
<br />
<br />
Overview of the header/binary separation for RSF files.<br />
Header file <br />
<br />
The header file is stored in your local directory with the suffix: .rsf. All files with the .rsf suffix are automatically considered to be RSF header files. Inside the header is the following information:<br />
A pointer to the actual data file (see binary data file below)<br />
Hypercube dimensions (origin, spacing, and number of points)<br />
Hypercube parameters (labels, units)<br />
A processing workflow history. Lists all programs used to create this file with parameters and dates/times.<br />
Special flags to indicate joint header/binary RSF files (see below).<br />
Because the header file stores very little actual data, the header file is stored in plain text (ASCII). You can open up a header file with your favorite text editor and read the parameters, or edit them if you'd like (note: don't edit the values unless you know what you're doing). <br />
<br />
Binary file<br />
<br />
The binary file contains the actual data that the header file points to. The binary data file is typically stored elsewhere on your local system (or even remotely) because the binary file can be very large (many TB). Binary files have the suffix: .rsf@ . To find out where your binary files are being stored you can view the header for a specific RSF file, or you can try looking in the location specified by your DATAPATH environment variable. By default, binary files are placed in the DATAPATH environment variable location. For example: DATAPATH=/tmp/local/ would make an RSF file /tmp/local/test.rsf@. <br />
<br />
Binary files are not readable by a text-editor. The only way to manipulate them is to use the built-in Madagascar programs, or to write your own RSF reader. <br />
<br />
WARNING:<br />
There are pros and cons to this style of file storage. The pro is that we can avoid bogging down our local file system with very large files. One con is that we might pay a performance penalty for keeping our data remotely. The major issue though is that we can't just move our headers or binaries around on the file system. If we move the binary data without changing our header we no longer point to the right data, creating an orphaned data file. We can avoid this issue using combined header/binary files.<br />
<br />
Combined header/binary files<br />
<br />
Combined header/binary files are exactly as the name says, the header and binary are attached to each other, meaning that the file has both the header information as well as the binary information in it. The advantage to doing this, is that the combined header binary file (suffix: .hh) can be moved around on the filesystem without worrying about breaking the link between header and binary. Combined header/binary files can be made using special Madagascar commands, which I will show you later. <br />
<br />
Recap:<br />
Header file suffix: .rsf <br />
Binary file suffix: .rsf@<br />
Combined file suffix: .hh<br />
RSF files are header-binary separated (stored in different locations).<br />
The header file contains all the information about the binary file (dimensions, etc.) and is human readable.<br />
The binary file contains the raw binary data and is not human readable.<br />
Don't move header or binary files without first combining them together into header/binary combined format.<br />
<br />
Additional information:<br />
<br />
[[Guide_to_rsf_format]]</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorials&diff=1668Tutorials2011-04-19T06:42:55Z<p>Jgodwin: moved Tutorial to Tutorials</p>
<hr />
<div>Learn Madagascar by completing the tutorial series below. The tutorials are aimed at a few types of individuals: <br />
<br />
1 - Users - Individuals who want to know how to use Madagascar immediately for data processing.<br />
<br />
2 - Developers - Individuals who are already Users, who want to write their own programs and/or contribute to Madagascar.<br />
<br />
3 - Authors - Individuals interested in creating reproducible documents using Madagascar.<br />
<br />
Additionally, we have a series of tutorials that show users how to perform common tasks, such as SEG-Y read/write, and conversion to and from SU formats. <br />
<br />
'''All tutorials are documented by examples in the Madagascar release. You can work alongside the examples!'''<br />
<br />
'''Tutorials are organized into levels. Higher level courses in a section require the lower level courses to be completed first.'''<br />
<br />
= Users =<br />
<br />
The user tutorials are focused on getting a new user running Madagascar from the ground up. These tutorials cover everything from: the command line interface, to advanced SCons functionality. By the end of these tutorials, you should be able to process large datasets using Madagascar very quickly, and write powerful Python scripts that are reproducible.<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|-<br />
| RSF file format || 0 || An introduction to Madagascar and the RSF file format<br />
|-<br />
| Command line interface || 1 || Using the command line interface<br />
|-<br />
| Plotting || 2 || Creating and viewing vplot files<br />
|-<br />
| Intro to SCons || 3 || Creating simple SCons scripts for build control<br />
|-<br />
| Advanced SCons || 4 || Creating advanced SCons scripts<br />
|-<br />
| Advanced SCons II || 5 || Abusing SCons<br />
|- <br />
| Python || 6 || Loops, flow control, functions<br />
|- <br />
| Advanced visualization || 6 || 3D visualization using the Mines JTK and VTK<br />
|}<br />
<br />
= Developers = <br />
<br />
The developer tutorials are targeted to people who are already familiar with processing data in Madagascar. You should have completed the User tutorial series before beginning this tutorial series. This tutorial set covers: designing and developing simple programs in Madagascar, using the various language APIs, and parallel programming. Following completion of this tutorial series, you should be able to write advanced programs in Madagascar that can be contributed back to the community for others to use!<br />
<br />
{| border="1"<br />
! Name !! Level !! Description <br />
|-<br />
| Intro to Development || 0 || Learn how to write simple C programs using Madagascar<br />
|-<br />
| Advanced development || 1 || Learn how to link against other libraries <br />
|- <br />
| API development || 1 || Learn how to write a program in another API (Java, Python, Matlab, Fortran)<br />
|- <br />
| Parallel computing || 2 || Write a program that uses MPI or OpenMP <br />
|- <br />
| High performance Madagascar || 3 || Maximize your program's performance in Madagascar<br />
|}<br />
<br />
= Authors =<br />
<br />
The author tutorials are targeted at those who want to create reproducible documents using Madagascar. You should have completed the User tutorial before attempting these tutorials. This tutorial covers: combining Latex and Madagascar in a reproducible fashion, adding your own Latex style-sheets and macros, and building an SEG expanded abstract.<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|- <br />
| Intro to Reproducible documents || 0 || Introduction to reproducible documents and the framework <br />
|-<br />
| Using Latex || 1 || Create a simple document that uses Latex and Madagascar together.<br />
|-<br />
| Slides || 2 || Create a Beamer presentation using Madagascar.<br />
|-<br />
| SEG || 2 || Create an SEG abstract using Madagascar.<br />
|-<br />
| Geophysics || 3 || Create a Geophysics paper using Madagascar.<br />
|-<br />
| Reproduce past research || 3 || Reproduce someone else's research using Madagascar and Latex.<br />
|-<br />
| Adding custom macros || 4 || Adding your own macros for Latex documents using Madagascar.<br />
|- <br />
| Adding custom style sheets || 5 || Add or change style sheets to suit your own purposes easily using Madagascar.<br />
|}<br />
<br />
= Tasks = <br />
<br />
These tutorials are side tutorials that show how to perform specific tasks. You should have completed the Users tutorials before using these tutorials.<br />
<br />
{| border="1"<br />
! Name || Description<br />
|-<br />
| SEG-Y conversion || Read and write SEG-Y data to and from RSF format<br />
|-<br />
| Finite difference modeling || Create physical models and synthesize seismograms using a finite difference modeling code.<br />
|}</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorials&diff=1667Tutorials2011-04-19T06:42:03Z<p>Jgodwin: /* Tasks */</p>
<hr />
<div>Learn Madagascar by completing the tutorial series below. The tutorials are aimed at a few types of individuals: <br />
<br />
1 - Users - Individuals who want to know how to use Madagascar immediately for data processing.<br />
<br />
2 - Developers - Individuals who are already Users, who want to write their own programs and/or contribute to Madagascar.<br />
<br />
3 - Authors - Individuals interested in creating reproducible documents using Madagascar.<br />
<br />
Additionally, we have a series of tutorials that show users how to perform common tasks, such as SEG-Y read/write, and conversion to and from SU formats. <br />
<br />
'''All tutorials are documented by examples in the Madagascar release. You can work alongside the examples!'''<br />
<br />
'''Tutorials are organized into levels. Higher level courses in a section require the lower level courses to be completed first.'''<br />
<br />
= Users =<br />
<br />
The user tutorials are focused on getting a new user running Madagascar from the ground up. These tutorials cover everything from: the command line interface, to advanced SCons functionality. By the end of these tutorials, you should be able to process large datasets using Madagascar very quickly, and write powerful Python scripts that are reproducible.<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|-<br />
| RSF file format || 0 || An introduction to Madagascar and the RSF file format<br />
|-<br />
| Command line interface || 1 || Using the command line interface<br />
|-<br />
| Plotting || 2 || Creating and viewing vplot files<br />
|-<br />
| Intro to SCons || 3 || Creating simple SCons scripts for build control<br />
|-<br />
| Advanced SCons || 4 || Creating advanced SCons scripts<br />
|-<br />
| Advanced SCons II || 5 || Abusing SCons<br />
|- <br />
| Python || 6 || Loops, flow control, functions<br />
|- <br />
| Advanced visualization || 6 || 3D visualization using the Mines JTK and VTK<br />
|}<br />
<br />
= Developers = <br />
<br />
The developer tutorials are targeted to people who are already familiar with processing data in Madagascar. You should have completed the User tutorial series before beginning this tutorial series. This tutorial set covers: designing and developing simple programs in Madagascar, using the various language APIs, and parallel programming. Following completion of this tutorial series, you should be able to write advanced programs in Madagascar that can be contributed back to the community for others to use!<br />
<br />
{| border="1"<br />
! Name !! Level !! Description <br />
|-<br />
| Intro to Development || 0 || Learn how to write simple C programs using Madagascar<br />
|-<br />
| Advanced development || 1 || Learn how to link against other libraries <br />
|- <br />
| API development || 1 || Learn how to write a program in another API (Java, Python, Matlab, Fortran)<br />
|- <br />
| Parallel computing || 2 || Write a program that uses MPI or OpenMP <br />
|- <br />
| High performance Madagascar || 3 || Maximize your program's performance in Madagascar<br />
|}<br />
<br />
= Authors =<br />
<br />
The author tutorials are targeted at those who want to create reproducible documents using Madagascar. You should have completed the User tutorial before attempting these tutorials. This tutorial covers: combining Latex and Madagascar in a reproducible fashion, adding your own Latex style-sheets and macros, and building an SEG expanded abstract.<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|- <br />
| Intro to Reproducible documents || 0 || Introduction to reproducible documents and the framework <br />
|-<br />
| Using Latex || 1 || Create a simple document that uses Latex and Madagascar together.<br />
|-<br />
| Slides || 2 || Create a Beamer presentation using Madagascar.<br />
|-<br />
| SEG || 2 || Create an SEG abstract using Madagascar.<br />
|-<br />
| Geophysics || 3 || Create a Geophysics paper using Madagascar.<br />
|-<br />
| Reproduce past research || 3 || Reproduce someone else's research using Madagascar and Latex.<br />
|-<br />
| Adding custom macros || 4 || Adding your own macros for Latex documents using Madagascar.<br />
|- <br />
| Adding custom style sheets || 5 || Add or change style sheets to suit your own purposes easily using Madagascar.<br />
|}<br />
<br />
= Tasks = <br />
<br />
These tutorials are side tutorials that show how to perform specific tasks. You should have completed the Users tutorials before using these tutorials.<br />
<br />
{| border="1"<br />
! Name || Description<br />
|-<br />
| SEG-Y conversion || Read and write SEG-Y data to and from RSF format<br />
|-<br />
| Finite difference modeling || Create physical models and synthesize seismograms using a finite difference modeling code.<br />
|}</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorials&diff=1666Tutorials2011-04-19T06:40:01Z<p>Jgodwin: /* Authors */</p>
<hr />
<div>Learn Madagascar by completing the tutorial series below. The tutorials are aimed at a few types of individuals: <br />
<br />
1 - Users - Individuals who want to know how to use Madagascar immediately for data processing.<br />
<br />
2 - Developers - Individuals who are already Users, who want to write their own programs and/or contribute to Madagascar.<br />
<br />
3 - Authors - Individuals interested in creating reproducible documents using Madagascar.<br />
<br />
Additionally, we have a series of tutorials that show users how to perform common tasks, such as SEG-Y read/write, and conversion to and from SU formats. <br />
<br />
'''All tutorials are documented by examples in the Madagascar release. You can work alongside the examples!'''<br />
<br />
'''Tutorials are organized into levels. Higher level courses in a section require the lower level courses to be completed first.'''<br />
<br />
= Users =<br />
<br />
The user tutorials are focused on getting a new user running Madagascar from the ground up. These tutorials cover everything from: the command line interface, to advanced SCons functionality. By the end of these tutorials, you should be able to process large datasets using Madagascar very quickly, and write powerful Python scripts that are reproducible.<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|-<br />
| RSF file format || 0 || An introduction to Madagascar and the RSF file format<br />
|-<br />
| Command line interface || 1 || Using the command line interface<br />
|-<br />
| Plotting || 2 || Creating and viewing vplot files<br />
|-<br />
| Intro to SCons || 3 || Creating simple SCons scripts for build control<br />
|-<br />
| Advanced SCons || 4 || Creating advanced SCons scripts<br />
|-<br />
| Advanced SCons II || 5 || Abusing SCons<br />
|- <br />
| Python || 6 || Loops, flow control, functions<br />
|- <br />
| Advanced visualization || 6 || 3D visualization using the Mines JTK and VTK<br />
|}<br />
<br />
= Developers = <br />
<br />
The developer tutorials are targeted to people who are already familiar with processing data in Madagascar. You should have completed the User tutorial series before beginning this tutorial series. This tutorial set covers: designing and developing simple programs in Madagascar, using the various language APIs, and parallel programming. Following completion of this tutorial series, you should be able to write advanced programs in Madagascar that can be contributed back to the community for others to use!<br />
<br />
{| border="1"<br />
! Name !! Level !! Description <br />
|-<br />
| Intro to Development || 0 || Learn how to write simple C programs using Madagascar<br />
|-<br />
| Advanced development || 1 || Learn how to link against other libraries <br />
|- <br />
| API development || 1 || Learn how to write a program in another API (Java, Python, Matlab, Fortran)<br />
|- <br />
| Parallel computing || 2 || Write a program that uses MPI or OpenMP <br />
|- <br />
| High performance Madagascar || 3 || Maximize your program's performance in Madagascar<br />
|}<br />
<br />
= Authors =<br />
<br />
The author tutorials are targeted at those who want to create reproducible documents using Madagascar. You should have completed the User tutorial before attempting these tutorials. This tutorial covers: combining Latex and Madagascar in a reproducible fashion, adding your own Latex style-sheets and macros, and building an SEG expanded abstract.<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|- <br />
| Intro to Reproducible documents || 0 || Introduction to reproducible documents and the framework <br />
|-<br />
| Using Latex || 1 || Create a simple document that uses Latex and Madagascar together.<br />
|-<br />
| Slides || 2 || Create a Beamer presentation using Madagascar.<br />
|-<br />
| SEG || 2 || Create an SEG abstract using Madagascar.<br />
|-<br />
| Geophysics || 3 || Create a Geophysics paper using Madagascar.<br />
|-<br />
| Reproduce past research || 3 || Reproduce someone else's research using Madagascar and Latex.<br />
|-<br />
| Adding custom macros || 4 || Adding your own macros for Latex documents using Madagascar.<br />
|- <br />
| Adding custom style sheets || 5 || Add or change style sheets to suit your own purposes easily using Madagascar.<br />
|}<br />
<br />
= Tasks = <br />
<br />
These tutorials are side tutorials that show how to perform specific tasks. You should have completed the Users tutorials before using these tutorials.</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorials&diff=1665Tutorials2011-04-19T06:38:32Z<p>Jgodwin: /* Authors */</p>
<hr />
<div>Learn Madagascar by completing the tutorial series below. The tutorials are aimed at a few types of individuals: <br />
<br />
1 - Users - Individuals who want to know how to use Madagascar immediately for data processing.<br />
<br />
2 - Developers - Individuals who are already Users, who want to write their own programs and/or contribute to Madagascar.<br />
<br />
3 - Authors - Individuals interested in creating reproducible documents using Madagascar.<br />
<br />
Additionally, we have a series of tutorials that show users how to perform common tasks, such as SEG-Y read/write, and conversion to and from SU formats. <br />
<br />
'''All tutorials are documented by examples in the Madagascar release. You can work alongside the examples!'''<br />
<br />
'''Tutorials are organized into levels. Higher level courses in a section require the lower level courses to be completed first.'''<br />
<br />
= Users =<br />
<br />
The user tutorials are focused on getting a new user running Madagascar from the ground up. These tutorials cover everything from: the command line interface, to advanced SCons functionality. By the end of these tutorials, you should be able to process large datasets using Madagascar very quickly, and write powerful Python scripts that are reproducible.<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|-<br />
| RSF file format || 0 || An introduction to Madagascar and the RSF file format<br />
|-<br />
| Command line interface || 1 || Using the command line interface<br />
|-<br />
| Plotting || 2 || Creating and viewing vplot files<br />
|-<br />
| Intro to SCons || 3 || Creating simple SCons scripts for build control<br />
|-<br />
| Advanced SCons || 4 || Creating advanced SCons scripts<br />
|-<br />
| Advanced SCons II || 5 || Abusing SCons<br />
|- <br />
| Python || 6 || Loops, flow control, functions<br />
|- <br />
| Advanced visualization || 6 || 3D visualization using the Mines JTK and VTK<br />
|}<br />
<br />
= Developers = <br />
<br />
The developer tutorials are targeted to people who are already familiar with processing data in Madagascar. You should have completed the User tutorial series before beginning this tutorial series. This tutorial set covers: designing and developing simple programs in Madagascar, using the various language APIs, and parallel programming. Following completion of this tutorial series, you should be able to write advanced programs in Madagascar that can be contributed back to the community for others to use!<br />
<br />
{| border="1"<br />
! Name !! Level !! Description <br />
|-<br />
| Intro to Development || 0 || Learn how to write simple C programs using Madagascar<br />
|-<br />
| Advanced development || 1 || Learn how to link against other libraries <br />
|- <br />
| API development || 1 || Learn how to write a program in another API (Java, Python, Matlab, Fortran)<br />
|- <br />
| Parallel computing || 2 || Write a program that uses MPI or OpenMP <br />
|- <br />
| High performance Madagascar || 3 || Maximize your program's performance in Madagascar<br />
|}<br />
<br />
= Authors =<br />
<br />
The author tutorials are targeted at those who want to create reproducible documents using Madagascar. You should have completed the User tutorial before attempting these tutorials. This tutorial covers: combining Latex and Madagascar in a reproducible fashion, adding your own Latex style-sheets and macros, and building an SEG expanded abstract.<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|- <br />
| Intro to Reproducible documents || 0 || Introduction to reproducible documents and the framework <br />
|-<br />
| Using Latex || 1 || Create a simple document that uses Latex and Madagascar together.<br />
|-<br />
| Slides || 2 || Create a Beamer presentation using Madagascar.<br />
|-<br />
| SEG || 2 || Create an SEG abstract using Madagascar.<br />
|-<br />
| Geophysics || 3 || Create a Geophysics paper using Madagascar.<br />
|-<br />
| Reproduce past research || 3 || Reproduce someone else's research using Madagascar and Latex.<br />
|-<br />
| Adding custom macros || 4 || Adding your own macros for Latex documents using Madagascar.<br />
| - <br />
| Adding custom style sheets || 5 || Add or change style sheets to suit your own purposes easily using Madagascar.<br />
|}<br />
<br />
= Tasks = <br />
<br />
These tutorials are side tutorials that show how to perform specific tasks. You should have completed the Users tutorials before using these tutorials.</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorials&diff=1664Tutorials2011-04-19T06:32:55Z<p>Jgodwin: </p>
<hr />
<div>Learn Madagascar by completing the tutorial series below. The tutorials are aimed at a few types of individuals: <br />
<br />
1 - Users - Individuals who want to know how to use Madagascar immediately for data processing.<br />
<br />
2 - Developers - Individuals who are already Users, who want to write their own programs and/or contribute to Madagascar.<br />
<br />
3 - Authors - Individuals interested in creating reproducible documents using Madagascar.<br />
<br />
Additionally, we have a series of tutorials that show users how to perform common tasks, such as SEG-Y read/write, and conversion to and from SU formats. <br />
<br />
'''All tutorials are documented by examples in the Madagascar release. You can work alongside the examples!'''<br />
<br />
'''Tutorials are organized into levels. Higher level courses in a section require the lower level courses to be completed first.'''<br />
<br />
= Users =<br />
<br />
The user tutorials are focused on getting a new user running Madagascar from the ground up. These tutorials cover everything from: the command line interface, to advanced SCons functionality. By the end of these tutorials, you should be able to process large datasets using Madagascar very quickly, and write powerful Python scripts that are reproducible.<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|-<br />
| RSF file format || 0 || An introduction to Madagascar and the RSF file format<br />
|-<br />
| Command line interface || 1 || Using the command line interface<br />
|-<br />
| Plotting || 2 || Creating and viewing vplot files<br />
|-<br />
| Intro to SCons || 3 || Creating simple SCons scripts for build control<br />
|-<br />
| Advanced SCons || 4 || Creating advanced SCons scripts<br />
|-<br />
| Advanced SCons II || 5 || Abusing SCons<br />
|- <br />
| Python || 6 || Loops, flow control, functions<br />
|- <br />
| Advanced visualization || 6 || 3D visualization using the Mines JTK and VTK<br />
|}<br />
<br />
= Developers = <br />
<br />
The developer tutorials are targeted to people who are already familiar with processing data in Madagascar. You should have completed the User tutorial series before beginning this tutorial series. This tutorial set covers: designing and developing simple programs in Madagascar, using the various language APIs, and parallel programming. Following completion of this tutorial series, you should be able to write advanced programs in Madagascar that can be contributed back to the community for others to use!<br />
<br />
{| border="1"<br />
! Name !! Level !! Description <br />
|-<br />
| Intro to Development || 0 || Learn how to write simple C programs using Madagascar<br />
|-<br />
| Advanced development || 1 || Learn how to link against other libraries <br />
|- <br />
| API development || 1 || Learn how to write a program in another API (Java, Python, Matlab, Fortran)<br />
|- <br />
| Parallel computing || 2 || Write a program that uses MPI or OpenMP <br />
|- <br />
| High performance Madagascar || 3 || Maximize your program's performance in Madagascar<br />
|}<br />
<br />
= Authors =<br />
<br />
The author tutorials are targeted at those who want to create reproducible documents using Madagascar. You should have completed the User tutorial before attempting these tutorials. This tutorial covers: combining Latex and Madagascar in a reproducible fashion, adding your own Latex style-sheets and macros, and building an SEG expanded abstract.<br />
<br />
= Tasks = <br />
<br />
These tutorials are side tutorials that show how to perform specific tasks. You should have completed the Users tutorials before using these tutorials.</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorials&diff=1663Tutorials2011-04-19T06:31:42Z<p>Jgodwin: /* Developers */</p>
<hr />
<div>Learn Madagascar by completing the tutorial series below. The tutorials are aimed at a few types of individuals: <br />
<br />
1 - Users - Individuals who want to know how to use Madagascar immediately for data processing.<br />
<br />
2 - Developers - Individuals who are already Users, who want to write their own programs and/or contribute to Madagascar.<br />
<br />
3 - Authors - Individuals interested in creating reproducible documents using Madagascar.<br />
<br />
Additionally, we have a series of tutorials that show users how to perform common tasks, such as SEG-Y read/write, and conversion to and from SU formats. <br />
<br />
'''All tutorials are documented by examples in the Madagascar release. You can work alongside the examples!'''<br />
<br />
'''Tutorials are organized into levels. Higher level courses in a section require the lower level courses to be completed first.'''<br />
<br />
= Users =<br />
<br />
The user tutorials are focused on getting a new user running Madagascar from the ground up. These tutorials cover everything from: the command line interface, to advanced SCons functionality. By the end of these tutorials, you should be able to process large datasets using Madagascar very quickly, and write powerful Python scripts that are reproducible.<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|-<br />
| RSF file format || 0 || An introduction to Madagascar and the RSF file format<br />
|-<br />
| Command line interface || 1 || Using the command line interface<br />
|-<br />
| Plotting || 2 || Creating and viewing vplot files<br />
|-<br />
| Intro to SCons || 3 || Creating simple SCons scripts for build control<br />
|-<br />
| Advanced SCons || 4 || Creating advanced SCons scripts<br />
|-<br />
| Advanced SCons II || 5 || Abusing SCons<br />
|- <br />
| Python || 6 || Loops, flow control, functions<br />
|- <br />
| Advanced visualization || 6 || 3D visualization using the Mines JTK and VTK<br />
|}<br />
<br />
= Developers = <br />
<br />
The developer tutorials are targeted to people who are already familiar with processing data in Madagascar. You should have completed the User tutorial series before beginning this tutorial series. This tutorial set covers: designing and developing simple programs in Madagascar, using the various language APIs, and parallel programming. Following completion of this tutorial series, you should be able to write advanced programs in Madagascar that can be contributed back to the community for others to use!<br />
<br />
{| border="1"<br />
! Name !! Level !! Description <br />
|-<br />
| Intro to Development || 0 || Learn how to write simple C programs using Madagascar<br />
|-<br />
| Advanced development || 1 || Learn how to link against other libraries <br />
| - <br />
| API development || 1 || Learn how to write a program in another API (Java, Python, Matlab, Fortran)<br />
| - <br />
| Parallel computing || 2 || Write a program that uses MPI or OpenMP <br />
| - <br />
| High performance Madagascar || 3 || Maximize your program's performance in Madagascar<br />
|}<br />
<br />
= Authors =<br />
<br />
The author tutorials are targeted at those who want to create reproducible documents using Madagascar. You should have completed the User tutorial before attempting these tutorials. This tutorial covers: combining Latex and Madagascar in a reproducible fashion, adding your own Latex style-sheets and macros, and building an SEG expanded abstract.<br />
<br />
= Tasks = <br />
<br />
These tutorials are side tutorials that show how to perform specific tasks. You should have completed the Users tutorials before using these tutorials.</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorials&diff=1662Tutorials2011-04-19T06:31:25Z<p>Jgodwin: /* Developers */</p>
<hr />
<div>Learn Madagascar by completing the tutorial series below. The tutorials are aimed at a few types of individuals: <br />
<br />
1 - Users - Individuals who want to know how to use Madagascar immediately for data processing.<br />
<br />
2 - Developers - Individuals who are already Users, who want to write their own programs and/or contribute to Madagascar.<br />
<br />
3 - Authors - Individuals interested in creating reproducible documents using Madagascar.<br />
<br />
Additionally, we have a series of tutorials that show users how to perform common tasks, such as SEG-Y read/write, and conversion to and from SU formats. <br />
<br />
'''All tutorials are documented by examples in the Madagascar release. You can work alongside the examples!'''<br />
<br />
'''Tutorials are organized into levels. Higher level courses in a section require the lower level courses to be completed first.'''<br />
<br />
= Users =<br />
<br />
The user tutorials are focused on getting a new user running Madagascar from the ground up. These tutorials cover everything from: the command line interface, to advanced SCons functionality. By the end of these tutorials, you should be able to process large datasets using Madagascar very quickly, and write powerful Python scripts that are reproducible.<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|-<br />
| RSF file format || 0 || An introduction to Madagascar and the RSF file format<br />
|-<br />
| Command line interface || 1 || Using the command line interface<br />
|-<br />
| Plotting || 2 || Creating and viewing vplot files<br />
|-<br />
| Intro to SCons || 3 || Creating simple SCons scripts for build control<br />
|-<br />
| Advanced SCons || 4 || Creating advanced SCons scripts<br />
|-<br />
| Advanced SCons II || 5 || Abusing SCons<br />
|- <br />
| Python || 6 || Loops, flow control, functions<br />
|- <br />
| Advanced visualization || 6 || 3D visualization using the Mines JTK and VTK<br />
|}<br />
<br />
= Developers = <br />
<br />
The developer tutorials are targeted to people who are already familiar with processing data in Madagascar. You should have completed the User tutorial series before beginning this tutorial series. This tutorial set covers: designing and developing simple programs in Madagascar, using the various language APIs, and parallel programming. Following completion of this tutorial series, you should be able to write advanced programs in Madagascar that can be contributed back to the community for others to use!<br />
<br />
{| border="1"<br />
! Name !! Level !! Description !!<br />
|-<br />
| Intro to Development || 0 || Learn how to write simple C programs using Madagascar<br />
|-<br />
| Advanced development || 1 || Learn how to link against other libraries <br />
| - <br />
| API development || 1 || Learn how to write a program in another API (Java, Python, Matlab, Fortran)<br />
| - <br />
| Parallel computing || 2 || Write a program that uses MPI or OpenMP <br />
| - <br />
| High performance Madagascar || 3 || Maximize your program's performance in Madagascar<br />
|}<br />
<br />
= Authors =<br />
<br />
The author tutorials are targeted at those who want to create reproducible documents using Madagascar. You should have completed the User tutorial before attempting these tutorials. This tutorial covers: combining Latex and Madagascar in a reproducible fashion, adding your own Latex style-sheets and macros, and building an SEG expanded abstract.<br />
<br />
= Tasks = <br />
<br />
These tutorials are side tutorials that show how to perform specific tasks. You should have completed the Users tutorials before using these tutorials.</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorials&diff=1661Tutorials2011-04-19T06:30:50Z<p>Jgodwin: /* Developers */</p>
<hr />
<div>Learn Madagascar by completing the tutorial series below. The tutorials are aimed at a few types of individuals: <br />
<br />
1 - Users - Individuals who want to know how to use Madagascar immediately for data processing.<br />
<br />
2 - Developers - Individuals who are already Users, who want to write their own programs and/or contribute to Madagascar.<br />
<br />
3 - Authors - Individuals interested in creating reproducible documents using Madagascar.<br />
<br />
Additionally, we have a series of tutorials that show users how to perform common tasks, such as SEG-Y read/write, and conversion to and from SU formats. <br />
<br />
'''All tutorials are documented by examples in the Madagascar release. You can work alongside the examples!'''<br />
<br />
'''Tutorials are organized into levels. Higher level courses in a section require the lower level courses to be completed first.'''<br />
<br />
= Users =<br />
<br />
The user tutorials are focused on getting a new user running Madagascar from the ground up. These tutorials cover everything from: the command line interface, to advanced SCons functionality. By the end of these tutorials, you should be able to process large datasets using Madagascar very quickly, and write powerful Python scripts that are reproducible.<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|-<br />
| RSF file format || 0 || An introduction to Madagascar and the RSF file format<br />
|-<br />
| Command line interface || 1 || Using the command line interface<br />
|-<br />
| Plotting || 2 || Creating and viewing vplot files<br />
|-<br />
| Intro to SCons || 3 || Creating simple SCons scripts for build control<br />
|-<br />
| Advanced SCons || 4 || Creating advanced SCons scripts<br />
|-<br />
| Advanced SCons II || 5 || Abusing SCons<br />
|- <br />
| Python || 6 || Loops, flow control, functions<br />
|- <br />
| Advanced visualization || 6 || 3D visualization using the Mines JTK and VTK<br />
|}<br />
<br />
= Developers = <br />
<br />
The developer tutorials are targeted to people who are already familiar with processing data in Madagascar. You should have completed the User tutorial series before beginning this tutorial series. This tutorial set covers: designing and developing simple programs in Madagascar, using the various language APIs, and parallel programming. Following completion of this tutorial series, you should be able to write advanced programs in Madagascar that can be contributed back to the community for others to use!<br />
<br />
{| border="1"<br />
! Name !! Level !! Description !!<br />
|-<br />
| Intro to Development || 0 || Learn how to write simple C programs using Madagascar<br />
|-<br />
| Advanced development || 1 || Learn how to link against other libraries <br />
| - <br />
| API development || 1 || Learn how to write a program in another API (Java, Python, Matlab, Fortran)<br />
| - <br />
| Parallel computing || 2 || Write a program that uses MPI or OpenMP <br />
| - <br />
| High performance Madagascar || 3 || Maximize your program's performance in Madagascar<br />
|-<br />
|}<br />
<br />
= Authors =<br />
<br />
The author tutorials are targeted at those who want to create reproducible documents using Madagascar. You should have completed the User tutorial before attempting these tutorials. This tutorial covers: combining Latex and Madagascar in a reproducible fashion, adding your own Latex style-sheets and macros, and building an SEG expanded abstract.<br />
<br />
= Tasks = <br />
<br />
These tutorials are side tutorials that show how to perform specific tasks. You should have completed the Users tutorials before using these tutorials.</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorials&diff=1660Tutorials2011-04-19T06:30:29Z<p>Jgodwin: /* Developers */</p>
<hr />
<div>Learn Madagascar by completing the tutorial series below. The tutorials are aimed at a few types of individuals: <br />
<br />
1 - Users - Individuals who want to know how to use Madagascar immediately for data processing.<br />
<br />
2 - Developers - Individuals who are already Users, who want to write their own programs and/or contribute to Madagascar.<br />
<br />
3 - Authors - Individuals interested in creating reproducible documents using Madagascar.<br />
<br />
Additionally, we have a series of tutorials that show users how to perform common tasks, such as SEG-Y read/write, and conversion to and from SU formats. <br />
<br />
'''All tutorials are documented by examples in the Madagascar release. You can work alongside the examples!'''<br />
<br />
'''Tutorials are organized into levels. Higher level courses in a section require the lower level courses to be completed first.'''<br />
<br />
= Users =<br />
<br />
The user tutorials are focused on getting a new user running Madagascar from the ground up. These tutorials cover everything from: the command line interface, to advanced SCons functionality. By the end of these tutorials, you should be able to process large datasets using Madagascar very quickly, and write powerful Python scripts that are reproducible.<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|-<br />
| RSF file format || 0 || An introduction to Madagascar and the RSF file format<br />
|-<br />
| Command line interface || 1 || Using the command line interface<br />
|-<br />
| Plotting || 2 || Creating and viewing vplot files<br />
|-<br />
| Intro to SCons || 3 || Creating simple SCons scripts for build control<br />
|-<br />
| Advanced SCons || 4 || Creating advanced SCons scripts<br />
|-<br />
| Advanced SCons II || 5 || Abusing SCons<br />
|- <br />
| Python || 6 || Loops, flow control, functions<br />
|- <br />
| Advanced visualization || 6 || 3D visualization using the Mines JTK and VTK<br />
|}<br />
<br />
= Developers = <br />
<br />
The developer tutorials are targeted to people who are already familiar with processing data in Madagascar. You should have completed the User tutorial series before beginning this tutorial series. This tutorial set covers: designing and developing simple programs in Madagascar, using the various language APIs, and parallel programming. Following completion of this tutorial series, you should be able to write advanced programs in Madagascar that can be contributed back to the community for others to use!<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|-<br />
| Intro to Development || 0 || Learn how to write simple C programs using Madagascar<br />
|-<br />
| Advanced development || 1 || Learn how to link against other libraries <br />
| - <br />
| API development || 1 || Learn how to write a program in another API (Java, Python, Matlab, Fortran)<br />
| - <br />
| Parallel computing || 2 || Write a program that uses MPI or OpenMP <br />
| - <br />
| High performance Madagascar || 3 || Maximize your program's performance in Madagascar<br />
|-<br />
|}<br />
<br />
= Authors =<br />
<br />
The author tutorials are targeted at those who want to create reproducible documents using Madagascar. You should have completed the User tutorial before attempting these tutorials. This tutorial covers: combining Latex and Madagascar in a reproducible fashion, adding your own Latex style-sheets and macros, and building an SEG expanded abstract.<br />
<br />
= Tasks = <br />
<br />
These tutorials are side tutorials that show how to perform specific tasks. You should have completed the Users tutorials before using these tutorials.</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorials&diff=1659Tutorials2011-04-19T06:26:33Z<p>Jgodwin: </p>
<hr />
<div>Learn Madagascar by completing the tutorial series below. The tutorials are aimed at a few types of individuals: <br />
<br />
1 - Users - Individuals who want to know how to use Madagascar immediately for data processing.<br />
<br />
2 - Developers - Individuals who are already Users, who want to write their own programs and/or contribute to Madagascar.<br />
<br />
3 - Authors - Individuals interested in creating reproducible documents using Madagascar.<br />
<br />
Additionally, we have a series of tutorials that show users how to perform common tasks, such as SEG-Y read/write, and conversion to and from SU formats. <br />
<br />
'''All tutorials are documented by examples in the Madagascar release. You can work alongside the examples!'''<br />
<br />
'''Tutorials are organized into levels. Higher level courses in a section require the lower level courses to be completed first.'''<br />
<br />
= Users =<br />
<br />
The user tutorials are focused on getting a new user running Madagascar from the ground up. These tutorials cover everything from: the command line interface, to advanced SCons functionality. By the end of these tutorials, you should be able to process large datasets using Madagascar very quickly, and write powerful Python scripts that are reproducible.<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|-<br />
| RSF file format || 0 || An introduction to Madagascar and the RSF file format<br />
|-<br />
| Command line interface || 1 || Using the command line interface<br />
|-<br />
| Plotting || 2 || Creating and viewing vplot files<br />
|-<br />
| Intro to SCons || 3 || Creating simple SCons scripts for build control<br />
|-<br />
| Advanced SCons || 4 || Creating advanced SCons scripts<br />
|-<br />
| Advanced SCons II || 5 || Abusing SCons<br />
|- <br />
| Python || 6 || Loops, flow control, functions<br />
|- <br />
| Advanced visualization || 6 || 3D visualization using the Mines JTK and VTK<br />
|}<br />
<br />
= Developers = <br />
<br />
The developer tutorials are targeted to people who are already familiar with processing data in Madagascar. You should have completed the User tutorial series before beginning this tutorial series. This tutorial set covers: designing and developing simple programs in Madagascar, using the various language APIs, and parallel programming. Following completion of this tutorial series, you should be able to write advanced programs in Madagascar that can be contributed back to the community for others to use!<br />
<br />
= Authors =<br />
<br />
The author tutorials are targeted at those who want to create reproducible documents using Madagascar. You should have completed the User tutorial before attempting these tutorials. This tutorial covers: combining Latex and Madagascar in a reproducible fashion, adding your own Latex style-sheets and macros, and building an SEG expanded abstract.<br />
<br />
= Tasks = <br />
<br />
These tutorials are side tutorials that show how to perform specific tasks. You should have completed the Users tutorials before using these tutorials.</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorials&diff=1658Tutorials2011-04-19T06:24:44Z<p>Jgodwin: /* Users */</p>
<hr />
<div>Learn Madagascar by completing the tutorial series below. The tutorials are aimed at two types of individuals: <br />
<br />
1 - Users - Individuals who want to know how to use Madagascar immediately for data processing.<br />
<br />
2 - Developers - Individuals who are already Users, who want to write their own programs and/or contribute to Madagascar.<br />
<br />
3 - Authors - Individuals interested in creating reproducible documents using Madagascar.<br />
<br />
Additionally, we have a series of tutorials that show users how to perform common tasks, such as SEG-Y read/write, and conversion to and from SU formats. <br />
<br />
'''All tutorials are documented by examples in the Madagascar release. You can work alongside the examples!'''<br />
<br />
= Users =<br />
<br />
The user tutorials are focused on getting a new user running Madagascar from the ground up. These tutorials cover everything from: the command line interface, to advanced SCons functionality. By the end of these tutorials, you should be able to process large datasets using Madagascar very quickly, and write powerful Python scripts that are reproducible.<br />
<br />
{| border="1"<br />
! Name !! Level !! Description<br />
|-<br />
| RSF file format || 0 || An introduction to Madagascar and the RSF file format<br />
|-<br />
| Command line interface || 1 || Using the command line interface<br />
|-<br />
| Plotting || 2 || Creating and viewing vplot files<br />
|-<br />
| Intro to SCons || 3 || Creating simple SCons scripts for build control<br />
|-<br />
| Advanced SCons || 4 || Creating advanced SCons scripts<br />
|-<br />
| Advanced SCons II || 5 || Abusing SCons<br />
|- <br />
| Python || 6 || Loops, flow control, functions<br />
|- <br />
| Advanced visualization || 6 || 3D visualization using the Mines JTK and VTK<br />
|}<br />
<br />
= Developers = <br />
<br />
The developer tutorials are targeted to people who are already familiar with processing data in Madagascar. You should have completed the User tutorial series before beginning this tutorial series. This tutorial set covers: designing and developing simple programs in Madagascar, using the various language APIs, and parallel programming. Following completion of this tutorial series, you should be able to write advanced programs in Madagascar that can be contributed back to the community for others to use!<br />
<br />
= Authors =<br />
<br />
The author tutorials are targeted at those who want to create reproducible documents using Madagascar. You should have completed the User tutorial before attempting these tutorials. This tutorial covers: combining Latex and Madagascar in a reproducible fashion, adding your own Latex style-sheets and macros, and building an SEG expanded abstract.<br />
<br />
= Tasks = <br />
<br />
These tutorials are side tutorials that show how to perform specific tasks. You should have completed the Users tutorials before using these tutorials.</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorials&diff=1657Tutorials2011-04-19T06:16:16Z<p>Jgodwin: /* Users */</p>
<hr />
<div>Learn Madagascar by completing the tutorial series below. The tutorials are aimed at two types of individuals: <br />
<br />
1 - Users - Individuals who want to know how to use Madagascar immediately for data processing.<br />
<br />
2 - Developers - Individuals who are already Users, who want to write their own programs and/or contribute to Madagascar.<br />
<br />
3 - Authors - Individuals interested in creating reproducible documents using Madagascar.<br />
<br />
Additionally, we have a series of tutorials that show users how to perform common tasks, such as SEG-Y read/write, and conversion to and from SU formats. <br />
<br />
'''All tutorials are documented by examples in the Madagascar release. You can work alongside the examples!'''<br />
<br />
= Users =<br />
<br />
The user tutorials are focused on getting a new user running Madagascar from the ground up. These tutorials cover everything from: the command line interface, to advanced SCons functionality. By the end of these tutorials, you should be able to process large datasets using Madagascar very quickly, and write powerful Python scripts that are reproducible.<br />
<br />
= Developers = <br />
<br />
The developer tutorials are targeted to people who are already familiar with processing data in Madagascar. You should have completed the User tutorial series before beginning this tutorial series. This tutorial set covers: designing and developing simple programs in Madagascar, using the various language APIs, and parallel programming. Following completion of this tutorial series, you should be able to write advanced programs in Madagascar that can be contributed back to the community for others to use!<br />
<br />
= Authors =<br />
<br />
The author tutorials are targeted at those who want to create reproducible documents using Madagascar. You should have completed the User tutorial before attempting these tutorials. This tutorial covers: combining Latex and Madagascar in a reproducible fashion, adding your own Latex style-sheets and macros, and building an SEG expanded abstract.<br />
<br />
= Tasks = <br />
<br />
These tutorials are side tutorials that show how to perform specific tasks. You should have completed the Users tutorials before using these tutorials.</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tutorials&diff=1656Tutorials2011-04-19T06:13:08Z<p>Jgodwin: This is the tutorials page.</p>
<hr />
<div>Learn Madagascar by completing the tutorial series below. The tutorials are aimed at two types of individuals: <br />
<br />
1 - Users - Individuals who want to know how to use Madagascar immediately for data processing.<br />
<br />
2 - Developers - Individuals who are already Users, who want to write their own programs and/or contribute to Madagascar.<br />
<br />
3 - Authors - Individuals interested in creating reproducible documents using Madagascar.<br />
<br />
Additionally, we have a series of tutorials that show users how to perform common tasks, such as SEG-Y read/write, and conversion to and from SU formats. <br />
<br />
'''All tutorials are documented by examples in the Madagascar release. You can work alongside the examples!'''<br />
<br />
= Users =<br />
<br />
The user tutorials are focused on getting a new user running Madagascar from the ground up. These tutorials cover everything from: the command line interface, to advanced SCons functionality. By the end of these tutorials, you should be able to process large datasets using Madagascar very quickly, and write powerful Python scripts that are reproducible. <br />
<br />
= Developers = <br />
<br />
The developer tutorials are targeted to people who are already familiar with processing data in Madagascar. You should have completed the User tutorial series before beginning this tutorial series. This tutorial set covers: designing and developing simple programs in Madagascar, using the various language APIs, and parallel programming. Following completion of this tutorial series, you should be able to write advanced programs in Madagascar that can be contributed back to the community for others to use!<br />
<br />
= Authors =<br />
<br />
The author tutorials are targeted at those who want to create reproducible documents using Madagascar. You should have completed the User tutorial before attempting these tutorials. This tutorial covers: combining Latex and Madagascar in a reproducible fashion, adding your own Latex style-sheets and macros, and building an SEG expanded abstract.<br />
<br />
= Tasks = <br />
<br />
These tutorials are side tutorials that show how to perform specific tasks. You should have completed the Users tutorials before using these tutorials.</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=File:Tkmadagascar-3.png&diff=1561File:Tkmadagascar-3.png2011-01-07T21:58:04Z<p>Jgodwin: Demo of program browser.</p>
<hr />
<div>Demo of program browser.</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=File:Tkmadagascar.png&diff=1560File:Tkmadagascar.png2011-01-07T18:48:28Z<p>Jgodwin: Overview of tkMadagascar.</p>
<hr />
<div>Overview of tkMadagascar.</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=TkMadagascar&diff=1552TkMadagascar2011-01-03T22:11:31Z<p>Jgodwin: Tkmadagascar moved to TkMadagascar: consistency</p>
<hr />
<div>tkMadagascar is a pure-Python, Tkinter graphical user interface for Madagascar. It allows users to construct processing flows using a graphical tool as well as on the command line. <br />
<br />
tkMadagascar is comprised of two main programs: the standalone program browser and the main user interface.<br />
<br />
= Video tutorials = <br />
<br />
Please view the following tutorials on YouTube for a quick introduction to tkMadagascar:<br />
<br />
'''[http://www.youtube.com/watch?v=q5O07-XGvhM Standalone program browser] '''<br />
<br />
'''[http://www.youtube.com/watch?v=piQTfk0aUfo Introduction to tkMadagascar] '''<br />
<br />
'''[http://www.youtube.com/watch?v=eJEAP9OJFTA Linking flows in tkMadagascar] '''<br />
<br />
'''[http://www.youtube.com/watch?v=AEGbOuOyI9c Running SCons from within tkMadagascar]'''<br />
<br />
'''[http://www.youtube.com/watch?v=E8jE_qXfj4A Using templates in tkMadagascar] '''<br />
<br />
'''[http://www.youtube.com/watch?v=Mj3vmzs7rb8 Finite difference modeling in tkMadagascar]'''<br />
<br />
= Program Browser = <br />
<br />
The program browser allows users to quickly view the self-documentation for Madagascar programs. To access the browser simply enter: '''sfbrowser''' on the command prompt. <br />
<br />
The browser is a single window consisting of multiple frames. To the left, is the area where the self-documentation will show for RSF programs. On the right is a list of all Madagascar programs contained within your local installation. This list is repopulated everytime that the browser is run, so it will be up-to-date provided that you have updated the Madagascar self-documentation (via a reinstall). <br />
<br />
<br />
== Search by name ==<br />
<br />
To select programs, simply double-click on their names in the program list. If you know the name of your program, you can enter it into the box to the left of the '''Find Program''' button, and then press '''Find Program''' which will take you to the program that you requested. <br />
<br />
== Search by functionality == <br />
<br />
Additionally, you can search program descriptions if you are not sure which program to use for a specific task. To do so, click on '''Search by functionality''', which opens a separate window. Type the keyword or phrase you want to look for in program descriptions. For example, to look for programs to add RSF files together, we might search for "add". Then click '''Search'''. Once the result list is populated, you can either double-click or click the '''Select''' button, to bring that programs self-documentation into the other window.<br />
<br />
= Main interface =<br />
<br />
The main interface is accessed by entering: '''sfgui''' on the command line. It allows users to create and manage processing flows using Madagascar and SCons.<br />
<br />
== Sandbox ==<br />
<br />
The main window of the interface is called the "Sandbox." It is where all of your Flows, Plots, and Results will show up as you add and configure them. The Sandbox is also the home screen. Closing the Sandbox terminates tkMadagascar.<br />
<br />
The Sandbox has the following menus:<br />
<br />
=== File === <br />
<br />
The File menu handles file input/output operations. <br />
<br />
New - Resets the Sandbox.<br />
<br />
Load state - Load the previous state of a saved Sandbox, or load items from a saved Sandbox.<br />
<br />
Save state - Save the state of the Sandbox (includes all items attached to a Sandbox). <br />
<br />
Export to SConstruct - Export all Flows, Plots and Result commands to an SConstruct of your choosing for later execution on the command line.<br />
<br />
Close - terminate tkMadagascar.<br />
<br />
=== View === <br />
<br />
The view menu lets you choose which other windows to show:<br />
<br />
Program browser, lets you find and select programs to add to your Sandbox.<br />
Log, lets you view the output of running processes.<br />
<br />
=== Run === <br />
<br />
The run menu lets you execute commands from the command line on the items attached to your Sandbox. List of commands is below:<br />
<br />
scons - build Results and their dependencies<br />
<br />
scons view - build Results and their dependencies, try to open a plot command for each Result<br />
<br />
scons lock - build Results and save them to $RSFFIGS<br />
<br />
scons -c - clean the local directory<br />
<br />
scons -n - try a dry-run of scons<br />
<br />
== Program browser == <br />
<br />
The program browser is nearly identical to the standalone version mentioned above, but this version has three additional buttons:<br />
<br />
=== Add Flow === <br />
<br />
Add the selected program as a Flow item to the Sandbox. Flows have black outlines.<br />
<br />
=== Add Plot ===<br />
<br />
Add the selected program as a Plot item to the Sandbox. Plots have purple outlines.<br />
<br />
=== Add Result === <br />
<br />
Add the selected program as a Result item to the Sandbox. Results have blue outlines.<br />
<br />
== Log == <br />
<br />
The log updates you on the status of a running process. You are only allowed to have 1 (one) running process at a time. If the child process is hanging, you may kill the process simply by clicking '''Kill process'''. The process is then killed immediately, without a clean termination.<br />
<br />
== General workflow ==<br />
<br />
=== A new session === <br />
<br />
When a new instance of tkMadagascar is opened, the user is presented with an empty Sandbox. To get started, the user should open the '''Program browser''' from the '''View''' menu. The user may then browse, select, and add as many Flows, Plots or Results as they would like from the Program browser. <br />
<br />
=== Interacting with Flows, Plots and Results === <br />
<br />
Flows, Plots and Results appear in the Sandbox after they are added by the Program browser. All behaviors and actions that we describe are equally valid for Flows, Plots, and Results. For simplicity, we refer to only Flows from here on.<br />
<br />
You may move Flows by clicking and dragging with the left mouse-button. Additionally, all Flows are initially added to the Sandbox in the '''unconfigured''' state. To configure a Flow you must edit its parameters, selecting valid values for the parameters that you wish to set. To edit a Flow's parameters, you can '''right-click''' over the Flow, which will bring up a drop-down menu. Select '''Edit parameters''' from this drop-down menu, which opens a menu with a list of parameters and entry boxes.<br />
<br />
=== Configuring Flows ===<br />
<br />
Once the '''Edit parameters:''' window is open, you can simply input values for the parameters that you want to set. You only need to enter the value, you do not need to enter the value in "key=val" format. There are some special parameters that every Flow has:<br />
<br />
'''output''' - the name or names of files that you want to output to. If multiple files, then separate the names with a space. You do not need to include '.rsf' on the end of file names.<br />
<br />
'''input''' - the name or names of files that you want to input to. Same rules as above.<br />
<br />
'''custom''' - a raw string of any additional parameters that you want to set. You must set these parameters in "key=val" format, unlike the other parameters. There is no parameter checking for parameters set this way. Multiple parameters should be separated by spaces.<br />
<br />
Additionally, some programs have parameters that work on any axis. For example, sfspike allows the user to set the number of samples (n#) for any axis. These parameters are listed as the parameter name, with the # still attached. These parameters must be set with "key=val" formatting as well. <br />
<br />
For sfspike's n# parameter, you might set: n#= n1=100 n2=100<br />
<br />
Once a Flow is configured, the Flow will change color to have a green background and the name of the output file will appear inside the flow. A green Flow is good-to-go, and does not require any additional configuration. It will be automatically saved, exported, or executed. Unconfigured Flows may be saved, but will not be exported or executed.<br />
<br />
Click '''Accept''' to save your parameter selections.<br />
Click '''Preview''' to see how the Flow would look in an SConstruct (useful for debugging).<br />
Click '''Self-documentation''' to see the Programs self-documentation while editing parameters.<br />
<br />
=== Linking Flows === <br />
<br />
One of the nicest features of Madagascar is that programs can pipe their output to other programs, greatly reducing the need for intermediate files. This functionality is fully supported by tkMadagascar. To link two Flows, right click on the flow that you want to link to another Flow, and select ''' Link'''. The cursor will change to a cross-hair to indicate that you are in '''Link''' mode. Once in '''Link''' mode, click on the Flow that you want to link to. The Flow that is selected for linking is assumed to have desired output for the Flow that you right-clicked on. <br />
<br />
Once Linked, the two Flows move together, their borders change color, and their input and output parameters are automatically changed to reflect the fact that one is piping into the other. The border colors change as follows:<br />
Flows become light gray,<br />
Plots become light purple,<br />
Results become light blue.<br />
<br />
To '''Unlink''' a Flow, simply '''right-click''' on the Flow you wish to unlink, and then select unlink. The Flow will be detached. The other Flows in the Linked Flow will be detached as well, or placed into separate Linked Flows.<br />
<br />
=== Deleting Flows === <br />
<br />
To delete a Flow from the Sandbox simply '''right-click''' on the Flow, and select '''Delete'''. If you select '''Delete''' for a Linked Flow, then you will delete all Flows linked to it.<br />
<br />
= Requirements = <br />
tkMadagascar requires Python 2.5 or higher, and Tkinter 8.0 or higher. Tkinter is included by default with your Python installation, so you will have to upgrade your Python installation to a higher version to upgrade Tkinter if needed. If in doubt, try to run tkMadagascar first, before upgrading, as your version may still work properly.<br />
<br />
'''Note: you must have a fully functional RSF installation before you can use tkMadagascar.'''</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=Tkmadagascar&diff=1553Tkmadagascar2011-01-03T22:11:31Z<p>Jgodwin: Tkmadagascar moved to TkMadagascar: consistency</p>
<hr />
<div>#REDIRECT [[TkMadagascar]]</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=TkMadagascar&diff=1551TkMadagascar2011-01-03T22:07:45Z<p>Jgodwin: /* Video tutorials */</p>
<hr />
<div>tkMadagascar is a pure-Python, Tkinter graphical user interface for Madagascar. It allows users to construct processing flows using a graphical tool as well as on the command line. <br />
<br />
tkMadagascar is comprised of two main programs: the standalone program browser and the main user interface.<br />
<br />
= Video tutorials = <br />
<br />
Please view the following tutorials on YouTube for a quick introduction to tkMadagascar:<br />
<br />
'''[http://www.youtube.com/watch?v=q5O07-XGvhM Standalone program browser] '''<br />
<br />
'''[http://www.youtube.com/watch?v=piQTfk0aUfo Introduction to tkMadagascar] '''<br />
<br />
'''[http://www.youtube.com/watch?v=eJEAP9OJFTA Linking flows in tkMadagascar] '''<br />
<br />
'''[http://www.youtube.com/watch?v=AEGbOuOyI9c Running SCons from within tkMadagascar]'''<br />
<br />
'''[http://www.youtube.com/watch?v=E8jE_qXfj4A Using templates in tkMadagascar] '''<br />
<br />
'''[http://www.youtube.com/watch?v=Mj3vmzs7rb8 Finite difference modeling in tkMadagascar]'''<br />
<br />
= Program Browser = <br />
<br />
The program browser allows users to quickly view the self-documentation for Madagascar programs. To access the browser simply enter: '''sfbrowser''' on the command prompt. <br />
<br />
The browser is a single window consisting of multiple frames. To the left, is the area where the self-documentation will show for RSF programs. On the right is a list of all Madagascar programs contained within your local installation. This list is repopulated everytime that the browser is run, so it will be up-to-date provided that you have updated the Madagascar self-documentation (via a reinstall). <br />
<br />
<br />
== Search by name ==<br />
<br />
To select programs, simply double-click on their names in the program list. If you know the name of your program, you can enter it into the box to the left of the '''Find Program''' button, and then press '''Find Program''' which will take you to the program that you requested. <br />
<br />
== Search by functionality == <br />
<br />
Additionally, you can search program descriptions if you are not sure which program to use for a specific task. To do so, click on '''Search by functionality''', which opens a separate window. Type the keyword or phrase you want to look for in program descriptions. For example, to look for programs to add RSF files together, we might search for "add". Then click '''Search'''. Once the result list is populated, you can either double-click or click the '''Select''' button, to bring that programs self-documentation into the other window.<br />
<br />
= Main interface =<br />
<br />
The main interface is accessed by entering: '''sfgui''' on the command line. It allows users to create and manage processing flows using Madagascar and SCons.<br />
<br />
== Sandbox ==<br />
<br />
The main window of the interface is called the "Sandbox." It is where all of your Flows, Plots, and Results will show up as you add and configure them. The Sandbox is also the home screen. Closing the Sandbox terminates tkMadagascar.<br />
<br />
The Sandbox has the following menus:<br />
<br />
=== File === <br />
<br />
The File menu handles file input/output operations. <br />
<br />
New - Resets the Sandbox.<br />
<br />
Load state - Load the previous state of a saved Sandbox, or load items from a saved Sandbox.<br />
<br />
Save state - Save the state of the Sandbox (includes all items attached to a Sandbox). <br />
<br />
Export to SConstruct - Export all Flows, Plots and Result commands to an SConstruct of your choosing for later execution on the command line.<br />
<br />
Close - terminate tkMadagascar.<br />
<br />
=== View === <br />
<br />
The view menu lets you choose which other windows to show:<br />
<br />
Program browser, lets you find and select programs to add to your Sandbox.<br />
Log, lets you view the output of running processes.<br />
<br />
=== Run === <br />
<br />
The run menu lets you execute commands from the command line on the items attached to your Sandbox. List of commands is below:<br />
<br />
scons - build Results and their dependencies<br />
<br />
scons view - build Results and their dependencies, try to open a plot command for each Result<br />
<br />
scons lock - build Results and save them to $RSFFIGS<br />
<br />
scons -c - clean the local directory<br />
<br />
scons -n - try a dry-run of scons<br />
<br />
== Program browser == <br />
<br />
The program browser is nearly identical to the standalone version mentioned above, but this version has three additional buttons:<br />
<br />
=== Add Flow === <br />
<br />
Add the selected program as a Flow item to the Sandbox. Flows have black outlines.<br />
<br />
=== Add Plot ===<br />
<br />
Add the selected program as a Plot item to the Sandbox. Plots have purple outlines.<br />
<br />
=== Add Result === <br />
<br />
Add the selected program as a Result item to the Sandbox. Results have blue outlines.<br />
<br />
== Log == <br />
<br />
The log updates you on the status of a running process. You are only allowed to have 1 (one) running process at a time. If the child process is hanging, you may kill the process simply by clicking '''Kill process'''. The process is then killed immediately, without a clean termination.<br />
<br />
== General workflow ==<br />
<br />
=== A new session === <br />
<br />
When a new instance of tkMadagascar is opened, the user is presented with an empty Sandbox. To get started, the user should open the '''Program browser''' from the '''View''' menu. The user may then browse, select, and add as many Flows, Plots or Results as they would like from the Program browser. <br />
<br />
=== Interacting with Flows, Plots and Results === <br />
<br />
Flows, Plots and Results appear in the Sandbox after they are added by the Program browser. All behaviors and actions that we describe are equally valid for Flows, Plots, and Results. For simplicity, we refer to only Flows from here on.<br />
<br />
You may move Flows by clicking and dragging with the left mouse-button. Additionally, all Flows are initially added to the Sandbox in the '''unconfigured''' state. To configure a Flow you must edit its parameters, selecting valid values for the parameters that you wish to set. To edit a Flow's parameters, you can '''right-click''' over the Flow, which will bring up a drop-down menu. Select '''Edit parameters''' from this drop-down menu, which opens a menu with a list of parameters and entry boxes.<br />
<br />
=== Configuring Flows ===<br />
<br />
Once the '''Edit parameters:''' window is open, you can simply input values for the parameters that you want to set. You only need to enter the value, you do not need to enter the value in "key=val" format. There are some special parameters that every Flow has:<br />
<br />
'''output''' - the name or names of files that you want to output to. If multiple files, then separate the names with a space. You do not need to include '.rsf' on the end of file names.<br />
<br />
'''input''' - the name or names of files that you want to input to. Same rules as above.<br />
<br />
'''custom''' - a raw string of any additional parameters that you want to set. You must set these parameters in "key=val" format, unlike the other parameters. There is no parameter checking for parameters set this way. Multiple parameters should be separated by spaces.<br />
<br />
Additionally, some programs have parameters that work on any axis. For example, sfspike allows the user to set the number of samples (n#) for any axis. These parameters are listed as the parameter name, with the # still attached. These parameters must be set with "key=val" formatting as well. <br />
<br />
For sfspike's n# parameter, you might set: n#= n1=100 n2=100<br />
<br />
Once a Flow is configured, the Flow will change color to have a green background and the name of the output file will appear inside the flow. A green Flow is good-to-go, and does not require any additional configuration. It will be automatically saved, exported, or executed. Unconfigured Flows may be saved, but will not be exported or executed.<br />
<br />
Click '''Accept''' to save your parameter selections.<br />
Click '''Preview''' to see how the Flow would look in an SConstruct (useful for debugging).<br />
Click '''Self-documentation''' to see the Programs self-documentation while editing parameters.<br />
<br />
=== Linking Flows === <br />
<br />
One of the nicest features of Madagascar is that programs can pipe their output to other programs, greatly reducing the need for intermediate files. This functionality is fully supported by tkMadagascar. To link two Flows, right click on the flow that you want to link to another Flow, and select ''' Link'''. The cursor will change to a cross-hair to indicate that you are in '''Link''' mode. Once in '''Link''' mode, click on the Flow that you want to link to. The Flow that is selected for linking is assumed to have desired output for the Flow that you right-clicked on. <br />
<br />
Once Linked, the two Flows move together, their borders change color, and their input and output parameters are automatically changed to reflect the fact that one is piping into the other. The border colors change as follows:<br />
Flows become light gray,<br />
Plots become light purple,<br />
Results become light blue.<br />
<br />
To '''Unlink''' a Flow, simply '''right-click''' on the Flow you wish to unlink, and then select unlink. The Flow will be detached. The other Flows in the Linked Flow will be detached as well, or placed into separate Linked Flows.<br />
<br />
=== Deleting Flows === <br />
<br />
To delete a Flow from the Sandbox simply '''right-click''' on the Flow, and select '''Delete'''. If you select '''Delete''' for a Linked Flow, then you will delete all Flows linked to it.<br />
<br />
= Requirements = <br />
tkMadagascar requires Python 2.5 or higher, and Tkinter 8.0 or higher. Tkinter is included by default with your Python installation, so you will have to upgrade your Python installation to a higher version to upgrade Tkinter if needed. If in doubt, try to run tkMadagascar first, before upgrading, as your version may still work properly.<br />
<br />
'''Note: you must have a fully functional RSF installation before you can use tkMadagascar.'''</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=TkMadagascar&diff=1550TkMadagascar2011-01-03T01:58:41Z<p>Jgodwin: </p>
<hr />
<div>tkMadagascar is a pure-Python, Tkinter graphical user interface for Madagascar. It allows users to construct processing flows using a graphical tool as well as on the command line. <br />
<br />
tkMadagascar is comprised of two main programs: the standalone program browser and the main user interface.<br />
<br />
= Video tutorials = <br />
<br />
Please view the following tutorials on YouTube for a quick introduction to tkMadagascar:<br />
<br />
'''[http://www.youtube.com/watch?v=q5O07-XGvhM Standalone program browser] '''<br />
<br />
<br />
= Program Browser = <br />
<br />
The program browser allows users to quickly view the self-documentation for Madagascar programs. To access the browser simply enter: '''sfbrowser''' on the command prompt. <br />
<br />
The browser is a single window consisting of multiple frames. To the left, is the area where the self-documentation will show for RSF programs. On the right is a list of all Madagascar programs contained within your local installation. This list is repopulated everytime that the browser is run, so it will be up-to-date provided that you have updated the Madagascar self-documentation (via a reinstall). <br />
<br />
<br />
== Search by name ==<br />
<br />
To select programs, simply double-click on their names in the program list. If you know the name of your program, you can enter it into the box to the left of the '''Find Program''' button, and then press '''Find Program''' which will take you to the program that you requested. <br />
<br />
== Search by functionality == <br />
<br />
Additionally, you can search program descriptions if you are not sure which program to use for a specific task. To do so, click on '''Search by functionality''', which opens a separate window. Type the keyword or phrase you want to look for in program descriptions. For example, to look for programs to add RSF files together, we might search for "add". Then click '''Search'''. Once the result list is populated, you can either double-click or click the '''Select''' button, to bring that programs self-documentation into the other window.<br />
<br />
= Main interface =<br />
<br />
The main interface is accessed by entering: '''sfgui''' on the command line. It allows users to create and manage processing flows using Madagascar and SCons.<br />
<br />
== Sandbox ==<br />
<br />
The main window of the interface is called the "Sandbox." It is where all of your Flows, Plots, and Results will show up as you add and configure them. The Sandbox is also the home screen. Closing the Sandbox terminates tkMadagascar.<br />
<br />
The Sandbox has the following menus:<br />
<br />
=== File === <br />
<br />
The File menu handles file input/output operations. <br />
<br />
New - Resets the Sandbox.<br />
<br />
Load state - Load the previous state of a saved Sandbox, or load items from a saved Sandbox.<br />
<br />
Save state - Save the state of the Sandbox (includes all items attached to a Sandbox). <br />
<br />
Export to SConstruct - Export all Flows, Plots and Result commands to an SConstruct of your choosing for later execution on the command line.<br />
<br />
Close - terminate tkMadagascar.<br />
<br />
=== View === <br />
<br />
The view menu lets you choose which other windows to show:<br />
<br />
Program browser, lets you find and select programs to add to your Sandbox.<br />
Log, lets you view the output of running processes.<br />
<br />
=== Run === <br />
<br />
The run menu lets you execute commands from the command line on the items attached to your Sandbox. List of commands is below:<br />
<br />
scons - build Results and their dependencies<br />
<br />
scons view - build Results and their dependencies, try to open a plot command for each Result<br />
<br />
scons lock - build Results and save them to $RSFFIGS<br />
<br />
scons -c - clean the local directory<br />
<br />
scons -n - try a dry-run of scons<br />
<br />
== Program browser == <br />
<br />
The program browser is nearly identical to the standalone version mentioned above, but this version has three additional buttons:<br />
<br />
=== Add Flow === <br />
<br />
Add the selected program as a Flow item to the Sandbox. Flows have black outlines.<br />
<br />
=== Add Plot ===<br />
<br />
Add the selected program as a Plot item to the Sandbox. Plots have purple outlines.<br />
<br />
=== Add Result === <br />
<br />
Add the selected program as a Result item to the Sandbox. Results have blue outlines.<br />
<br />
== Log == <br />
<br />
The log updates you on the status of a running process. You are only allowed to have 1 (one) running process at a time. If the child process is hanging, you may kill the process simply by clicking '''Kill process'''. The process is then killed immediately, without a clean termination.<br />
<br />
== General workflow ==<br />
<br />
=== A new session === <br />
<br />
When a new instance of tkMadagascar is opened, the user is presented with an empty Sandbox. To get started, the user should open the '''Program browser''' from the '''View''' menu. The user may then browse, select, and add as many Flows, Plots or Results as they would like from the Program browser. <br />
<br />
=== Interacting with Flows, Plots and Results === <br />
<br />
Flows, Plots and Results appear in the Sandbox after they are added by the Program browser. All behaviors and actions that we describe are equally valid for Flows, Plots, and Results. For simplicity, we refer to only Flows from here on.<br />
<br />
You may move Flows by clicking and dragging with the left mouse-button. Additionally, all Flows are initially added to the Sandbox in the '''unconfigured''' state. To configure a Flow you must edit its parameters, selecting valid values for the parameters that you wish to set. To edit a Flow's parameters, you can '''right-click''' over the Flow, which will bring up a drop-down menu. Select '''Edit parameters''' from this drop-down menu, which opens a menu with a list of parameters and entry boxes.<br />
<br />
=== Configuring Flows ===<br />
<br />
Once the '''Edit parameters:''' window is open, you can simply input values for the parameters that you want to set. You only need to enter the value, you do not need to enter the value in "key=val" format. There are some special parameters that every Flow has:<br />
<br />
'''output''' - the name or names of files that you want to output to. If multiple files, then separate the names with a space. You do not need to include '.rsf' on the end of file names.<br />
<br />
'''input''' - the name or names of files that you want to input to. Same rules as above.<br />
<br />
'''custom''' - a raw string of any additional parameters that you want to set. You must set these parameters in "key=val" format, unlike the other parameters. There is no parameter checking for parameters set this way. Multiple parameters should be separated by spaces.<br />
<br />
Additionally, some programs have parameters that work on any axis. For example, sfspike allows the user to set the number of samples (n#) for any axis. These parameters are listed as the parameter name, with the # still attached. These parameters must be set with "key=val" formatting as well. <br />
<br />
For sfspike's n# parameter, you might set: n#= n1=100 n2=100<br />
<br />
Once a Flow is configured, the Flow will change color to have a green background and the name of the output file will appear inside the flow. A green Flow is good-to-go, and does not require any additional configuration. It will be automatically saved, exported, or executed. Unconfigured Flows may be saved, but will not be exported or executed.<br />
<br />
Click '''Accept''' to save your parameter selections.<br />
Click '''Preview''' to see how the Flow would look in an SConstruct (useful for debugging).<br />
Click '''Self-documentation''' to see the Programs self-documentation while editing parameters.<br />
<br />
=== Linking Flows === <br />
<br />
One of the nicest features of Madagascar is that programs can pipe their output to other programs, greatly reducing the need for intermediate files. This functionality is fully supported by tkMadagascar. To link two Flows, right click on the flow that you want to link to another Flow, and select ''' Link'''. The cursor will change to a cross-hair to indicate that you are in '''Link''' mode. Once in '''Link''' mode, click on the Flow that you want to link to. The Flow that is selected for linking is assumed to have desired output for the Flow that you right-clicked on. <br />
<br />
Once Linked, the two Flows move together, their borders change color, and their input and output parameters are automatically changed to reflect the fact that one is piping into the other. The border colors change as follows:<br />
Flows become light gray,<br />
Plots become light purple,<br />
Results become light blue.<br />
<br />
To '''Unlink''' a Flow, simply '''right-click''' on the Flow you wish to unlink, and then select unlink. The Flow will be detached. The other Flows in the Linked Flow will be detached as well, or placed into separate Linked Flows.<br />
<br />
=== Deleting Flows === <br />
<br />
To delete a Flow from the Sandbox simply '''right-click''' on the Flow, and select '''Delete'''. If you select '''Delete''' for a Linked Flow, then you will delete all Flows linked to it.<br />
<br />
= Requirements = <br />
tkMadagascar requires Python 2.5 or higher, and Tkinter 8.0 or higher. Tkinter is included by default with your Python installation, so you will have to upgrade your Python installation to a higher version to upgrade Tkinter if needed. If in doubt, try to run tkMadagascar first, before upgrading, as your version may still work properly.<br />
<br />
'''Note: you must have a fully functional RSF installation before you can use tkMadagascar.'''</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=TkMadagascar&diff=1549TkMadagascar2011-01-03T01:42:55Z<p>Jgodwin: /* Program Browser */</p>
<hr />
<div>tkMadagascar is a pure-Python, Tkinter graphical user interface for Madagascar. It allows users to construct processing flows using a graphical tool as well as on the command line. <br />
<br />
tkMadagascar is comprised of two main programs: the standalone program browser and the main user interface.<br />
<br />
= Requirements = <br />
tkMadagascar requires Python 2.5 or higher, and Tkinter 8.0 or higher. Tkinter is included by default with your Python installation, so you will have to upgrade your Python installation to a higher version to upgrade Tkinter if needed. If in doubt, try to run tkMadagascar first, before upgrading, as your version may still work properly.<br />
<br />
'''Note: you must have a fully functional RSF installation before you can use tkMadagascar.'''<br />
<br />
= Program Browser = <br />
<br />
The program browser allows users to quickly view the self-documentation for Madagascar programs. To access the browser simply enter: '''sfbrowser''' on the command prompt. <br />
<br />
The browser is a single window consisting of multiple frames. To the left, is the area where the self-documentation will show for RSF programs. On the right is a list of all Madagascar programs contained within your local installation. This list is repopulated everytime that the browser is run, so it will be up-to-date provided that you have updated the Madagascar self-documentation (via a reinstall). <br />
<br />
'''[http://www.youtube.com/watch?v=q5O07-XGvhM View a demo of the program browser on YouTube] '''<br />
<br />
== Search by name ==<br />
<br />
To select programs, simply double-click on their names in the program list. If you know the name of your program, you can enter it into the box to the left of the '''Find Program''' button, and then press '''Find Program''' which will take you to the program that you requested. <br />
<br />
== Search by functionality == <br />
<br />
Additionally, you can search program descriptions if you are not sure which program to use for a specific task. To do so, click on '''Search by functionality''', which opens a separate window. Type the keyword or phrase you want to look for in program descriptions. For example, to look for programs to add RSF files together, we might search for "add". Then click '''Search'''. Once the result list is populated, you can either double-click or click the '''Select''' button, to bring that programs self-documentation into the other window.<br />
<br />
= Main interface =<br />
<br />
The main interface is accessed by entering: '''sfgui''' on the command line. It allows users to create and manage processing flows using Madagascar and SCons.<br />
<br />
== Sandbox ==<br />
<br />
The main window of the interface is called the "Sandbox." It is where all of your Flows, Plots, and Results will show up as you add and configure them. The Sandbox is also the home screen. Closing the Sandbox terminates tkMadagascar.<br />
<br />
The Sandbox has the following menus:<br />
<br />
=== File === <br />
<br />
The File menu handles file input/output operations. <br />
<br />
New - Resets the Sandbox.<br />
<br />
Load state - Load the previous state of a saved Sandbox, or load items from a saved Sandbox.<br />
<br />
Save state - Save the state of the Sandbox (includes all items attached to a Sandbox). <br />
<br />
Export to SConstruct - Export all Flows, Plots and Result commands to an SConstruct of your choosing for later execution on the command line.<br />
<br />
Close - terminate tkMadagascar.<br />
<br />
=== View === <br />
<br />
The view menu lets you choose which other windows to show:<br />
<br />
Program browser, lets you find and select programs to add to your Sandbox.<br />
Log, lets you view the output of running processes.<br />
<br />
=== Run === <br />
<br />
The run menu lets you execute commands from the command line on the items attached to your Sandbox. List of commands is below:<br />
<br />
scons - build Results and their dependencies<br />
<br />
scons view - build Results and their dependencies, try to open a plot command for each Result<br />
<br />
scons lock - build Results and save them to $RSFFIGS<br />
<br />
scons -c - clean the local directory<br />
<br />
scons -n - try a dry-run of scons<br />
<br />
== Program browser == <br />
<br />
The program browser is nearly identical to the standalone version mentioned above, but this version has three additional buttons:<br />
<br />
=== Add Flow === <br />
<br />
Add the selected program as a Flow item to the Sandbox. Flows have black outlines.<br />
<br />
=== Add Plot ===<br />
<br />
Add the selected program as a Plot item to the Sandbox. Plots have purple outlines.<br />
<br />
=== Add Result === <br />
<br />
Add the selected program as a Result item to the Sandbox. Results have blue outlines.<br />
<br />
== Log == <br />
<br />
The log updates you on the status of a running process. You are only allowed to have 1 (one) running process at a time. If the child process is hanging, you may kill the process simply by clicking '''Kill process'''. The process is then killed immediately, without a clean termination.<br />
<br />
== General workflow ==<br />
<br />
=== A new session === <br />
<br />
When a new instance of tkMadagascar is opened, the user is presented with an empty Sandbox. To get started, the user should open the '''Program browser''' from the '''View''' menu. The user may then browse, select, and add as many Flows, Plots or Results as they would like from the Program browser. <br />
<br />
=== Interacting with Flows, Plots and Results === <br />
<br />
Flows, Plots and Results appear in the Sandbox after they are added by the Program browser. All behaviors and actions that we describe are equally valid for Flows, Plots, and Results. For simplicity, we refer to only Flows from here on.<br />
<br />
You may move Flows by clicking and dragging with the left mouse-button. Additionally, all Flows are initially added to the Sandbox in the '''unconfigured''' state. To configure a Flow you must edit its parameters, selecting valid values for the parameters that you wish to set. To edit a Flow's parameters, you can '''right-click''' over the Flow, which will bring up a drop-down menu. Select '''Edit parameters''' from this drop-down menu, which opens a menu with a list of parameters and entry boxes.<br />
<br />
=== Configuring Flows ===<br />
<br />
Once the '''Edit parameters:''' window is open, you can simply input values for the parameters that you want to set. You only need to enter the value, you do not need to enter the value in "key=val" format. There are some special parameters that every Flow has:<br />
<br />
'''output''' - the name or names of files that you want to output to. If multiple files, then separate the names with a space. You do not need to include '.rsf' on the end of file names.<br />
<br />
'''input''' - the name or names of files that you want to input to. Same rules as above.<br />
<br />
'''custom''' - a raw string of any additional parameters that you want to set. You must set these parameters in "key=val" format, unlike the other parameters. There is no parameter checking for parameters set this way. Multiple parameters should be separated by spaces.<br />
<br />
Additionally, some programs have parameters that work on any axis. For example, sfspike allows the user to set the number of samples (n#) for any axis. These parameters are listed as the parameter name, with the # still attached. These parameters must be set with "key=val" formatting as well. <br />
<br />
For sfspike's n# parameter, you might set: n#= n1=100 n2=100<br />
<br />
Once a Flow is configured, the Flow will change color to have a green background and the name of the output file will appear inside the flow. A green Flow is good-to-go, and does not require any additional configuration. It will be automatically saved, exported, or executed. Unconfigured Flows may be saved, but will not be exported or executed.<br />
<br />
Click '''Accept''' to save your parameter selections.<br />
Click '''Preview''' to see how the Flow would look in an SConstruct (useful for debugging).<br />
Click '''Self-documentation''' to see the Programs self-documentation while editing parameters.<br />
<br />
=== Linking Flows === <br />
<br />
One of the nicest features of Madagascar is that programs can pipe their output to other programs, greatly reducing the need for intermediate files. This functionality is fully supported by tkMadagascar. To link two Flows, right click on the flow that you want to link to another Flow, and select ''' Link'''. The cursor will change to a cross-hair to indicate that you are in '''Link''' mode. Once in '''Link''' mode, click on the Flow that you want to link to. The Flow that is selected for linking is assumed to have desired output for the Flow that you right-clicked on. <br />
<br />
Once Linked, the two Flows move together, their borders change color, and their input and output parameters are automatically changed to reflect the fact that one is piping into the other. The border colors change as follows:<br />
Flows become light gray,<br />
Plots become light purple,<br />
Results become light blue.<br />
<br />
To '''Unlink''' a Flow, simply '''right-click''' on the Flow you wish to unlink, and then select unlink. The Flow will be detached. The other Flows in the Linked Flow will be detached as well, or placed into separate Linked Flows.<br />
<br />
=== Deleting Flows === <br />
<br />
To delete a Flow from the Sandbox simply '''right-click''' on the Flow, and select '''Delete'''. If you select '''Delete''' for a Linked Flow, then you will delete all Flows linked to it.</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=TkMadagascar&diff=1548TkMadagascar2011-01-03T01:42:32Z<p>Jgodwin: /* Search by functionality */</p>
<hr />
<div>tkMadagascar is a pure-Python, Tkinter graphical user interface for Madagascar. It allows users to construct processing flows using a graphical tool as well as on the command line. <br />
<br />
tkMadagascar is comprised of two main programs: the standalone program browser and the main user interface.<br />
<br />
= Requirements = <br />
tkMadagascar requires Python 2.5 or higher, and Tkinter 8.0 or higher. Tkinter is included by default with your Python installation, so you will have to upgrade your Python installation to a higher version to upgrade Tkinter if needed. If in doubt, try to run tkMadagascar first, before upgrading, as your version may still work properly.<br />
<br />
'''Note: you must have a fully functional RSF installation before you can use tkMadagascar.'''<br />
<br />
= Program Browser = <br />
<br />
The program browser allows users to quickly view the self-documentation for Madagascar programs. To access the browser simply enter: '''sfbrowser''' on the command prompt. <br />
<br />
The browser is a single window consisting of multiple frames. To the left, is the area where the self-documentation will show for RSF programs. On the right is a list of all Madagascar programs contained within your local installation. This list is repopulated everytime that the browser is run, so it will be up-to-date provided that you have updated the Madagascar self-documentation (via a reinstall). <br />
<br />
== Search by name ==<br />
<br />
To select programs, simply double-click on their names in the program list. If you know the name of your program, you can enter it into the box to the left of the '''Find Program''' button, and then press '''Find Program''' which will take you to the program that you requested. <br />
<br />
== Search by functionality == <br />
<br />
Additionally, you can search program descriptions if you are not sure which program to use for a specific task. To do so, click on '''Search by functionality''', which opens a separate window. Type the keyword or phrase you want to look for in program descriptions. For example, to look for programs to add RSF files together, we might search for "add". Then click '''Search'''. Once the result list is populated, you can either double-click or click the '''Select''' button, to bring that programs self-documentation into the other window.<br />
<br />
= Main interface =<br />
<br />
The main interface is accessed by entering: '''sfgui''' on the command line. It allows users to create and manage processing flows using Madagascar and SCons.<br />
<br />
== Sandbox ==<br />
<br />
The main window of the interface is called the "Sandbox." It is where all of your Flows, Plots, and Results will show up as you add and configure them. The Sandbox is also the home screen. Closing the Sandbox terminates tkMadagascar.<br />
<br />
The Sandbox has the following menus:<br />
<br />
=== File === <br />
<br />
The File menu handles file input/output operations. <br />
<br />
New - Resets the Sandbox.<br />
<br />
Load state - Load the previous state of a saved Sandbox, or load items from a saved Sandbox.<br />
<br />
Save state - Save the state of the Sandbox (includes all items attached to a Sandbox). <br />
<br />
Export to SConstruct - Export all Flows, Plots and Result commands to an SConstruct of your choosing for later execution on the command line.<br />
<br />
Close - terminate tkMadagascar.<br />
<br />
=== View === <br />
<br />
The view menu lets you choose which other windows to show:<br />
<br />
Program browser, lets you find and select programs to add to your Sandbox.<br />
Log, lets you view the output of running processes.<br />
<br />
=== Run === <br />
<br />
The run menu lets you execute commands from the command line on the items attached to your Sandbox. List of commands is below:<br />
<br />
scons - build Results and their dependencies<br />
<br />
scons view - build Results and their dependencies, try to open a plot command for each Result<br />
<br />
scons lock - build Results and save them to $RSFFIGS<br />
<br />
scons -c - clean the local directory<br />
<br />
scons -n - try a dry-run of scons<br />
<br />
== Program browser == <br />
<br />
The program browser is nearly identical to the standalone version mentioned above, but this version has three additional buttons:<br />
<br />
=== Add Flow === <br />
<br />
Add the selected program as a Flow item to the Sandbox. Flows have black outlines.<br />
<br />
=== Add Plot ===<br />
<br />
Add the selected program as a Plot item to the Sandbox. Plots have purple outlines.<br />
<br />
=== Add Result === <br />
<br />
Add the selected program as a Result item to the Sandbox. Results have blue outlines.<br />
<br />
== Log == <br />
<br />
The log updates you on the status of a running process. You are only allowed to have 1 (one) running process at a time. If the child process is hanging, you may kill the process simply by clicking '''Kill process'''. The process is then killed immediately, without a clean termination.<br />
<br />
== General workflow ==<br />
<br />
=== A new session === <br />
<br />
When a new instance of tkMadagascar is opened, the user is presented with an empty Sandbox. To get started, the user should open the '''Program browser''' from the '''View''' menu. The user may then browse, select, and add as many Flows, Plots or Results as they would like from the Program browser. <br />
<br />
=== Interacting with Flows, Plots and Results === <br />
<br />
Flows, Plots and Results appear in the Sandbox after they are added by the Program browser. All behaviors and actions that we describe are equally valid for Flows, Plots, and Results. For simplicity, we refer to only Flows from here on.<br />
<br />
You may move Flows by clicking and dragging with the left mouse-button. Additionally, all Flows are initially added to the Sandbox in the '''unconfigured''' state. To configure a Flow you must edit its parameters, selecting valid values for the parameters that you wish to set. To edit a Flow's parameters, you can '''right-click''' over the Flow, which will bring up a drop-down menu. Select '''Edit parameters''' from this drop-down menu, which opens a menu with a list of parameters and entry boxes.<br />
<br />
=== Configuring Flows ===<br />
<br />
Once the '''Edit parameters:''' window is open, you can simply input values for the parameters that you want to set. You only need to enter the value, you do not need to enter the value in "key=val" format. There are some special parameters that every Flow has:<br />
<br />
'''output''' - the name or names of files that you want to output to. If multiple files, then separate the names with a space. You do not need to include '.rsf' on the end of file names.<br />
<br />
'''input''' - the name or names of files that you want to input to. Same rules as above.<br />
<br />
'''custom''' - a raw string of any additional parameters that you want to set. You must set these parameters in "key=val" format, unlike the other parameters. There is no parameter checking for parameters set this way. Multiple parameters should be separated by spaces.<br />
<br />
Additionally, some programs have parameters that work on any axis. For example, sfspike allows the user to set the number of samples (n#) for any axis. These parameters are listed as the parameter name, with the # still attached. These parameters must be set with "key=val" formatting as well. <br />
<br />
For sfspike's n# parameter, you might set: n#= n1=100 n2=100<br />
<br />
Once a Flow is configured, the Flow will change color to have a green background and the name of the output file will appear inside the flow. A green Flow is good-to-go, and does not require any additional configuration. It will be automatically saved, exported, or executed. Unconfigured Flows may be saved, but will not be exported or executed.<br />
<br />
Click '''Accept''' to save your parameter selections.<br />
Click '''Preview''' to see how the Flow would look in an SConstruct (useful for debugging).<br />
Click '''Self-documentation''' to see the Programs self-documentation while editing parameters.<br />
<br />
=== Linking Flows === <br />
<br />
One of the nicest features of Madagascar is that programs can pipe their output to other programs, greatly reducing the need for intermediate files. This functionality is fully supported by tkMadagascar. To link two Flows, right click on the flow that you want to link to another Flow, and select ''' Link'''. The cursor will change to a cross-hair to indicate that you are in '''Link''' mode. Once in '''Link''' mode, click on the Flow that you want to link to. The Flow that is selected for linking is assumed to have desired output for the Flow that you right-clicked on. <br />
<br />
Once Linked, the two Flows move together, their borders change color, and their input and output parameters are automatically changed to reflect the fact that one is piping into the other. The border colors change as follows:<br />
Flows become light gray,<br />
Plots become light purple,<br />
Results become light blue.<br />
<br />
To '''Unlink''' a Flow, simply '''right-click''' on the Flow you wish to unlink, and then select unlink. The Flow will be detached. The other Flows in the Linked Flow will be detached as well, or placed into separate Linked Flows.<br />
<br />
=== Deleting Flows === <br />
<br />
To delete a Flow from the Sandbox simply '''right-click''' on the Flow, and select '''Delete'''. If you select '''Delete''' for a Linked Flow, then you will delete all Flows linked to it.</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=TkMadagascar&diff=1547TkMadagascar2011-01-03T01:42:12Z<p>Jgodwin: /* Search by functionality */</p>
<hr />
<div>tkMadagascar is a pure-Python, Tkinter graphical user interface for Madagascar. It allows users to construct processing flows using a graphical tool as well as on the command line. <br />
<br />
tkMadagascar is comprised of two main programs: the standalone program browser and the main user interface.<br />
<br />
= Requirements = <br />
tkMadagascar requires Python 2.5 or higher, and Tkinter 8.0 or higher. Tkinter is included by default with your Python installation, so you will have to upgrade your Python installation to a higher version to upgrade Tkinter if needed. If in doubt, try to run tkMadagascar first, before upgrading, as your version may still work properly.<br />
<br />
'''Note: you must have a fully functional RSF installation before you can use tkMadagascar.'''<br />
<br />
= Program Browser = <br />
<br />
The program browser allows users to quickly view the self-documentation for Madagascar programs. To access the browser simply enter: '''sfbrowser''' on the command prompt. <br />
<br />
The browser is a single window consisting of multiple frames. To the left, is the area where the self-documentation will show for RSF programs. On the right is a list of all Madagascar programs contained within your local installation. This list is repopulated everytime that the browser is run, so it will be up-to-date provided that you have updated the Madagascar self-documentation (via a reinstall). <br />
<br />
== Search by name ==<br />
<br />
To select programs, simply double-click on their names in the program list. If you know the name of your program, you can enter it into the box to the left of the '''Find Program''' button, and then press '''Find Program''' which will take you to the program that you requested. <br />
<br />
== Search by functionality == <br />
<br />
Additionally, you can search program descriptions if you are not sure which program to use for a specific task. To do so, click on '''Search by functionality''', which opens a separate window. Type the keyword or phrase you want to look for in program descriptions. For example, to look for programs to add RSF files together, we might search for "add". Then click '''Search'''. Once the result list is populated, you can either double-click or click the '''Select''' button, to bring that programs self-documentation into the other window.<br />
<br />
<br />
'''[http://www.youtube.com/watch?v=q5O07-XGvhM View a demo of the program browser on YouTube] '''<br />
<br />
= Main interface =<br />
<br />
The main interface is accessed by entering: '''sfgui''' on the command line. It allows users to create and manage processing flows using Madagascar and SCons.<br />
<br />
== Sandbox ==<br />
<br />
The main window of the interface is called the "Sandbox." It is where all of your Flows, Plots, and Results will show up as you add and configure them. The Sandbox is also the home screen. Closing the Sandbox terminates tkMadagascar.<br />
<br />
The Sandbox has the following menus:<br />
<br />
=== File === <br />
<br />
The File menu handles file input/output operations. <br />
<br />
New - Resets the Sandbox.<br />
<br />
Load state - Load the previous state of a saved Sandbox, or load items from a saved Sandbox.<br />
<br />
Save state - Save the state of the Sandbox (includes all items attached to a Sandbox). <br />
<br />
Export to SConstruct - Export all Flows, Plots and Result commands to an SConstruct of your choosing for later execution on the command line.<br />
<br />
Close - terminate tkMadagascar.<br />
<br />
=== View === <br />
<br />
The view menu lets you choose which other windows to show:<br />
<br />
Program browser, lets you find and select programs to add to your Sandbox.<br />
Log, lets you view the output of running processes.<br />
<br />
=== Run === <br />
<br />
The run menu lets you execute commands from the command line on the items attached to your Sandbox. List of commands is below:<br />
<br />
scons - build Results and their dependencies<br />
<br />
scons view - build Results and their dependencies, try to open a plot command for each Result<br />
<br />
scons lock - build Results and save them to $RSFFIGS<br />
<br />
scons -c - clean the local directory<br />
<br />
scons -n - try a dry-run of scons<br />
<br />
== Program browser == <br />
<br />
The program browser is nearly identical to the standalone version mentioned above, but this version has three additional buttons:<br />
<br />
=== Add Flow === <br />
<br />
Add the selected program as a Flow item to the Sandbox. Flows have black outlines.<br />
<br />
=== Add Plot ===<br />
<br />
Add the selected program as a Plot item to the Sandbox. Plots have purple outlines.<br />
<br />
=== Add Result === <br />
<br />
Add the selected program as a Result item to the Sandbox. Results have blue outlines.<br />
<br />
== Log == <br />
<br />
The log updates you on the status of a running process. You are only allowed to have 1 (one) running process at a time. If the child process is hanging, you may kill the process simply by clicking '''Kill process'''. The process is then killed immediately, without a clean termination.<br />
<br />
== General workflow ==<br />
<br />
=== A new session === <br />
<br />
When a new instance of tkMadagascar is opened, the user is presented with an empty Sandbox. To get started, the user should open the '''Program browser''' from the '''View''' menu. The user may then browse, select, and add as many Flows, Plots or Results as they would like from the Program browser. <br />
<br />
=== Interacting with Flows, Plots and Results === <br />
<br />
Flows, Plots and Results appear in the Sandbox after they are added by the Program browser. All behaviors and actions that we describe are equally valid for Flows, Plots, and Results. For simplicity, we refer to only Flows from here on.<br />
<br />
You may move Flows by clicking and dragging with the left mouse-button. Additionally, all Flows are initially added to the Sandbox in the '''unconfigured''' state. To configure a Flow you must edit its parameters, selecting valid values for the parameters that you wish to set. To edit a Flow's parameters, you can '''right-click''' over the Flow, which will bring up a drop-down menu. Select '''Edit parameters''' from this drop-down menu, which opens a menu with a list of parameters and entry boxes.<br />
<br />
=== Configuring Flows ===<br />
<br />
Once the '''Edit parameters:''' window is open, you can simply input values for the parameters that you want to set. You only need to enter the value, you do not need to enter the value in "key=val" format. There are some special parameters that every Flow has:<br />
<br />
'''output''' - the name or names of files that you want to output to. If multiple files, then separate the names with a space. You do not need to include '.rsf' on the end of file names.<br />
<br />
'''input''' - the name or names of files that you want to input to. Same rules as above.<br />
<br />
'''custom''' - a raw string of any additional parameters that you want to set. You must set these parameters in "key=val" format, unlike the other parameters. There is no parameter checking for parameters set this way. Multiple parameters should be separated by spaces.<br />
<br />
Additionally, some programs have parameters that work on any axis. For example, sfspike allows the user to set the number of samples (n#) for any axis. These parameters are listed as the parameter name, with the # still attached. These parameters must be set with "key=val" formatting as well. <br />
<br />
For sfspike's n# parameter, you might set: n#= n1=100 n2=100<br />
<br />
Once a Flow is configured, the Flow will change color to have a green background and the name of the output file will appear inside the flow. A green Flow is good-to-go, and does not require any additional configuration. It will be automatically saved, exported, or executed. Unconfigured Flows may be saved, but will not be exported or executed.<br />
<br />
Click '''Accept''' to save your parameter selections.<br />
Click '''Preview''' to see how the Flow would look in an SConstruct (useful for debugging).<br />
Click '''Self-documentation''' to see the Programs self-documentation while editing parameters.<br />
<br />
=== Linking Flows === <br />
<br />
One of the nicest features of Madagascar is that programs can pipe their output to other programs, greatly reducing the need for intermediate files. This functionality is fully supported by tkMadagascar. To link two Flows, right click on the flow that you want to link to another Flow, and select ''' Link'''. The cursor will change to a cross-hair to indicate that you are in '''Link''' mode. Once in '''Link''' mode, click on the Flow that you want to link to. The Flow that is selected for linking is assumed to have desired output for the Flow that you right-clicked on. <br />
<br />
Once Linked, the two Flows move together, their borders change color, and their input and output parameters are automatically changed to reflect the fact that one is piping into the other. The border colors change as follows:<br />
Flows become light gray,<br />
Plots become light purple,<br />
Results become light blue.<br />
<br />
To '''Unlink''' a Flow, simply '''right-click''' on the Flow you wish to unlink, and then select unlink. The Flow will be detached. The other Flows in the Linked Flow will be detached as well, or placed into separate Linked Flows.<br />
<br />
=== Deleting Flows === <br />
<br />
To delete a Flow from the Sandbox simply '''right-click''' on the Flow, and select '''Delete'''. If you select '''Delete''' for a Linked Flow, then you will delete all Flows linked to it.</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=TkMadagascar&diff=1546TkMadagascar2011-01-03T01:41:42Z<p>Jgodwin: /* Program Browser */</p>
<hr />
<div>tkMadagascar is a pure-Python, Tkinter graphical user interface for Madagascar. It allows users to construct processing flows using a graphical tool as well as on the command line. <br />
<br />
tkMadagascar is comprised of two main programs: the standalone program browser and the main user interface.<br />
<br />
= Requirements = <br />
tkMadagascar requires Python 2.5 or higher, and Tkinter 8.0 or higher. Tkinter is included by default with your Python installation, so you will have to upgrade your Python installation to a higher version to upgrade Tkinter if needed. If in doubt, try to run tkMadagascar first, before upgrading, as your version may still work properly.<br />
<br />
'''Note: you must have a fully functional RSF installation before you can use tkMadagascar.'''<br />
<br />
= Program Browser = <br />
<br />
The program browser allows users to quickly view the self-documentation for Madagascar programs. To access the browser simply enter: '''sfbrowser''' on the command prompt. <br />
<br />
The browser is a single window consisting of multiple frames. To the left, is the area where the self-documentation will show for RSF programs. On the right is a list of all Madagascar programs contained within your local installation. This list is repopulated everytime that the browser is run, so it will be up-to-date provided that you have updated the Madagascar self-documentation (via a reinstall). <br />
<br />
== Search by name ==<br />
<br />
To select programs, simply double-click on their names in the program list. If you know the name of your program, you can enter it into the box to the left of the '''Find Program''' button, and then press '''Find Program''' which will take you to the program that you requested. <br />
<br />
== Search by functionality == <br />
<br />
Additionally, you can search program descriptions if you are not sure which program to use for a specific task. To do so, click on '''Search by functionality''', which opens a separate window. Type the keyword or phrase you want to look for in program descriptions. For example, to look for programs to add RSF files together, we might search for "add". Then click '''Search'''. Once the result list is populated, you can either double-click or click the '''Select''' button, to bring that programs self-documentation into the other window.<br />
<br />
<br />
'''[http://www.youtube.com/watch?v=q5O07-XGvhM View the Demonstration video on YouTube] '''<br />
<br />
= Main interface =<br />
<br />
The main interface is accessed by entering: '''sfgui''' on the command line. It allows users to create and manage processing flows using Madagascar and SCons.<br />
<br />
== Sandbox ==<br />
<br />
The main window of the interface is called the "Sandbox." It is where all of your Flows, Plots, and Results will show up as you add and configure them. The Sandbox is also the home screen. Closing the Sandbox terminates tkMadagascar.<br />
<br />
The Sandbox has the following menus:<br />
<br />
=== File === <br />
<br />
The File menu handles file input/output operations. <br />
<br />
New - Resets the Sandbox.<br />
<br />
Load state - Load the previous state of a saved Sandbox, or load items from a saved Sandbox.<br />
<br />
Save state - Save the state of the Sandbox (includes all items attached to a Sandbox). <br />
<br />
Export to SConstruct - Export all Flows, Plots and Result commands to an SConstruct of your choosing for later execution on the command line.<br />
<br />
Close - terminate tkMadagascar.<br />
<br />
=== View === <br />
<br />
The view menu lets you choose which other windows to show:<br />
<br />
Program browser, lets you find and select programs to add to your Sandbox.<br />
Log, lets you view the output of running processes.<br />
<br />
=== Run === <br />
<br />
The run menu lets you execute commands from the command line on the items attached to your Sandbox. List of commands is below:<br />
<br />
scons - build Results and their dependencies<br />
<br />
scons view - build Results and their dependencies, try to open a plot command for each Result<br />
<br />
scons lock - build Results and save them to $RSFFIGS<br />
<br />
scons -c - clean the local directory<br />
<br />
scons -n - try a dry-run of scons<br />
<br />
== Program browser == <br />
<br />
The program browser is nearly identical to the standalone version mentioned above, but this version has three additional buttons:<br />
<br />
=== Add Flow === <br />
<br />
Add the selected program as a Flow item to the Sandbox. Flows have black outlines.<br />
<br />
=== Add Plot ===<br />
<br />
Add the selected program as a Plot item to the Sandbox. Plots have purple outlines.<br />
<br />
=== Add Result === <br />
<br />
Add the selected program as a Result item to the Sandbox. Results have blue outlines.<br />
<br />
== Log == <br />
<br />
The log updates you on the status of a running process. You are only allowed to have 1 (one) running process at a time. If the child process is hanging, you may kill the process simply by clicking '''Kill process'''. The process is then killed immediately, without a clean termination.<br />
<br />
== General workflow ==<br />
<br />
=== A new session === <br />
<br />
When a new instance of tkMadagascar is opened, the user is presented with an empty Sandbox. To get started, the user should open the '''Program browser''' from the '''View''' menu. The user may then browse, select, and add as many Flows, Plots or Results as they would like from the Program browser. <br />
<br />
=== Interacting with Flows, Plots and Results === <br />
<br />
Flows, Plots and Results appear in the Sandbox after they are added by the Program browser. All behaviors and actions that we describe are equally valid for Flows, Plots, and Results. For simplicity, we refer to only Flows from here on.<br />
<br />
You may move Flows by clicking and dragging with the left mouse-button. Additionally, all Flows are initially added to the Sandbox in the '''unconfigured''' state. To configure a Flow you must edit its parameters, selecting valid values for the parameters that you wish to set. To edit a Flow's parameters, you can '''right-click''' over the Flow, which will bring up a drop-down menu. Select '''Edit parameters''' from this drop-down menu, which opens a menu with a list of parameters and entry boxes.<br />
<br />
=== Configuring Flows ===<br />
<br />
Once the '''Edit parameters:''' window is open, you can simply input values for the parameters that you want to set. You only need to enter the value, you do not need to enter the value in "key=val" format. There are some special parameters that every Flow has:<br />
<br />
'''output''' - the name or names of files that you want to output to. If multiple files, then separate the names with a space. You do not need to include '.rsf' on the end of file names.<br />
<br />
'''input''' - the name or names of files that you want to input to. Same rules as above.<br />
<br />
'''custom''' - a raw string of any additional parameters that you want to set. You must set these parameters in "key=val" format, unlike the other parameters. There is no parameter checking for parameters set this way. Multiple parameters should be separated by spaces.<br />
<br />
Additionally, some programs have parameters that work on any axis. For example, sfspike allows the user to set the number of samples (n#) for any axis. These parameters are listed as the parameter name, with the # still attached. These parameters must be set with "key=val" formatting as well. <br />
<br />
For sfspike's n# parameter, you might set: n#= n1=100 n2=100<br />
<br />
Once a Flow is configured, the Flow will change color to have a green background and the name of the output file will appear inside the flow. A green Flow is good-to-go, and does not require any additional configuration. It will be automatically saved, exported, or executed. Unconfigured Flows may be saved, but will not be exported or executed.<br />
<br />
Click '''Accept''' to save your parameter selections.<br />
Click '''Preview''' to see how the Flow would look in an SConstruct (useful for debugging).<br />
Click '''Self-documentation''' to see the Programs self-documentation while editing parameters.<br />
<br />
=== Linking Flows === <br />
<br />
One of the nicest features of Madagascar is that programs can pipe their output to other programs, greatly reducing the need for intermediate files. This functionality is fully supported by tkMadagascar. To link two Flows, right click on the flow that you want to link to another Flow, and select ''' Link'''. The cursor will change to a cross-hair to indicate that you are in '''Link''' mode. Once in '''Link''' mode, click on the Flow that you want to link to. The Flow that is selected for linking is assumed to have desired output for the Flow that you right-clicked on. <br />
<br />
Once Linked, the two Flows move together, their borders change color, and their input and output parameters are automatically changed to reflect the fact that one is piping into the other. The border colors change as follows:<br />
Flows become light gray,<br />
Plots become light purple,<br />
Results become light blue.<br />
<br />
To '''Unlink''' a Flow, simply '''right-click''' on the Flow you wish to unlink, and then select unlink. The Flow will be detached. The other Flows in the Linked Flow will be detached as well, or placed into separate Linked Flows.<br />
<br />
=== Deleting Flows === <br />
<br />
To delete a Flow from the Sandbox simply '''right-click''' on the Flow, and select '''Delete'''. If you select '''Delete''' for a Linked Flow, then you will delete all Flows linked to it.</div>Jgodwinhttps://www.reproducibility.org/wiki2020/index.php?title=TkMadagascar&diff=1545TkMadagascar2011-01-03T01:41:08Z<p>Jgodwin: /* Requirements */</p>
<hr />
<div>tkMadagascar is a pure-Python, Tkinter graphical user interface for Madagascar. It allows users to construct processing flows using a graphical tool as well as on the command line. <br />
<br />
tkMadagascar is comprised of two main programs: the standalone program browser and the main user interface.<br />
<br />
= Requirements = <br />
tkMadagascar requires Python 2.5 or higher, and Tkinter 8.0 or higher. Tkinter is included by default with your Python installation, so you will have to upgrade your Python installation to a higher version to upgrade Tkinter if needed. If in doubt, try to run tkMadagascar first, before upgrading, as your version may still work properly.<br />
<br />
'''Note: you must have a fully functional RSF installation before you can use tkMadagascar.'''<br />
<br />
= Program Browser = <br />
<br />
The program browser allows users to quickly view the self-documentation for Madagascar programs. To access the browser simply enter: '''sfbrowser''' on the command prompt. <br />
<br />
The browser is a single window consisting of multiple frames. To the left, is the area where the self-documentation will show for RSF programs. On the right is a list of all Madagascar programs contained within your local installation. This list is repopulated everytime that the browser is run, so it will be up-to-date provided that you have updated the Madagascar self-documentation (via a reinstall). <br />
<br />
== Search by name ==<br />
<br />
To select programs, simply double-click on their names in the program list. If you know the name of your program, you can enter it into the box to the left of the '''Find Program''' button, and then press '''Find Program''' which will take you to the program that you requested. <br />
<br />
== Search by functionality == <br />
<br />
Additionally, you can search program descriptions if you are not sure which program to use for a specific task. To do so, click on '''Search by functionality''', which opens a separate window. Type the keyword or phrase you want to look for in program descriptions. For example, to look for programs to add RSF files together, we might search for "add". Then click '''Search'''. Once the result list is populated, you can either double-click or click the '''Select''' button, to bring that programs self-documentation into the other window. <br />
<br />
= Main interface =<br />
<br />
The main interface is accessed by entering: '''sfgui''' on the command line. It allows users to create and manage processing flows using Madagascar and SCons.<br />
<br />
== Sandbox ==<br />
<br />
The main window of the interface is called the "Sandbox." It is where all of your Flows, Plots, and Results will show up as you add and configure them. The Sandbox is also the home screen. Closing the Sandbox terminates tkMadagascar.<br />
<br />
The Sandbox has the following menus:<br />
<br />
=== File === <br />
<br />
The File menu handles file input/output operations. <br />
<br />
New - Resets the Sandbox.<br />
<br />
Load state - Load the previous state of a saved Sandbox, or load items from a saved Sandbox.<br />
<br />
Save state - Save the state of the Sandbox (includes all items attached to a Sandbox). <br />
<br />
Export to SConstruct - Export all Flows, Plots and Result commands to an SConstruct of your choosing for later execution on the command line.<br />
<br />
Close - terminate tkMadagascar.<br />
<br />
=== View === <br />
<br />
The view menu lets you choose which other windows to show:<br />
<br />
Program browser, lets you find and select programs to add to your Sandbox.<br />
Log, lets you view the output of running processes.<br />
<br />
=== Run === <br />
<br />
The run menu lets you execute commands from the command line on the items attached to your Sandbox. List of commands is below:<br />
<br />
scons - build Results and their dependencies<br />
<br />
scons view - build Results and their dependencies, try to open a plot command for each Result<br />
<br />
scons lock - build Results and save them to $RSFFIGS<br />
<br />
scons -c - clean the local directory<br />
<br />
scons -n - try a dry-run of scons<br />
<br />
== Program browser == <br />
<br />
The program browser is nearly identical to the standalone version mentioned above, but this version has three additional buttons:<br />
<br />
=== Add Flow === <br />
<br />
Add the selected program as a Flow item to the Sandbox. Flows have black outlines.<br />
<br />
=== Add Plot ===<br />
<br />
Add the selected program as a Plot item to the Sandbox. Plots have purple outlines.<br />
<br />
=== Add Result === <br />
<br />
Add the selected program as a Result item to the Sandbox. Results have blue outlines.<br />
<br />
== Log == <br />
<br />
The log updates you on the status of a running process. You are only allowed to have 1 (one) running process at a time. If the child process is hanging, you may kill the process simply by clicking '''Kill process'''. The process is then killed immediately, without a clean termination.<br />
<br />
== General workflow ==<br />
<br />
=== A new session === <br />
<br />
When a new instance of tkMadagascar is opened, the user is presented with an empty Sandbox. To get started, the user should open the '''Program browser''' from the '''View''' menu. The user may then browse, select, and add as many Flows, Plots or Results as they would like from the Program browser. <br />
<br />
=== Interacting with Flows, Plots and Results === <br />
<br />
Flows, Plots and Results appear in the Sandbox after they are added by the Program browser. All behaviors and actions that we describe are equally valid for Flows, Plots, and Results. For simplicity, we refer to only Flows from here on.<br />
<br />
You may move Flows by clicking and dragging with the left mouse-button. Additionally, all Flows are initially added to the Sandbox in the '''unconfigured''' state. To configure a Flow you must edit its parameters, selecting valid values for the parameters that you wish to set. To edit a Flow's parameters, you can '''right-click''' over the Flow, which will bring up a drop-down menu. Select '''Edit parameters''' from this drop-down menu, which opens a menu with a list of parameters and entry boxes.<br />
<br />
=== Configuring Flows ===<br />
<br />
Once the '''Edit parameters:''' window is open, you can simply input values for the parameters that you want to set. You only need to enter the value, you do not need to enter the value in "key=val" format. There are some special parameters that every Flow has:<br />
<br />
'''output''' - the name or names of files that you want to output to. If multiple files, then separate the names with a space. You do not need to include '.rsf' on the end of file names.<br />
<br />
'''input''' - the name or names of files that you want to input to. Same rules as above.<br />
<br />
'''custom''' - a raw string of any additional parameters that you want to set. You must set these parameters in "key=val" format, unlike the other parameters. There is no parameter checking for parameters set this way. Multiple parameters should be separated by spaces.<br />
<br />
Additionally, some programs have parameters that work on any axis. For example, sfspike allows the user to set the number of samples (n#) for any axis. These parameters are listed as the parameter name, with the # still attached. These parameters must be set with "key=val" formatting as well. <br />
<br />
For sfspike's n# parameter, you might set: n#= n1=100 n2=100<br />
<br />
Once a Flow is configured, the Flow will change color to have a green background and the name of the output file will appear inside the flow. A green Flow is good-to-go, and does not require any additional configuration. It will be automatically saved, exported, or executed. Unconfigured Flows may be saved, but will not be exported or executed.<br />
<br />
Click '''Accept''' to save your parameter selections.<br />
Click '''Preview''' to see how the Flow would look in an SConstruct (useful for debugging).<br />
Click '''Self-documentation''' to see the Programs self-documentation while editing parameters.<br />
<br />
=== Linking Flows === <br />
<br />
One of the nicest features of Madagascar is that programs can pipe their output to other programs, greatly reducing the need for intermediate files. This functionality is fully supported by tkMadagascar. To link two Flows, right click on the flow that you want to link to another Flow, and select ''' Link'''. The cursor will change to a cross-hair to indicate that you are in '''Link''' mode. Once in '''Link''' mode, click on the Flow that you want to link to. The Flow that is selected for linking is assumed to have desired output for the Flow that you right-clicked on. <br />
<br />
Once Linked, the two Flows move together, their borders change color, and their input and output parameters are automatically changed to reflect the fact that one is piping into the other. The border colors change as follows:<br />
Flows become light gray,<br />
Plots become light purple,<br />
Results become light blue.<br />
<br />
To '''Unlink''' a Flow, simply '''right-click''' on the Flow you wish to unlink, and then select unlink. The Flow will be detached. The other Flows in the Linked Flow will be detached as well, or placed into separate Linked Flows.<br />
<br />
=== Deleting Flows === <br />
<br />
To delete a Flow from the Sandbox simply '''right-click''' on the Flow, and select '''Delete'''. If you select '''Delete''' for a Linked Flow, then you will delete all Flows linked to it.</div>Jgodwin