mvc show pdf in div : Add text to pdf in preview control SDK platform web page wpf .net web browser 508TM12-A110-part1323

ShakeMap Manual 
Version 1.0  6/19/06 
more tables already exist, the program will complain, but will continue and make any tables that 
do not yet exist. 
If this is an upgrade to V3.0, you will want to convert the existing earthquake and shake_flags 
databases to MySQL. Programs exist for this purpose as well. These programs assume that the 
files ‘<shake_home>/database/earthquake’ and ‘<shake_home>/database/shake_flags’ exist. If 
they do not (possibly because you are actually following instructions and have installed this 
version of ShakeMap in a new directory), simply copy them from their old location into the new 
<shake_home>/database . Do the following: 
% cd <shake_home>/bin 
% ./eq2mysql 
% ./shake2mysql 
These programs will complain if the data they are inserting already exists, so if you need to 
correct errors, first drop (and recreate (with mktable)) or truncate the tables before running the 
programs again. Once you are satisfied with the results (as determined by running an event and 
looking at the home and archive pages on your web site), you will never use these programs 
again. It is unlikely that this will all work perfectly the first time. Feel free to run the programs, 
edit your ‘earthquake’ and ‘shake_flags’ files, drop and recreate the tables, and run the programs 
until it all works. Nothing will break. A simple way to check your work is to connect to MySQL 
and have a look at the table: 
mysql> use shakemap; 
… 
mysql> select * from earthquake order by tabsol; 
(You will want a nice, wide window to view this information.)  This will display all of your 
archived events in chronological order (or use ‘evid’ instead of ‘tabsol,’ above, to see events 
ordered by event id).
End of V3.0-specific block. 
Once the config files have been edited, the final step for installation is to create the web products 
and put them on the web server. To do this: 
% cd <shake_home>/lib 
% make web 
% cd <shake_home>/bin 
% ./transfer -permweb 
Check that the transfer was successful. You will probably need to run and transfer an event 
before the web pages will work properly. 
V3.0: Because V3.0 introduces compression of web products and a dramatically more efficient 
directory structure (both within the local ‘data’ directory and on the web sites), you may wish to 
rerun many (or all) of your existing events to save space. You will also want to delete all of the 
events from your web site(s). If you wish to do this but minimize the down time of the site, you 
SOFTWARE GUIDE 
101 
Installing the Software 
Add text to pdf in preview - insert text into PDF content in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
XDoc.PDF for .NET, providing C# demo code for inserting text to PDF file
add text pdf reader; how to enter text in pdf file
Add text to pdf in preview - VB.NET PDF insert text library: insert text into PDF content in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Providing Demo Code for Adding and Inserting Text to PDF File Page in VB.NET Program
how to enter text in a pdf document; how to add text box to pdf document
ShakeMap Manual 
Version 1.0  6/19/06 
can make a dummy web site on a local machine and modify ‘transfer.conf’ to transfer only there. 
Then rerun all of your events. Finally delete the existing web site(s) and copy the dummy site to 
the web server(s) (and don’t forget to change ‘transfer.conf’ back to its original configuration). 
You could accomplish the same thing by omitting transfer from the processing of each event, 
then deleting the events from the web site, then running transfer for all the events in sequence. 
Our web sites ended up being about 40% of their original size when we performed this task. 
Note that within the ShakeMap <shake_home> directory the subdirectory ‘data’ will contain all 
the event data and intermediate files as well as the final products to be transferred. Depending on 
the number of events, and the resolution of your grid and topography files, this directory can 
grow to be quite large. If disk space is limited on the install partition, the 'data' directory should 
be placed on a larger partition and a link to it (called ‘data’) should be made from the install 
directory. E.g.: 
% cd $SM_HOME
% rmdir data
% ln -s /bigdisk/shake_data data
3.3  Customizing ShakeMap 
3.3.1  Region-Specific Files 
There are a number of region-specific files that you will need to create (see Table 3.2A and 
Table 3.2B). You should give these files names different from those in the distribution or they 
will be overwritten when you upgrade. Most of these files are part of the configuration defined in 
‘mapping.conf’ and ‘grind.conf.’ See the configuration files themselves for more documentation. 
3.3.2  Configuration Files 
In the directory <shake_home>/config you will find a number of configuration files. It is 
important to read the documentation within these files as they provide most of the information 
necessary  to  customize  ShakeMap  to  your  particular  environment.  Table  3.2C  lists  the 
ShakeMap programs and the configuration files upon which they depend. All of the programs 
also depend on ‘mydb.conf’ to access the MySQL database. More discussion of shake.conf and 
mysql.conf can be found in the section “Running ShakeMap.” 
When  editing configuration files, please  note that the default values (as  described  in the 
documentation for some parameters) may not be the same as the value assigned to the parameter 
by default within the configuration file itself. The assigned value is the recommended value, the 
documented  default  is  only  used  if  no  assignment  is  made,  and  may  no  longer  be  the 
recommended value (but may have been retained for reasons of backward compatibility). 
Important Note: When editing shake.conf, please comment out the line: 
SOFTWARE GUIDE 
102 
Customizing ShakeMap 
C# WinForms Viewer: Load, View, Convert, Annotate and Edit PDF
Highlight PDF text. • Add text to PDF document in preview. • Add text box to PDF file in preview. • Draw PDF markups. PDF Protection.
how to add text fields to a pdf document; acrobat add text to pdf
C# WPF Viewer: Load, View, Convert, Annotate and Edit PDF
PDF Annotation. • Add sticky notes to PDF document. • Highlight PDF text in preview. • Add text to PDF document. • Insert text box to PDF file.
adding text to pdf file; how to add text to a pdf file in preview
ShakeMap Manual 
Version 1.0  6/19/06 
program : scfeed 
The program ‘scfeed’ will not function until a ShakeCast server is generally available and your 
system is configured to connect to it. 
(When upgrading please note: From time to time we make changes to programs that require 
changes to config files. These changes must be merged with the config files that the user may 
have modified in customizing his/her version of ShakeMap. This is a non-trivial problem, and 
our solution is a bit simplistic. The merging consists of inserting the user's potentially changed 
config statements as comments into the new config file. The user may then go through the file 
and select which config statements are appropriate. This process takes a few minutes, but is 
fairly easy. Except in the case of ‘transfer.conf,’ which turns into a mess when it is changed. In 
this case it is often easier to clean out the destinations and file lists in the new config, then go to 
the backup file ‘transfer.conf.BAK’ (always made to keep a safe copy of the user-modified 
config files around) and just cut and paste your old destinations and file lists back into the new 
config file.) 
3.3.3  Passwords 
You will need passwords to access a database through db.conf or mydb.conf (or for transfer 
using ssh or ftp). To set up a password file: 
% cd <shake_home>
% mkdir pw
% chmod og-rx pw
% cd pw
Create or copy your passwords file to ‘passwords.’ For an explanation of the format of this file, 
see ‘<shake_home>/src/lib/Password.pm.’ Also see the section “Running ShakeMap,” below for 
more on ‘mydb.conf.’ In general, the format for ssh and FTP passwords is: 
<machine> <username> <password> 
And for database access the format is: 
<dbname> <username> <password> 
where the substitutions for “dbname” and “username” above should exactly match the strings in 
the database configuration file. 
3.3.4  Web Pages 
You may also wish to make changes to the Web pages. We have tried to include much of the 
region-specific data in the Web.conf file, but there may be additional customizations needed. 
Please keep track of your changes and let us know so that we can add common items to the 
configuration file. The Web pages and templates can be found in <shake_home>/lib/genex/Web/. 
SOFTWARE GUIDE 
103 
Customizing ShakeMap 
How to C#: Preview Document Content Using XDoc.Word
With the SDK, you can preview the document content according to the preview thumbnail by the ways as following. C# DLLs for Word File Preview. Add references:
add text to pdf document in preview; adding text fields to pdf acrobat
How to C#: Preview Document Content Using XDoc.PowerPoint
C# DLLs: Preview PowerPoint Document. Add necessary XDoc.PowerPoint DLL libraries into your created C# application as references. RasterEdge.Imaging.Basic.dll.
how to insert pdf into email text; add text to pdf acrobat
ShakeMap Manual 
Version 1.0  6/19/06 
3.3.5  Automation 
Because each regional network is different, automation is left to you. Currently code exists to 
automate  generating ShakeMaps from two  types  of systems:   1)  a  database running  the 
NCEDC/SCEDC schema (as in southern California and Berkeley), and 2) earthworm running 
with the Oracle database. If you are using either of these systems you will be able to adapt 
current code. 
If you do not use one of the above data acquisition systems, you will need to first generate code 
that will process data in near-real-time. The output of this processing should include peak 
horizontal  acceleration,  peak horizontal  velocity,  and  5  percent-damped peak  horizontal 
acceleration (0.3, 1.0 and 3.0 second periods) for all horizontal component data. This information 
along with station information must be written into ShakeMap compatible XML files with 
filenames that end in “_dat.xml.” The event information – latitude, longitude, depth, and 
magnitude – should be written to a second ShakeMap compatible XML file – “event.xml”. See 
the section on “ShakeMap XML Input,” below, for a discussion of these file formats. Examples 
of  data  and  event  XML  files  can  be  found  in  the  distribution  in  the  directory 
<shake_home>/data/9583161/input. 
Next, you need a program to watch when these files are made, then copy them to the ShakeMap 
input directory and start ShakeMap. This could, of course, be the same program that creates the 
files. 
The  distribution includes a  program  called  ‘queue’  and  its  associated  configuration file 
‘queue.conf’  that  may be  of interest. queue waits  for an alarm  announcing  an event  or 
cancellation (see the programs ‘shake_alarm’ and ‘shake_cancel’) and then takes appropriate 
action depending on its configuration (i.e., given a location and magnitude it will either kick off 
a run of ShakeMap or ignore the event). It can prioritize and queue multiple events, and schedule 
events for automatic reprocessing at user-defined intervals. The program accesses a database to 
retrieve information on the earthquake, but should be fairly easy to adapt to other systems. 
If you develop a program (or modify queue) that you think might be of interest to other 
ShakeMap installations, please let us know and we will include it in a future release. 
3.3.6  Attenuation Relations 
V3.0: The calling convention for maximum() and random() has changed. Please be sure to 
update  your  custom  modules  to  reflect  this  change.   See  the  example  modules  (e.g., 
<shake_home>/src/lib/Regression/Small.pm) for examples of the new calling convention. 
Custom attenuation relations may be needed for some regions.  If you are going to develop a 
module, the interface must be modeled after the ones found in <shake_src>/src/lib/Regression 
(e.g.,  Small.pm). 
The  module  should  also  be  added  to  the  file 
“<shake_src>/src/lib/Regressions.pm.” 
SOFTWARE GUIDE 
104 
Customizing ShakeMap 
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
Remove bookmarks, annotations, watermark, page labels and article threads from PDF while compressing. Also a preview component enables compressing and
how to add text fields in a pdf; how to enter text into a pdf
C# PDF insert image Library: insert images into PDF in C#.net, ASP
viewer component supports inserting image to PDF in preview without adobe Insert images into PDF form field. How to insert and add image, picture, digital photo
adding text to pdf online; how to add text to a pdf document using reader
ShakeMap Manual 
Version 1.0  6/19/06 
3.4  Running ShakeMap 
ShakeMap consists of a series of programs (refer to list Table 3.2) that when run sequentially, 
produce the desired output and transfer it to its destination.   All of the programs will print 
documentation  when  run  with  the  ‘-help’  flag,  and  most  of  them  have  an  associated 
configuration file (found in the “config” directory and named “<program>.conf”) that controls 
the behavior of the program. 
3.4.1  Data Directory Structure 
Before running ShakeMap you must collect some data.  This data is stored in the data directory, 
and as mentioned elsewhere, it can become quite large.  Put it somewhere with lots of space and 
link to it from your distribution directory.  Each event is stored in its own sub-directory named 
for the event, whether this be a number or a text string.  This event name must be the same as in 
the file containing the event information – “event.xml”.  Within each event directory a number of 
subdirectories are created (Table 3.4).  ShakeMap will create all of these directories except “raw” 
and “input”. 
3.4.2  Creating the Maps 
Once the ShakeMap software is installed and configured, creating a ShakeMap is simple.  First, 
cd to <shake_home>/bin (e.g. /opt/ShakeMap/bin), then execute ‘shake’: 
% ./shake -event <event_id> 
This will run the pre-configured set of programs as specified in “shake.conf”. If you would like a 
little more information about the progress of the run, use the -verbose flag to ‘shake’. 
It is not always appropriate or necessary to run all of the programs. For instance, when running a 
historic event, or an event not otherwise in the database, the ‘retrieve’ program will probably fail, 
causing ‘shake’ to abort.  One possibility is to reconfigure “shake.conf” to skip the unnecessary 
program(s).  Another option is to use the -dryrun flag: 
% ./shake -event <event_id> -dryrun 
Which will produce output showing the programs that shake would run (and their options) 
without actually running them: 
/opt/ShakeMap/bin/retrieve -event 9108645 
/opt/ShakeMap/bin/pending -event 9108645 
/opt/ShakeMap/bin/grind -event 9108645 -qtm -boundcheck 
-lonspan 4.5 -psa 
/opt/ShakeMap/bin/mapping -event 9108645 -timestamp -ascii 
/opt/ShakeMap/bin/shakemail -event 9108645 
SOFTWARE GUIDE 
105 
Running ShakeMap 
VB.NET PDF insert image library: insert images into PDF in vb.net
try with this sample VB.NET code to add an image As String = Program.RootPath + "\\" 1.pdf" Dim doc New PDFDocument(inputFilePath) ' Get a text manager from
add text to pdf; how to add text to a pdf in acrobat
How to C#: Preview Document Content Using XDoc.excel
following. C# DLLs: Preview Excel Document without Microsoft Office Installed. Add necessary references: RasterEdge.Imaging.Basic.dll.
how to add text to pdf document; add text pdf acrobat professional
ShakeMap Manual 
Version 1.0  6/19/06 
/opt/ShakeMap/bin/tag -event 9108645 -mainshock 
/opt/ShakeMap/bin/genex -event 9108645 
/opt/ShakeMap/bin/print -event 9108645 
/opt/ShakeMap/bin/transfer -event 9108645 -www -ftp 
You may then run the programs you choose and ignore the others.  For instance, if you were to 
make a change to the “estimates.xml” file, you might just run ‘grind’ and ‘mapping’ and then 
look at the plots as PostScript (the .ps files in the “<shake_home>/data/<event_id>/mapping” 
directory).  You could then run ‘genex’ and look at the JPEGs.  Or also run ‘transfer’ and look at 
the images on your Web site. 
3.4.3  The Gory Details 
Of course, it is never that simple. And even if it were, there are reasons for having a better 
understanding of the system. Here, then, is more detailed information on configuring ‘shake’ and 
on the way the versioning system works. 
3.4.3.1  shake.conf 
The program ‘shake’ is the main ShakeMap program. Its job is to run a series of other programs 
in  a  specified order,  possibly calling  the  programs  with invocation  flags  that  vary with 
magnitude. The program can also be told to call certain programs only the first time a given 
event is processed. Run shake -help to see other options. 
At this point, it is recommended that you read ‘shake.conf’ (in ‘<shake_home>/config’) to get a 
basic idea of what is available. The default configuration is probably about right for most 
installations (except for the “program : scfeed” line, which you will want to comment out until 
you  are  configured  to  communicate  with  a  ShakeCast  server).  Some  of  the  parameters 
(‘once_only,’ ‘no_dep,’ ‘cancel,’ and ‘scenario_skip’) probably won’t need to be changed unless 
you add a new program to the processing sequence with the ‘program’ parameter (and maybe not 
even then). 
‘shake.conf’ is also the configuration file for the program ‘cancel,’ which effectively undoes the 
effects of shake,  removing the event  from  the  system,  sending cancellation  notices, and 
rebuilding the web pages to reflect the absence of the cancelled event. 
3.4.3.2  The Processing Sequence and shake.conf 
ShakeMaps are not always automatically generated. Frequently, manual intervention is necessary 
or desirable, and we often run one or more of the programs repeatedly until we are satisfied with 
the results. For example, the automatic processing sequence might go something like this: 
retrieve  pending  grind  tag 
mapping 
genex 
shakemail 
transfer 
setversion 
scfeed 
SOFTWARE GUIDE 
106 
Running ShakeMap 
ShakeMap Manual 
 
Version 1.0  6/19/06 
But after the automatic run, we might wish to change the map dimensions or centering by 
changing the options to grind. Our manual sequence might look like this: 
grind 
mapping 
genex 
transfer 
scfeed 
We might run the grind 
mapping pair several times in succession until we are satisfied with 
the results. Satisfied, we then run transfer to update the web pages with our new maps. Previous 
versions of ShakeMap would happily do this, despite the fact that we forgot to run genex and, as 
a result, some of our products (e.g., the PostScript maps) do not agree with others (e.g., the JPEG 
maps and shapefiles). 
Starting with ShakeMap V3.0 we have introduced the idea of program dependency. Simply put, 
a program is considered to be dependent on the programs that precede it in the processing 
sequence, and it will not run unless the sequence is run in the proper order. For instance, in the 
above example, transfer would recognize that mapping had run more recently than genex and 
would abort with an error message explaining the problem. 
Things to be aware of: 
1)  The processing sequence is defined by the order of ‘program’ lines in ‘shake.conf.’ 
2)  A program that does not affect the performance of programs later in the sequence (i.e., 
later programs do not depend on its output) can be identified with a ‘no_dep’ line in 
‘shake.conf.’ For instance, shakemail sends email to interested parties, but does not 
generate data that any program later in the processing sequence depends upon. Thus, 
shakemail is declared ‘no_dep.’ When a later program (e.g., transfer) runs, it will not 
include shakemail in its investigation of the processing sequence. But (this is important!) 
shakemail itself will still require the programs that precede it to be run in sequence. Thus, 
if shakemail is run immediately after mapping, it will complain that genex has not been 
run. 
3)
 
You do not have to always start at the beginning of the sequence. Once an event has been
run once, you can start anywhere in the sequence. You can jump in and re-run mapping.
You can run it a bunch of times in a row. Then you can run genex. Then you can run
mapping again. Then you can run grind. What you can’t do is use out of date output.
4)  Yes, it seems complicated. But it is actually simple. Assume the function T() returns the
time a program, P, was most recently run. Assume that ‘P
P
n
’ is the n
th 
non-no_dep
program  in  the  processing  sequence.  The  software  enforces  the  relation:
T(P
1
)<T ( P
2
)<. . .< T ( P
n- 1
with the provision that each of the n-1 earlier programs has run at least once. 
5)  You can always force a program to run with the -forcerun flag. 
So how does the system keep track of all this?   By using the ‘shake_runs’ database table 
described in the next section. 
3.4.3.3  Flags, Versions, and the MySQL Database 
During the ShakeMap installation process you created a number of tables in your MySQL 
database. These tables replace the old ‘earthquake’ and ‘shake_flags’ Text::CSV tables in pre-
SOFTWARE GUIDE 
107
 
Running ShakeMap 
ShakeMap Manual 
Version 1.0  6/19/06 
V3.0 ShakeMap, and provide functionality to support versions and the processing sequence 
integrity system described above. 
The database tables in the shakemap database can be listed with mysql: 
mysql> use shakemap; 
Database changed 
mysql> show tables; 
+--------------------+ 
| Tables_in_shakemap  | 
+--------------------+ 
| earthquake 
| server 
| shake_lock 
| shake_runs 
| shake_version 
+--------------------+ 
5 rows in set (0.00 sec) 
The ‘server’ table contains information the ShakeCast system needs to connect to a server. This 
information will be provided to individual regions when the ShakeCast system is fully available 
(early 2004 is the target date). 
The ‘earthquake’ table is very similar to the earlier CSV table of the same name: 
mysql> describe earthquake; 
+-----------+-----------+------+-----+---------+-------+ 
| Field 
| Type 
| Null | Key  | Default | Extra  | 
+-----------+-----------+------+-----+---------+-------+ 
| evid 
| name 
| char(80) 
| char(255)
| YES 
| PRI  | 
| NULL 
| locstring 
| tabsol 
| tzone 
| mag 
| lat 
| char(255) | YES 
| datetime  | YES 
| char(8) 
| YES 
| double 
| YES 
| double 
| YES 
| NULL 
| NULL 
| NULL 
| NULL 
| NULL 
| lon 
| mainshock 
| cluster 
| double 
| char(20) 
| char(80) 
| YES 
| YES 
| YES 
| NULL 
| NULL 
| NULL 
+-----------+-----------+------+-----+---------+-------+ 
10 rows in set (0.00 sec) 
This table is accessed and modified by a number of programs (tag, genex, cancel, etc.). Its 
primary purpose is to maintain a complete inventory of the events for which ShakeMaps have 
been made. Under rare circumstances you may have to edit this table (using SQL commands), so 
the following table describes the columns. 
SOFTWARE GUIDE 
108 
Running ShakeMap 
ShakeMap Manual 
Version 1.0  6/19/06 
Name 
Description 
Valid values 
evid 
The event identifier. 
Any text string that forms a valid 
Unix  filename,  up  to  80 
characters. 
name 
The 
eve
long, possibly descriptive name of the 
nt; will be printed at the top of the maps. 
Any  text  string  up  to  255 
characters. 
locstring  The 
fiel
‘tag
on t
location of the earthquake. If the name 
d is not specified (through the program 
’), this text will be used as the event name 
he maps. 
Any  text  string  up  to  255 
characters. 
tabsol 
The date and time of the event in the format: 
yyyy-mm-dd hh:mm:ss 
From 1000-01-01 12:00:00 AM to 
9999-12-31 11:59:59 PM 
tzone 
The timezone of ‘tabsol,’ above. 
Usually  ‘GMT,’  but  could  be 
‘PST,’ ‘MDT,’ etc. 
mag 
The earthquake magnitude. 
Any valid magnitude. 
lat 
The latitude of the earthquake epicenter. 
North  is  positive,  south  is 
negative. 
lon 
The longitude of the earthquake epicenter 
West is negative. 
mainshock  Val
l
the 
ue set by the program ‘tag’ to categorize 
earthquake 
Valid values include ‘’, ‘current,’ 
‘historic,’  ‘scenario,’  and 
‘invisible.’ 
cluster 
If t
fiel
the 
a  s
seq
his event is part of a larger sequence, this 
d specifies the evid of the mainshock in 
sequence. This may be useful for creating 
pecial  archive  page  for  a  particular 
uence. 
Any valid evid. 
The table ‘shake_lock’ table is used to prevent multiple ShakeMap processes from operating on 
an event at the same time. Each ShakeMap program will acquire the lock before it begins 
processing, and will release the lock when it quits (or is killed). 
mysql> describe shake_lock; 
+---------+----------+------+-----+---------+-------+ 
| Field 
| Type 
| Null | Key | Default | Extra | 
+---------+----------+------+-----+---------+-------+ 
| evid 
| program
| char(80) | 
| char(80) | 
| PRI | 
| pid 
| tepoch 
| int(11) 
| int(11) 
| 0 
| 0 
+---------+----------+------+-----+---------+-------+ 
4 rows in set (0.00 sec) 
The columns are: the event id, the name of the program, the process id of the locking process, 
and the Unix epoch time that the lock was acquired. Occasionally, a lock will be held when the 
locking process is dead or hung. The lock can be broken by 1) using the ‘-forcerun’ flag to the 
next program, or 2) calling the program ‘unlock’ with the event id of the locked event (this 
SOFTWARE GUIDE 
109 
Running ShakeMap 
ShakeMap Manual 
Version 1.0  6/19/06 
program will also optionally try to kill the locking process), or 3) if a lock is stale (more than 
fifteen minutes old), ShakeMap programs will automatically unlock the event and continue 
processing after issuing a warning message. 
The ‘shake_runs’ table keeps track of the last run of each program for each version of an event. 
But first: 
A Digression on Versioning 
After a great deal of discussion and consideration, we decided that the most useful demarcation 
of a ‘version’ of a ShakeMap (which is really a collection of products) is the point at which the 
products are distributed to external destinations. In other words, we create a new version every 
time we run transfer, whether or not that version differs in any significant way from the previous 
version. (Models that assigned version numbers to each product based on its difference from the 
previous version of that product, while sexy, were ultimately found to be too complicated, 
unreliable, and unworkable. Consider, for example, a JPEG map that varies in no way from 
another map, except that the embedded processing date is different. Is that a different version? 
Some say “yes,” some say “no.” Plus, no one could come up with a compelling reason for 
defining versions this way. But our digression digresses…) 
So how does this versioning system work?  Let us assume that transfer has just run on an event 
and created version ‘N’ (if transfer has never run for this event, ‘N’ would be zero). We then run 
one of the other programs in the processing sequence. For instance, we run grind to change the 
“lonspan.” The program will inspect the ‘shake_version’ table and determine that the most recent 
version of the event is version ‘N.’ grind will then declare itself to be working on version ‘N+1.’ 
It will check that the processing sequence is being honored, do its processing job, then insert 
some information about itself (its name, the current time and date, the version, and the flags with 
which it was invoked) in the ‘shake_runs’ table before exiting. If we were to run this program 
again, it would go through the same process, but when it found that a row already existed in the 
shake_flags table for  that event/program/version combination, it would simply update the 
date/time and invocation flags. It would still be version N+1. We could run it twenty times and it 
would still be version N+1. We could then run mapping (version N+1) and genex (version N+1). 
We could go back and run grind some more (still version N+1). Finally, when we run transfer, 
the new version is declared complete, a new row is inserted in ‘shake_version’ for version N+1, 
and the products are transferred to the world. The next time a program in the sequence is run, it 
begins version N+2. And so on. 
(In the situation where some programs were not run, the missing programs are inserted into the 
‘shake_runs’ table with the new version number, but the date/time and flags of the previous 
version. For example, we could run mapping, genex, and transfer, without ever re-running grind 
(which is a valid thing to do – see the section on the Processing Sequence, above). When the new 
version was set, the system would copy the flags and time/date of the previous run of grind, but 
give it the new version number.) 
By using this system, we have a complete record of the programs and their invocation flags for 
each version of the event that we transferred to the world. In conjunction with the judicious use 
of the program ‘setversion’ (which will save a copy of the input data and the configuration files 
SOFTWARE GUIDE 
110 
Running ShakeMap 
Documents you may be interested
Documents you may be interested