Jmol is a powerful, free program that displays 3D molecular models. The models, displayed and colored as desired, can be rotated and zoomed interactively with the mouse. The tutorial-authoring tools discussed here, Proteopedia and JTAT, use Jmol (in its java applet form) within a web browser. Tutorials may be made freely available on-line, or, in the case of JTAT, can also be projected from a local (optionally private) copy.
The easiest and quickest way to create a molecular structure tutorial in Jmol is with Proteopedia.Org, an innovative free website created in 2007 by Sussman, Prilusky, and Hodis. Its Scene Authoring Tool makes it quite easy to create customized molecular views or scenes, and its wiki format makes it easy to describe your scenes with accompanying text. "Green links" placed in the text show your views. Examples of such tutorials are linked to Proteopedia's main page.
Proteopedia limits what you can do, to some degree, which contributes to its ease of use. JTAT offers greater control, and offers several features and amenities to enhance your tutorials, but these come at the price of requiring additional skills and time during tutorial authoring.
Luckily, you don't have to decide in advance which to use. We recommend that you start making a tutorial in Proteopedia. Then, if it seems worthwhile, you can easily move the scenes and text from Proteopedia into JTAT, to get a feel for what is involved. In fact, we recommend using Proteopedia to author your molecular scenes, even when you plan to deliver your tutorial in JTAT.
Both Proteopedia and JTAT tutorials operate in standard web browsers, such as Firefox, Internet Explorer, and Safari (Windows, Mac OS X, or linux). Both support multiple molecules in one page/chapter, and both have toggles for graphics quality. They differ in the following features:
|
||
Features | Proteopedia | JTAT |
Molecule | May scroll out of view. Often small, but can be enlarged temporarily (with edit preview) or permanently. | Always visible and large.Text and view buttons scroll without moving the molecule. |
Compare
Molecules Side by Side |
Yes, but no synchronization
(as of 4/08). |
Yes, up to 4, with synchronization,
maintaining alignment. |
Details | All text is always in view. There is no mechanism to hide "details". | Details are hidden, e.g. when projecting to an audience, but can be displayed, e.g. when one person is viewing the tutorial. Showing details for one molecular view at a time leaves more view descriptions visible, making it easy to see where you are in a series of molecular views. |
Slider | None. | Zoom slider invites user to zoom without remembering mouse gestures. Optional slab slider. |
Centering | Only via Jmol's menu. | Centering convenience button is provided below the molecular view. |
Authoring: Text | Easily type into a form as wiki text. | Text editor needed to type HTML into disk files. Familiarity with a little HTML is required -- HTML quick reference is provided. |
Authoring: Molecular Scenes/Views | Superb Scene Authoring Tool makes it incredibly easy. | Using Proteopedia's Scene Authoring Tool is recommended. Then you simply paste the resulting script into a .spt file. |
Editing of content by users. | Easy: its a wiki! Authors may protect tutorials but their contents can be copied to other pages for editing and adaptation by others. | Editing files with a text editor is possible only when the tutorial's author chooses to make the files available by download or email request. |
Putting the tutorial online | Automatic. All contributions are online immediately because its a wiki. | Requires uploading to a server. (Author may choose not to put the tutorial online, but this denies access by students.) |
Proteopedia and JTAT enable authors of macromolecular structure tutorials to concentrate on the scientific content, rather than on web page programming. Authors choose molecules, design molecular views, and explain them. JTAT provides a template or "shell" that sets up the molecular display, a scrolling panel of view buttons and descriptions, ready-made style sheets, and many other amenities that improve usability and make your tutorials look classy. Typically, most molecular views show a single molecule, but JTAT can show two, three, or four molecules for side by side comparisons. The best way to see JTAT's range of capabilities is to run through the JTAT Demonstration Tutorial.
JTAT displays molecules in a web browser, using the Jmol java applet, a free, open-source molecular display program that requires no installation. JTAT tutorials work from disk files (off line) or from servers (on line). They work in Windows (in Internet Explorer, Mozilla Firefox), in Mac OS X (in Safari or Firefox), and in linux (in Firefox).
In brief, after getting familiar with these instructions, you download JTAT. It includes an empty template, which is a working tutorial, except without any molecular content. You view the template in your favorite web browser. Then, following the instructions below, you insert molecular content into the template. The content consists primarily of customized molecular views, with descriptions of the views, which include color keys: text colored to match the colors of the molecule. After each change to your tutorial's content, you reload it in the browser to see the change. When you're finished, you can put the tutorial on-line for use by your students, or project it from local files (or on-line) to illustrate a lecture.
Proteopedia.Org is the easiest and quickest way to create an on-line macromolecular structure tutorial. A detailed comparison with JTAT is in the table above, and succinct comparisons with other tutorial-authoring systems are on JTAT's main page.
We suggest that you begin by creating, in Proteopedia, a few scenes
(views) of the molecule(s) that will feature in your tutorial, and also
that you begin writing their descriptions there. You will need to apply
for an account at Proteopedia.Org, which requires that you use your real
name. Click the log in/request account
link at the upper right
at Proteopedia.Org.
Proteopedia's Scene Authoring Tool is by far the easiest way to create a customized view of a macromolecule. You may decide that completing your tutorial in Proteopedia, and leaving it there on-line, meets your needs quite well.
Protected Pages. Proteopedia is a wiki. Unlike most wiki's, however, you can protect your tutorial in Proteopedia from changes by others. (By contributing your tutorial to Proteopedia, you give others permission to copy your tutorial, and modify and adapt the copy, but your original will remain intact.) Instructions for creating protected pages are linked to Proteopedia's main page, under What Can Proteopedia Do For Me?.
Scenes and scene descriptions that you create in Proteopedia can readily be installed in JTAT. Indeed, Proteopedia is the easiest way to create macromolecular scenes for JTAT, and the way that we recommend. Other methods are described below.
Jmol requires java.
Jmol comes in two forms, both of which have the same display
capabilities and command language. Both require java in order to
operate. Java is free, and cross-platform
; that is, it
enables programs written in java to run identically on Windows, Apple Macs, or
linux, without needing a different implementation for each platform.
Apple Mac OSX comes with java, and Apple Software Updates keep it up to date.
Windows comes without java, but java can be installed at no cost,
quickly and smoothly from
java.com. Java is used by many other programs besides
Jmol.
Jmol Applet. JTAT uses the applet form of Jmol because this is the form that operates within a web browser. Delivering tutorials to users on the web has many advantages. The browser makes the display, layout formatting, and organization of text relatively easy. Delivering tutorials in browsers makes them highly accessible. When a web surfer visits a site that uses Jmol, Jmol is sent to the user's browser silently, quickly, and automatically. This means that, aside from having to install java on Windows systems, nothing needs to be installed in order to use a Jmol applet-based tutorial. When you download JTAT, the Jmol applet is included.
Web browsers contain a versatile programming language called javascript (not to be confused with java). This makes it possible to have menus, buttons, and links that control the molecular view within the applet. It also enables the applet to inform the browser about actions taken by the user, such as what atom has been clicked. JTAT uses javascript extensively, but you will need to learn hardly any javascript in order to use JTAT to author a tutorial.
Jmol Application. The Jmol application is a stand-alone program (as are RasMol, PyMol, and many other popular molecular visualization programs). Unlike the Jmol applet, it runs independently of, and has nothing to do with, web browsers. And unlike RasMol and PyMol, which need implementations (source code compilations) specific for each computer platform, a single Jmol program runs identically (with the help of java) on Windows, Apple Macs, and linux. Optionally, the application can be used when you are developing molecular view scripts for JTAT. Instructions are provided.
Biochemistry. We assume that you know about, or are learning about, a molecular structure -- and that you wish to present a series of informative views of this molecule, explaining its salient structural features, and how they support its function.
Text Editing. First, you'll need to be able to edit plain text files, using a text editing program. Plain text editors include Notepad, a simple but adequate text editor that comes with Windows, and TextWrangler or BBEdit, superb text editors for Macs. You can also use word processors (such as Wordpad in Windows, Textedit or iWork Pages on Macs, or Microsoft Word) but then you must be careful to save the file as plain ("ASCII" or "DOS") text. If you inadvertantly save it as a document file, it won't work -- but then you can simply re-save it as plain text.
You'll need to edit plain text files that contain the text descriptions for your molecular views, and the Jmol script (.spt) files that specify those views.
Windows Notepad: Start, (All) Programs, Accessories, Notepad.
Mac OSX: TextWrangler is an excellent and free text editor for Mac OS X. BBEdit, from the same company, is the supreme Mac text editor (30 day free demo). Get them from barebonessoftware.com
HTML (HyperText Markup Language). Second, you'll need to be familiar with just a little HTML, in order to color your text to match colors in the molecular view, and to insert links and images into your tutorials.
Jmol scripting.
Third, you'll need some familiarity with the Jmol molecular view command scripting language.
This is a superset of the RasMol and Chime command languages. Command scripts, or
scripts
for short, will be saved in plain text files whose names end ".spt".
Gather the PDB codes for the molecular models that you want to display in your tutorial. Good places to search for published PDB files are listed in the syllabus for the most recent Martz Workshop.
Download the PDB files themselves. After you set up the directory for your new tutorial, these files can be put in the directory jtat/tutorial_name/molecules4all. ("molecules4all" means "molecules for all chapters" -- you may use a given PDB file in more than one chapter, or not, as needed.) Make sure that the saved filenames are all lower case (see below) and end in ".pdb".
You can download any molecular model that you see in Jmol (or Chime). Click on the "Jmol" frank in the lower right corner beneath the molecule, to open Jmol's menu. Click the top item on the menu, and then the last item on the submenu that opens. If the PDB file appears in the browser as text, use the browser's File, Save As, and save the file as plain text with a lower case filename ending with ".pdb".
Plan what you want to show and explain in your tutorial. The best place to start exploring a molecule is Proteopedia.Org: it shows the name of the molecule, the reference to the original publication, the abstract from the original publication, the resolution of the model, the locations and full names of ligands and functional sites, and more. From within Proteopedia, click the link (beneath the molecule) to FirstGlance in Jmol for further exploration.
The material that follows will make a lot more sense if you get familiar
with the
JTAT Demonstration Tutorial.
First, you need to be familiar with how the Demo looks in a browser.
This will help you understand what we mean below by Table of Contents
and Chapter
, molecular views, etc. Then, as you read below, be sure
to look at the folders and files that make up jtat/jtatdemo. This will give
you a concrete example to see how those folders and files support
the tutorial as it appears in a browser.
It is very important that you understand the organization of
files and folders within JTAT. This will enable you to avoid
inadvertently breaking
JTAT, and enable you to place your new
tutorials and alterations correctly. It will greatly facilitate
moving your tutorials to new versions of JTAT, should new
versions become available.
The jtat
folder.
All of JTAT is contained in a folder (directory) we'll call jtat
. When
you download JTAT, the main folder will include its release date
in its name. For example, jtat_2008_02_15 would signify a release
date of 15 February (02), 2008. It is best to leave the release date in
the folder name because you may well end up with several versions of JTAT side by
side (see next paragraph), in which case leaving the release dates of each in their
folder names will be very helpful.
The release date of each version of JTAT is displayed at
the bottom of the control panel in every tutorial.
Below, we'll refer to the folder generically as jtat.
JTAT versions.
You can have multiple versions of JTAT side by side, as long as
the main jtat
folder has a distinct name for each version.
In some cases, it might be simpler to leave a well-functioning
tutorial in an older version, particularly when it would need
extensive revisions to make it compatible with a newer version of
JTAT.
Tutorial folders.
Multiple tutorials can be contained in jtat
, each in its
own folder. For example, the JTAT Demonstration Tutorial is in a
folder named jtat/jtatdemo
. Were you to create a new tutorial
on acetylcholinesterase, an appropriate folder name for it would
be jtat/acetylcholinesterase
. This folder will contain all
text, molecular view scripts, images, and other components that are
specific to this tutorial.
All tutorials in jtat
share the JTAT shell
, that
is, the code that sets up and operates the tutorial. This code is in
a set of standard folders that are shared in
common among all tutorials, and are named as follows:
Each tutorial that you create will add another folder to the above list.
In addition to the above folders, the following are the only
files that should be present in jtat
:
JTAT files you can edit. For the most part, you should not alter the jtat files or folders that are outside your tutorial's folder. There are a few exceptions listed below. However, most authors will never need to touch any of these files (except for index.htm).
jtatfolder. If you wish to change one of these settings in one or a subset of the tutorials in the current
jtatfolder, you should change or add these settings in the relevant file(s) in jtat/tutorial_name/js4all.
jtatfolder. Styles specific to one or a subset of the tutorials belong in jtat/tutorial_name/css4all.
Copy the Template.
To create a new tutorial,
copy (duplicate) the folder named
template
(in the jtat
folder),
including all the folders and files it contains.
Now rename Copy of template
to, for example,
acetylcholinesterase
(or whatever is the topic of your planned
tutorial). Below, we'll refer to it generically as tutorial_name
.
Lower case for all folder and file names! Nearly all file and folder names in JTAT are entirely in lower case letters. (The exceptions are Jmol.js and jmolApplet*.jar.) We strongly recommend that you use only lower case letters (a, b, c, ...) and no upper case letters (NOT A, B, C, ...) in file and folder names. Case mismatches in file or folder references are harmless in Windows and Macs, but when your tutorial is moved to a server, they can be tedious to fix!
View Your New Tutorial. There are several ways to set up a convenient way to view your new tutorial. Use whichever you like.
Send To, Desktop (create shortcut).
index.htmon your Desktop, and rename it to your tutorial_name. To view your new tutorial, double-click it.
Note that Firefox is recommended (in both Windows and Macs) for developing and testing JTAT tutorials (see below).
Files and folders making up a tutorial.
Your new tutorial folder (we'll call it tutorial_name
) should contain the following:
ch_, e.g. ch_view1, ch_movie, ch_spin, etc.
If you haven't already done so, put the PDB files you need in jtat/tutorial_name/molecules4all.
Before starting to add content to your new tutorial, it will
be helpful to understand the files that will make up each chapter.
The folder for each chapter (we'll call it chapter_name
)
needs to contain the following files. The contents folder contains
similar files as indicated.
View 1, plus some additional commands that display only when the chapter is first entered. So typically, this script calls view01.spt, but adds a few things to it. For examples, see the initial-view.spt files in jtat/jtatdemo. JTAT expects and calls this script automatically; you do not need to refer to it in chapter.js.
View 1in this chapter. You can name this file anything as long as it ends in
.spt. Its name must be specified both in initial-view.spt, and in chapter.js for the first View button.
.spt, and is specified correctly for its corresponding view button in chapter.js.
This section assumes that you have already followed the instructions under How to Start a New Tutorial.
Title.
When you first view your copy of the template in your browser,
at the top, you'll
see someting like Put Tutorial Title Here
. Let's do that.
This may be the first time you will be editing a .js
(javascript) file, so in the next section, we discuss some technical problems that might occur,
and how to find and fix them. It would be a good idea to read
Editing Javascript Files
before continuing with this section.
In the file jtat/tutorial_name/contents/contents.js, you will find a line something like this:
Use your text editor to replace the placeholder text with the real title of your tutorial. For example, you might change the above line to this:
Now, save the changed file (as plain text), and then reload your tutorial in your browser, and you should see your real title in the browser.
If you do not see the the title that you typed into the file contents.js, please read the following section, which describes troubleshooting.
Adding textual content to your tutorial is largely a process of repeating the above cycle: change a javascript text variable, save the .js file, reload the page in your browser, and troubleshoot if anything goes wrong.
Do you need a Contents page in your tutorial? If your tutorial will have more than one chapter, you should use a Contents page (which serves as a Table of Contents) that provides a list of your chapter titles, and a link to enter each chapter.
If you will have only one chapter, you may prefer to skip the Contents page. In order to do that, in the file jtat/tutorial_title/index.htm, change this line
to this line
Of course, if you renamed the folder chapter01
to something else,
you'll need to use that name in the above line.
If you decide you don't need a Contents page, because you plan to have only one Chapter, then you should put your first molecular scene, and its description, in the file jtat/tutorial_name/chapter01/chapter.js. If later you decide to add additional chapters, and then you would like to have a Contents page, simply reverse the change described above that skips the contents, and put a molecular view, and links to your chapters, in the file jtat/tutorial_name/contents/contents.js.
Editing javascript files. The textual content
in a JTAT tutorial is stored in javascript files, whose names
end in .js
.
The text itself is stored in various javascript
text string variables. For example, in the file
jtat/tutorial_name/contents/contents.js you will find:
The above line defines the javascript variable chapterTitle to contain the text you see in quotation marks. You simply edit the text between the quotation marks to put in a real title. For example
The tricky part is to avoid inadvertantly changing the parts shown in red here:
Those
red parts are absolutely required, unchanged.
For example,
none of the following will work. (Portions following //
are
comments, that is, they are ignored by javascript.)
So, the trick is to pay careful attention to leaving the javascript
syntax intact. (The word var
is not always needed.
It depends on issues we don't need to get into here. If var is present,
leave it; if not, don't add it.)
It is highly recommended that you make one change at a time to a javascript file, and then reload the relevant page of your tutorial in the browser to confirm that all is well. When you have made many changes before testing the result (by reloading in the browser), it becomes much harder to find the problem. But what if you do accidentally damage the javascript?
Troubleshooting: The Javascript Console. Sooner or later you will accidentally damage the syntax of the javascript. It happens to the best of us -- fairly often! The symptom will typically be that parts of the page will fail to appear in the web browser.
The Firefox web browser is particularly good at telling you exactly where the problem is. Therefore, we highly recommend that you use Firefox (on both Windows and Macs) for testing JTAT tutorials during development.
Firefox locates broken javascript in its Error Console.
This is a special window that is opened from Firefox's Tools
menu.
So, whenever you suspect a problem with javascript, check the Error Console.
To make sure that only current errors are shown, press the Clear button
in the Error Console, reload your page in the browser, and then check the
Error Console again.
Double vs. single quotes . It doesn't matter whether a text string is double or single quoted, provided the opening quote and the closing quote are matched. These two are valid and equivalent:
A common pitfall is to include quoted material within a quoted string. This
is best accomplished by using double vs. single quotes. For example,
suppose we want the word red
to appear in color, using an HTML
font color tag. The following will not work because the opening quote
around red
(marked with ^)
inadvertantly closes the whole text string variable.
var chapterTitle = "A <font color="red">Red</font> Molecule"; // INVALID /^\
The solution is to use double quotes within single quotes (or vice versa):
var chapterTitle = 'A <font color="red">Red</font> Molecule'; // VALID var chapterTitle = "A <font color='red'>Red</font> Molecule"; // VALID
But you have to be careful to match each pair!
var chapterTitle = 'A <font color="red">Red</font> Molecule"; // INVALID /^\
Apostrophes and escaping quotes.
Single quotes are often used around the main text, so you can double-quote
items within the text, such as red
font coloring. In such cases,
you cannot use a single quotation mark as an apostrophe, because it
prematurely terminates the quoted string:
var chapterTitle = 'An Amino Acid's <font color="red">Mutation</font>'; // INVALID /^\
One solution, of course, is to use double quotes around the main text.
However, in the example above, we need double quotes within
the text for red
. So the solution is to mark the apostrophe as
being part of the text, not the end of it. This is done by preceding it
with a backslash (\), which is called escaping
it:
var chapterTitle = 'An Amino Acid\'s <font color="red">Mutation</font>'; // VALID
Literal quotes
. If you want literal quotation marks to appear
around a word or phrase in the text, use HTML quotation tags:
var chapterTitle = 'A <q>Quoted</q> Word'; // VALID
If the text is long (multiple lines), there are two ways to handle it.
chapterIntro = '<p> \n\ Here is some text that is long enough that we prefer to \n\ break it into several lines. Also, it makes the \n\ javascript more readable to put the paragraph tags \n\ on separate lines, as is done here. \n\ </p> \n\ ';
In the above method, leaving the \n\
off the end of a
line causes a fatal javascript error (meaning simply that the
javascript cannot be interpreted, and will fail to display
correctly). Another error that is nearly
impossible to find is inadvertantly putting a space
after \n\
. Firefox's Error Console will report unterminated
string literal
. The Error Console will tell you the line number
where the offending string begins. Check the end of each line carefully
looking for an (invisible) space.
The second method is like this:
chapterIntro = "<p> " + "Here is some text that is long enough that we prefer to " + "break it into several lines. Also, it makes the " + "javascript more readable to put the paragraph tags " + "on separate lines, as is done here. " + "</p> ";
The above two methods are equally good.
Empty string variables. Sometimes you want no text in a certain location. For example, you might not need a subtitle. In such cases, it may be crucial that the subtitle variable be defined but its value be empty:
var chapterSubtitle = ''; // VALID: EMPTY (BLANK)
Deleting the above line would leave the variable chapterSubtitle undefined, and could cause a fatal javascript error.
The following steps will install a molecular view on your Contents page.
Jmol makes it easy to specify the initial orientation and zoom for any molecular view. This can be done before you have customized the molecular rendering and coloring, afterwards, or again at any time you decide to change it. Here is how.
(This section makes some references to Jmol commands and command scripts. You may want to read the upcoming section on Scripting Molecular Views before proceeding.)
moveto /* time, axisAngle */ 1.0 { -512 593 -622 120.03} /* zoom, translation */ 111.93 0.0 0.0 /* center, rotationRadius */ {27.204605 41.80329 28.43788} 45.783455 /* navigation center, translation, depth */ {0.0 0.0 0.0} -49.80277 -41.18717 50.0; #OR #Follows Z-Y-Z convention for Euler angles reset;center {27.204605 41.80329 28.43788}; rotate z -87.96; rotate y 85.43; rotate z -6.31; zoom 111.93; set rotationRadius 45.78; Jmol script terminated
resetstopping just before
Jmol script terminated.
moveto, stopping just before the #OR.
zoom 15, which reduces the molecule to 15% of full size before it starts zooming into view.
movetoto the number of seconds over which you want the action to occur. Try different values to see what you like. Typically, about 2 seconds is good.
Viewbutton will leave the prior orientation/zoom unchanged. This means the user can rotate the molecule, and zoom it, and then see different views in that user-set orientation and zoom.
Describing the Molecular View in the Contents page.
You probably wish to provide a description of the molecular
view you have now installed in the Table of Contents
for your
new tutorial. In the file
jtat/tutorial_name/contents/contents.js, you will find the
javascript string variable chapterIntro. This is a good
place to describe the molecular view. If you wish to provide
additional details about the view, you may put the topic of these
details in topContentsDetailsTitle and the details
themselves in topContentsDetailsText.
Don't forget to make one small change at a time, and to reload your browser to see the changes (or troubleshoot any errors) after each change!
Using HTML in your tutorial text. By "text" in your tutorials, we mean the text you type into the javascript string variables for text that will be displayed in your tutorial, such as titles, subtitles, chapter links, text below chapter links, introductions, molecular view descriptions, details titles, details, and conclusions. If you wish to make some of your text strings, or portions of text javascript strings, larger, boldface*, italics, colored,
and so forth, you can do so by including HTML tags. JTAT includes a handy
from which you can conveniently copy and paste the HTML tags you need. If you need something more advanced, just search for "html" and what you need with Google.
Finishing the text in your Contents page. Now that you know how to put text into javascript string variables in the file jtat/tutorial_name/contents/contents.js, you can proceed finish up the text in your Contents page. Examining the variables in contents.js will show you where to put the subtitle, introduction to your tutorial, the name of your first chapter, any details you wish to provide, and the conclusion. All of these are optional except for the name of your first chapter. Those you don't need can be set to empty (blank) strings.
The Next Button. The usual way to enter a Chapter from the Contents is to click the link for the chapter's title. But there is also a Next button near the bottom of the Contents. In jtat/tutorial_name/contents/contents.js is a variable nextChapterButtonGoesTo, which comes set to go to chapter01. If you gave the folder for your first chapter a different name, you'll have to change chapter01 to the new folder name to make the Next button work.
Now you have created your first molecular view, in your Contents page, and described it. (If you still need to customize the molecular view, please see Scripting.) Completing your tutorial consists largely of adding one or more chapters, creating additional molecular views, and describing them.
Create Your First Chapter. The folder for your first chapter is already present: jtat/tutorial_name/chapter01. In order to add molecular views and text, you edit the file jtat/tutorial_name/chapter01/chapter.js in much the same way as you did for contents.js. In fact, you can follow the directions above for adding a molecular view (with one important difference, see the next paragraph), then setting its orientation and zoom, and describing it, for each molecular view in your first chapter.
initial-view.spt vs. view01.spt. In chapters (as
distinct from the contents), the first view on each page is
scripted in the file
jtat/tutorial_name/chapter_name/view01.spt. (Actually, you
can name the script file anything you want, as long as you
specify the name correctly in setupButton(...) in chapter.js.)
When you first enter the chapter, you may wish to have additional
special effects, such as having the message Click and drag on
the structure to rotate it fade in and then out, and to have
the molecule roll while zooming into view (as in Star
Wars). These "special effects" are needed only once, when you
enter the Chapter. Generally, the user doesn't want to see them
later should s/he revisit View 1. Therefore, when the chapter is
first loaded, the view is generated with initial-view.spt.
Later, if the View 1 button is clicked, only the
view01.spt is applied. So initial-view.spt calls
view01.spt (with the command script view01.spt
), and adds
any one-time special effects.
Replay/Reset Initial View is an optional button, present by default, that re-executes initial-view.spt, including any special effects. Often, you may decide to specify the initial orientation and zoom in initial-view.spt, but specify none in view01.spt. This means that revisiting View 1 does not change the orientation and zoom the user may have set in the previous view, allowing for better comparisons. Should the user wish to reset the view to the initial orientation and zoom, this is accomplished by clicking on the button Replay/Reset Initial View.
If the above distinctions between the initial view and View
1
are not clear, try this in the JTAT Demonstration
Tutorial. Enter the chapter 1. Molecular Views,
Descriptions, and Details
. Note the message that fades in and out
at the top of Jmol, and the rolling zoom of the molecule. Now click
View 2. Rotate and zoom the molecule with the mouse and zoom
slider. Click View 1 and notice that (i) the orientation and zoom
do not change, and (ii) the message does not fade in/out at the top of Jmol.
Now click the button Replay/Reset Initial View and note the differences.
More Molecular View Buttons. You may have as many molecular views in each chapter as needed. Simply copy the Molecular View Button block for each beyond the two provided. The buttons will appear in the order in which they occur in chapter.js. Therefore, if you want to re-arrange the order of existing buttons, simply re-arrange the order of these blocks in chapter.js.
view01.spt, view02.spt, etc. The default names for the script files for the views in a given chapter are view01.spt, view02.spt, etc. However, you may name these scripts in any way you wish, as long as you provide the correct script names in initial-view.spt and (for View 1), and in setupButton(...) (for each View button). Should you later insert a new view between, for example, Views 1 and 2, you could name its script view01a.spt or view015.spt (bearing in mind that the script for View 15 would be view15.spt).
Zoom and Cut/Slab Sliders? Please review the chapter Slider for Zoom, Cut (Slab) in the JTAT Demonstration Tutorial. Each chapter.js files contains these variables and default values:
You may have no zoom slider by setting showZoomSlider to false, but this is not recommended.
When a Cut (Slab) slider is present (set showSlabSlider to true),
checking the word Cut
(or Slab
) cuts the molecule
in half (at 50%), hiding the portion in front of the cut. Moving
the slider moves the cut plane from 0% (behind the molecule) to
100% (in front of the molecule). Thus, by having a Cut Slider in
a chapter, you need not cut a molecular view(s) in order for the
user to see the cross section. You may simply instruct the user
to check Cut
(or Slab
) and use the slider. Such
instructions are probably best given in the description of the
view. (When Cut
is unchecked by checking Zoom
, the
front portion of the molecule is automatically restored.)
Strictly speaking,
Slab
means that both the front and rear portions of the molecule
have been "cut away" and hidden, leaving a slab.
The term Slab
is often mis-used when only one cut is made, and only the
portion in front of the cut is hidden. A better term for this is
Cut
, which is the default label for the slider. If you prefer
the label
Slab
for this slider, change the variable slabSliderLabel
from Cut
to Slab
.
Create Additional Chapters. To add another chapter, copy the folder jtat/template/chapter01 (with all the files it contains) into jtat/tutorial_name. Rename the new folder, e.g. chapter02. The files in chapter02 should NOT be renamed. Proceed to add molecular views, descriptions, and details as you did for chapter01.
Finishing up Chapters: Next, Previous, Contents buttons. Each chapter.js file contains navigation variables that specify the targets of the Next, Previous, and Contents buttons. Make sure these are correct as part of finishing up your tutorial chapters.
Next, provide the following specifics for the window title, and the footer material that can be viewed at the bottom of the Contents as well as every chapter.
If you set noSpinning to true (see Convenience Settings While Authoring), be sure to restore it to false before deploying your tutorial!
Provide an Introduction? Optionally, you may provide an introduction to your tutorial that users will see before they enter the Contents page that shows Jmol. A skeleton for such an introduction is provided in the file jtat/template/intro.htm. If you use this file, you may rename it to index.htm (a conventional starting place), or else you will need to change the link in jtat/index.htm to go to intro.htm.
Project your Tutorial from your private copy. When your tutorial is completed, you can project it from a computer (or stick/thumb memory) to illustrate lectures, without putting it on the web. We hope you will also put your tutorial on the web so your students as well as other educators and students can benefit from it.
Note: All of your tutorial is in the jtat folder. To copy it to another device, simply copy jtat and all the files and folders that it contains. To view the copy, please review Viewing Your Tutorial.
Put Your Tutorial Online! Putting your tutorial on the web requires that you have an account on a web server (http server). If you are at an educational institution or corporation, typically the information technology department of your institution will provide the server account and help in using it.
If you would like an independent, free web server, we recommend that
you apply to bioinformatics.org for what they call a project
.
First, you'll need to create a login account for yourself: click on the
"Log In" link near the upper left, and on the login page is a link for
New account. After you have logged in, at the upper left of the main
page, you'll see Logged in: yourname. Below that is a link
Register new group/project.
Once approved, your project includes a place where you can put your jtat
folder and all its tutorials. If you would like help setting up your tutorial
on bioinformatics.org, feel free to contact me (emartz@microbio.umass.edu).
If you have more than one tutorial in one jtat folder, you can provide a list of them, with links to each, in the file jtat/index.htm. By default, this file redirects to the main page for JTAT. To use it for your tutorials, copy the file jtat/index2tutorials.htm to jtat/index.htm. Then edit the new index.htm to make the links to your tutorials.
What is a "script"? The term "script" is short for "command script", which is a series of commands to Jmol that specify how to render a molecular view. Typically these commands are stored in a plain text "script" file, with a filename ending ".spt".
Optional: If you want to examine some script files now, look at the files ending in ".spt" in the jtat/jtatdemo/ch_* directories. Note, however, that these were all created by direct scripting rather than being state scripts generated by Jmol.
There are several ways to generate these molecular view scripts.
state scripts. Proteopedia.Org's Scene Authoring Tool is the easiest way to create scripts for JTAT. In brief, you get the molecular view you want by any combination of these three methods:
state script) that precisely describes the current view. You simply copy and paste this state script into a .spt file in JTAT. Detailed instructions are below.
Scripting in Proteopedia is recommended because it is easiest and can produce a wide range of molecular views that will meet most needs. Some advanced molecular views (such as translucency, cavity surfaces, or crystal symmetry operations) will not be available in the dialogs of Proteopedia's Scene Authoring Tool -- in these cases you could enter script commands into Jmol's Console within Proteopedia.
Before using Proteopedia to make molecular view scripts for JTAT, you should first have tried creating a tutorial directly in a Proteopedia wiki page. Molecular scenes in such a page can easily be moved later into script files for JTAT following the instructions below. You don't need to use the procedure below unless Proteopedia seems too limiting, and you want to try using JTAT instead.
A. Making JTAT scripts in Proteopedia:
Scenes for [topic of your tutorial] in JTAT. (see Help:Protected Pages).
Jmolat the lower right corner below the molecule. Changing the scene with the menu can be somewhat technical. Jmol's menu has no help, so you will have to experiment. Most things on the menu can be done more easily in the dialogs of Proteopedia's Scene Authoring Tool. Unless you just like the menu better for a particular purpose, a good reason to use Jmol's menu would be if you find something there that can't be done in the Scene Authoring Tool.
set percentVdwAtom 20; set smartAromatic true; #load /*file*/"http://proteopedia.org/cgi-bin/getpdbz?1eve"; end function; function _setVariableState();
.spt.
B. Editing JTAT scripts in Proteopedia:
Suppose that you already have a molecular view in JTAT that you scripted in Proteopedia, but you want to make changes. If it will be easier to modify the existing scene than to re-create the desired scene from the beginning, here is how.
Jmolfrank to open Jmol's menu, then click Console.
You can also put molecular views obtained in FirstGlance in Jmol into JTAT script files. To do this, it is crucial that you start FirstGlance from within Proteopedia, using the link to FirstGlance beneath each Jmol display (on pages titled with a PDB identification code). These links within Proteopedia start the beta version of FirstGlance, which should be using a version of Jmol that is matched to the Jmol version used in Proteopedia and JTAT. Mismatches between the version of Jmol used to generate the state script, and the version asked to run it, may cause the molecular view to fail to appear, or to be incorrect. (For more on this, see Troubleshooting Scripts.)
Certain views that are obtained very easily in FirstGlance are very difficult to obtain in Proteopedia. These include any view generated with the Contacts.. dialog, as well as (under More Views..) the display of all salt bridges or all cation-pi orbital interactions.
As in Proteopedia, scenes obtained in FirstGlance can be modified by direct command entry into Jmol's Console before you transfer the state script. It would also be possible to transfer a FirstGlance state script into Proteopedia (by transfering it into the console and executing it), and then modify it with Proteopedia's Scene Authoring Tool. Then you could transfer the final scene from Proteopedia to a .spt file for JTAT.
Once you have obtained the desired molecular view in FirstGlance, display and transfer the state script into a .spt file, following the instructions above.
Direct scripting will be unnecessary for most JTAT tutorials. Therefore, most authors of JTAT tutorials will not need to learn direct scripting.
Learning how to make molecular view scripts is the most technical option for authoring tutorials with JTAT. If you have some knowledge of the command languages for RasMol or Chime, Jmol scripting will be very similar for basic operations. However, Jmol has many capabilities not present in RasMol or Chime.
Select atoms, then display and color them. In Jmol, as in Chime and RasMol, you select a subset of the atoms first, and then apply a display style and/or color or color scheme to them (or hide them). Next, you can select a different subset of atoms, and so forth, until the desired molecular view is complete.
Jmol's menu can be used for selection, display and coloring in either the application or the applet. Jmol's menu is cumbersome for more than a few operations, and lacks help, but may be used if you wish.
Script Command Reference Manual. The commands understood by Jmol are listed and explained in a master Jmol Command Reference Manual. Here you will find detailed descriptions of each command, often together with examples demonstrating their uses. Because Jmol is under rapid development, the documentation sometimes lags behind current Jmol behavior. If, after consulting the documentation, questions remain, don't hesitate to ask for help at the Jmol-users email list.
Jmol's command language is a superset of the language used by the MDL Chime browser plugin, which was popular from its inception in 1996 until Jmol became macromolecule-capable, around 2004 (see the Chime-based tutorials, being phased out, at molviz.org, and many more at molvisindex.org). In turn, Chime's command language is a superset of the language invented by Roger A. Sayle for RasMol, a very popular stand-alone molecular visualization application that became available in 1993. Thus, the Jmol language is easier to learn for those already familiar with the Chime or RasMol languages.
Jmol is preferable to RasMol because RasMol does not work in a web browser, and has no support for tutorials. Chime has not been developed for a decade, is not open source, and is difficult to get to work by today's standards (see About Chime).
Help: the Jmol-users email list. This is a very active email discussion of Jmol use. Not infrequently over a dozen messages are broadcast in a single day. This is the place to ask for help, to report bugs, and to make suggestions for enhancements. Suggestions for enhancements may also be entered as Feature Requests. At http://jmol.org, click on the Projects link near the upper right. There you will see the links for Feature Requests, and for the jmol-users mailing list. It is best to subscribe before you ask for help, so you can see the replies. If you don't want to keep receiving all the broadcasts, you can always unsubscribe, possibly resubscribing again later if you have more questions.
Sooner or later, you will save a Jmol command script file (such as view01.spt), but when you click the corresponding View # button, you do not get the desired view (or you get no view at all). Troubleshooting Jmol scripts is straightforward. Here is how.
Make sure you don't have a javascript error. Before working on the .spt file, make sure there are no javascript errors by checking the javascript error console, as described under troubleshooting in Editing Javascript Files: Finding and Fixing Problems.
Confirm which .spt file is the culprit: Show History. It is frustrating to spend time inadvertantly trying to debug the wrong .spt file, so first, make sure you know which one has the problem.
Reload the chapter (click on the browser's reload/refresh button) so only the initial view has been displayed. Next, click the button for the view in question. (Don't click other views first, as they will add confusion.) Open Jmol's menu:
To Open Jmol's Menu: Click on the gray word Jmolto the lower right of the molecule, in the lower right corner of the Jmol applet rectangle. Jmol's menu should open on the first click. Occasionally, it doesn't. In that case, try reloading the page, or even quitting/exiting the browser and starting a new browser session. If the menu that opens is short, with Main Menuas the first item, click on Main Menuto open the complete menu. |
In Jmol's menu, click Show, History. The Jmol Console window will open, and the commands that have been sent to Jmol will be listed.
The command history shows all commands sent to Jmol since the applet was first loaded in the chapter. The initial view script block will be between these comments:
Within this block will typically be the command "script initial-view.spt", since that is the default script file used for the first view in a chapter. Before and after this line will be other commands that JTAT automatically adds to the .spt file itself.
Following the initial-view script will be the script for the view button you pressed. For example, if you pressed "View 5", it will be between these comments:
Between these comments will be the script command that calls the script for the view in question. Typically, for View 5, this would be script view05.spt. This is the script file name you are looking for to confirm which script file needs debugging.
Note that the commands within a script file (*.spt) are not shown in the history. For example, the file "initial-view.spt" typically includes the command "script view01.spt", but this will not be listed in the history. There are two ways to see all of the commands received by Jmol. One is to open the .spt file(s) in a text editor. The other is to use "set debugscript on" (see next section below).
Make sure your Jmol versions are matched. If the malfunctioning .spt file in question is a state script saved from Proteopedia or FirstGlance in Jmol, check the versions of the Jmol applet in the application that generated the state script, and in your copy of JTAT. Open Jmol's menu in each application, and touch About Jmol. The submenu that opens begins with Jmol's version. The state script should work if the versions are the same, or nearly the same. If they are not, you can change the version of the Jmol applet used by your local (downloaded) copy of JTAT to be closer to the one in use by Proteopedia (or FirstGlance in Jmol).
Before you change the Jmol version in JTAT, we recommend that you try finding the first invalid command, as explained below. If the Jmol versions are different, bear in mind that the command may be invalid because of the difference in Jmol versions.
If you decide to change the Jmol version in JTAT, here is how:
Find the Jmol command that isn't working. Jmol command scripts typically fail because a single command is syntactically invalid (cannot be understood by Jmol). When one command is invalid, Jmol typically stops executing the entire remainder of the commands in the script, often displaying no molecule at all.
Invalid commands are reported in the Jmol Console (available from the Jmol Menu) as "script ERROR:" followed by details.
Invalid commands are also reported in the Java Console. On rare occasions, you may find the error there more easily than in the Jmol Console. To open the Java Console:
About Java Technology. Click on
Open Console.
Show Console, and click OK.
Java Preferences.app, found in Applications, Utilities, Java. In the
Java Preferencesdialog, under the Advanced tab, under Java console, check
Show console. Close Java Preferences. Alternatively, you can check
Hide Console. This opens the console but keeps it minimized at the lower right of your dock. If you click on the Java Console item there, it will open.
If the molecule shows but the view is not what you expected, it is very helpful to be able to see the actual commands Jmol executed, in order. To do this, open Jmol's Console from the Jmol Menu. In the Console's lower box (command input box), type "set debugscript on" and press Enter. Make sure that you typed it correctly by noting whether any error is reported in the top box (output box). Also you can find out whether debugscript is on or off (true or false) by entering the command "show debugscript".
With debugscript on, click the "Clear Output" button in the Jmol Console. Now, click a view button in your tutorial. The output box of Jmol's Console will list every command executed, in order, including commands within script files (*.spt).
If your tutorial has multiple-molecule views, you first need to display a view with the number of molecules that are in the view you wish to debug. Then open the console for one of the Jmols (or for as many as you wish -- multiple Jmol consoles can be open at once), set debugscript on, and proceed as above. If the number of Jmols (molecules) changes when you click the problematic view button, then new Jmol(s) will be loaded, and these will not have debugscript turned on.
Opening Jmol's Console Automatically. The above scheme shows all commands and all errors. Often, however, you will be primarily interested in debugging commands in a particular script file. This can also be done by inserting two commands into the script file, at the top, one to open the console, and one to turn on debugging:
This method does not report commands that are automatically inserted by JTAT before and after your script file. However, if you now click "Clear Output" and press the problematic view button again, the console is already open and debugging is already on, so on this second pass, you will see all commands.
After you have debugged the script file, and the desired molecular view is being achieved, you can either delete the above two commands, or comment them out by prefixing them with the pound sign (#), as follows:
Help! If you have a frustrating problem that you haven't managed to debug, please contact the jmol-users email list (see last paragraph at Direct Scripting) or me (emartz@microbio.umass.edu).
The DRuMS Standard Color Schemes. Careful selection of colors can help your structural views to communicate effectively, and enhance their attractiveness. Unless there are compelling reasons to do otherwise, we recommend that you use the DRuMS Standard Color Schemes illustrated in the JTAT Demonstration Tutorial and below. These build upon colors used for elements in physical models, and upon the color schemes for secondary structure in RasMol, Chime, and Jmol, and extend them to nucleotides and chemical composition. The colors are designed to be distinguishable when any or all schemes are combined, to the extent feasible. In addition to JTAT, DRuMS is used in Protein Explorer, FirstGlance in Jmol, and Biochemistry in 3D, the latter being tutorials designed to complement Lehninger Principles of Biochemistry, and elsewhere.
Jmol vs. DRuMS. The original DRuMS Color Schemes were proposed in 2000. Later, when Jmol was enhanced for macromolecules, its default colors for some elements (those less common in macromolecules) were changed, after careful consideration. Hence, while the colors for C, H, O, N, P, and S are similar in Jmol and DRuMS, Jmol's colors for other elements are different. JTAT's built in support for color schemes follows Jmol's default colors.
JTAT vs. DRuMS. JTAT (first released in 2008) extends the 2000-vintage DRuMS color schemes in a few places with additional or modified colors. These extensions follow, for the most part, similar extensions that were made in Protein Explorer (first available in 1998) and FirstGlance in Jmol (first available in 2005).
JTAT's Support for Color Schemes. Proteopedia's Scene Authoring Tool and JTAT both support DRuMS color schemes. JTAT provides script files that apply DRuMS color schemes to selected atoms, style sheets for applying DRuMS colors to HTML text, a copy-and-paste Text Coloring Quick Reference, and javascript functions to generate color key text for the standard color schemes. Below are explanations of how to use all of these.
The word DRuMS
represents the people who created it:
Tim Driscoll,
Frieda Reichsman,
Eric Martz,
and Roger Sayle. Sayle is the creator of RasMol and its color schemes.
JTAT makes it easy to apply standard (DRuMS) color schemes to your molecules by several methods.
Proteopedia. If you are using Proteopedia to generate your view scripts, it provides several DRuMS color schemes at the touch of a button. In Proteopedia's Scene Authoring Tool, in the colors tab, the following are DRuMS color schemes:
With the exceptions of amino and amino 2, the other color schemes in Proteopedia's Scene Authoring Tool are also quite commonly used, although not formally part of DRuMS.
Direct Scripting. If you are writing your own scripts by hand, you may use Jmol's built-in DRuMS color schemes for element or secondary structure, or ready-made DRuMS coloring scripts provided with JTAT. Assuming the script file calling these coloring scripts is in a contents or chapter folder, these can be called as follows in .spt files:
There are four ways to make color keys in the text of your molecular view descriptions.
Carboninstead of showing only the "C" displayed by element_key("c"), you can use <span class="c">Carbon</span>. More..
Below are explained how to use each of these, and all the standard color keys are shown.
A. JTAT's functions for standard color keys are javascript functions, each of which returns a colored text key. For example, the function composition_key() returns the HTML to display this:
First, we'll explain how to use these functions. Then we'll list all the color key functions provided by JTAT.
How to use JTAT's color key functions. All the *_key() functions have one optional parameter, which is the final punctuation. Typically, this is ", " (comma space) when followed by another color key, "." (period) when the end of a sentence, or ":" (colon) when preceding a statement. For example, composition_key(".") returns this:
When authoring a JTAT tutorial, text, such as a molecular view description, is written into a javascript
file (either chapter.js or contents.js). It is written as a character string
variable (see
javascript above). In order to combine a javascript
color key function with such a string, it must be added
(concatenated)
onto the string. So, the string must be ended with a closing quote, followed
by a +
, followed by the function.
If more
quoted text is to follow the color key, again, it must be added with a +
after the function.
For example:
// MOLECULAR VIEW DESCRIPTION buttons[buttonNumber][iButtonText] = "The composition of this molecule is: " + composition_key(".") + " (This is a DRuMS standard color scheme.)";
which will display in the tutorial like this:
Multiple color key functions can be added together. For example, if the molecule has only protein, ligand, and solvent, the color key can be generated as follows:
// MOLECULAR VIEW DESCRIPTION buttons[buttonNumber][iButtonText] = "This molecule consists of " + protein_key(", ") + dna_key(", ") + solvent_key(".");
which will display like this:
The default font for color keys is intentionally large and bold in order to be easily visible in Windows browsers, where the weight of the normal sans serif font is low (compared to its weight in Mac browsers, where it is more readable). If you want to experiment with changing the color key font, uncomment and modify the variables colorKeyPrefix and colorKeySuffix in jtat/tutorial_name/js4all/tutorial.js. (The primary definitions are in jtat/_jsutil/keys.js.)
Complete list of JTAT's color key functions for standard color schemes.
B. Color key text with HTML
style class spans.
Every standard JTAT/DRuMS color has a syle sheet class name. For example,
in the Composition color scheme, solvent
is the name of
a color. The JTAT color key function solvent_key()
returns:
However, if the only solvent in the molecule at hand is water, you might
prefer to apply the solvent
color to the word Water
. This
can be accomplished using
which displays like this:
Note that when combining two style classes, they must be separated by
a space, without a comma.
Note also that combining the color class solvent
with the font
class keyfont
(as above) produces the standard color key font. If you want
the font to be the same size and style as the surrounding text, omit keyfont
, like
this:
which displays as follows:
(Color key text is always bold weight. This is included in the color key style classes.)
The complete list of color key style classes is in the
where it is easy to copy and paste the complete span tag for each color you need.
C. Color key text in non-standard colors and the standard color key font: the ckey() function. When you want to color text with a non-standard color, and you want the text to be in the standard color key font, use the ckey() function. It takes three parameters:
For an example, in the JTAT Demonstration Tutorial, in the chapter on Animations and Movies, View 1 uses non-standard colors for DNA and sulfur. This was done in order to distinguish the two strands of DNA clearly, and to distinguish the disulfide bond (normally colored the same as sulfur) from beta strands. The color key is:
The above was produced with this javascript:
ckey("ff9090", "DNA", "/") + ckey("a0a0ff", "DNA", ", ") + ss_key(", ") + ckey("ff8000", "Disulfide bond", ".")
D. Color key text in non-standard colors and the default font: the HTML font tag. When you want to color text with a non-standard color, and you want the text to be in same font as the surrounding non-colored text, specify the color with an HTML font tag. The color can be either an RGB code or a color name. These can be gotten from the Jmol Colors page. Enclosing the colored text in boldface tags <b>...</b> makes the colors easier to see.
displays as follows:
Font color tags are used, for example, in the JTAT Demonstration Tutorial, in the chapter on Spin Control.
Disabling Automatic Spinning. When you are constantly reloading a page (and not testing the automatic spinning controls), you may not want to have the molecule start spinning on every test. Spinning is a siginficant load on your computer, and may, for example, cause the speed of the CPU fan, or the CPU temperature, to increase. Set noSpinning to true in jtat/_jsutil/config2.js and you won't be bothered. But please remember to set it back to false before putting your tutorial on the web!
Below are described methods to change some of the default behaviors of JTAT. These are all optional, and only advanced users need be concerned with this section.
Default Text Font and Weight
The default font face for text in tutorials is Verdana (sans-serif), with
a default size of 1em. These can be changed for a particular tutorial
in jtat/tutorial_name/js4all/tutorial.js in the section
Control Panel Text Style
. They can be changed for all tutorials
in the setTextFont*() functions in jtat/_jsutil/config.js
The default font weight for Apple Mac OS X and Linux is "normal". For Windows, bold was chosen as the default for all control panel text because the normal fonts in Windows Firefox and Internet Explorer are rather thin and hard to see, especially for projection. This means that explicit bold weight text in Windows is no different than the rest of the text. The default weight can be changed as in the previous paragraph.
Style of Chapter Links in Contents are set with the style class="contents", which is defined in jtat/_cssutil/jtat.css. This style could be changed for one tutorial by re-defining the .contents classes in jtat/tutorial_name/css4all/tutorial.css, or for all tutorials by editing the definitions in jtat/_cssutil/jtat.css.
Color Key Text Style is specified by colorKeyPrefix and colorKeySuffix in jtat/_jsutil/keys.js. If you want to change it for all tutorials, change it there. If you want to change it for one tutorial, change these variables in jtat/tutorial_name/js4all/tutorial.js.
Replay/Reset Initial View Buttons are, by default, present at both the bottom and top of the control panel for each chapter. If there is no difference between initial-view.spt and view01.spt, you do not need any Replay/Reset buttons: set provideResetButton to false in chapter.js. If you want a Replay/Reset button at the bottom, but not at the top, set showResetInitialViewButtonAtTop to false in chapter.js. If you want this for all chapters in one tutorial, set it to false in jtat/tutorial_name/js4all/tutorial.js.
Optional Credits or Acknowledgements, to be displayed at the bottom of every chapter in a tutorial, can be specified in tutorialCredits in jtat/tutorial_name/js4all/license.js. The required credits, copyright year, etc. are also specified there.
A custom license for your tutorial, to be displayed at the bottom of every chapter, can be specified in alternativeLicenseAndCredits in jtat/tutorial_name/js4all/license.js. If this variable is not blank, it will replace the default Creative Commons Attribution - Noncommercial - Share Alike 3.0 License displayed in all JTAT tutorials. That is defined in jtat/_jsutil/licenses.js. Please don't change it, but a mechanism is provided there to add another standard license, and specify it. See also the previous paragraph here.
The core of a JTAT tutorial is the series of molecular view buttons, each of which displays a different molecular view. For the most part, this mechanism is satisfactory. In some cases, however, it is useful to make minor changes to a molecular view without having an entire new view button. One way to make such small changes is with checkboxes. An example is the first view in the chapter Color Schemes: DRuMS in the JTAT Demonstration Tutorial. In this instance, each checkbox shows or hides a component of the molecule.
Jmol.js, which comes with Jmol, includes functions to create
checkboxes, pull-down menus, radio buttons, and links (which
we'll call collectively controls
) that send command
scripts to Jmol. These functions cannot be used to write these
form elements directly into a JTAT chapter.js file for for technical
reasons. Instead, after a chapter page has loaded and Jmol has
been initialized, the HTML for the controls is created and
inserted into a pre-existing division. If you wish to try using
any of these controls, you should examine the implementation in
jtat/jtatdemo/ch_drums while following these two steps.
The same strategy should also work for pull-down menus and radio buttons, but I have not tested it. Also I have not attempted to design checkboxes for multiple-Jmol views, but it should be straightforward. Don't hesitate to ask for help: emartz@microbio.umass.edu.
Animations vs. Movies. We'll use "animation" to mean an animation that plays in Jmol, and "movie" to mean a true movie -- a series of still photos played in sequence. If you haven't already done so, please review the chapter on Animations and Movies in the JTAT Demonstration Tutorial. The key difference is that an animation in Jmol can be viewed from any perspective (by rotating it with the mouse), while animating. A movie has only one perspective (or a limited, pre-determined set). Also, the color scheme and rendering can be changed easily in Jmol to show different aspects of the animation, while a separate movie is typically required for each such change. Finally, animations in Jmol typically require transfer of less than one tenth of the amount of data through the Internet than does a movie.
Therefore, animations in Jmol are a powerful and
efficient way to show molecular conformational changes at atomic level
resolution. How to make and use them in JTAT is discussed in the
next section.
Generating a molecular movie showing a molecular conformational change
usually involves first making a multiple-model interpolated or morphed
atomic coordinate (PDB) file. Once you have such
a file, for display in a JTAT tutorial, there are many advantages to
animating it in Jmol, rather than using it to make a true movie.
When Are True Movies Best? In a JTAT tutorial, there are two good reasons for including a true movie. The first is when the movie is already available (along with permission to use it!), thereby saving you the time needed to create your own animation. The second is when the movie shows something that would be difficult or impossible to represent in Jmol, such as cartoons of higher level structures. Examples of atomic-level movies that would be difficult to animate in Jmol (due to the kinds of atomic models that would be required) are some showing DNA recombinations moving through Holliday junctions.
On the other hand, in a Powerpoint presentation, movies are great because incorporating Jmol is either impossible (Macs) or technically tricky (Windows). (To create movies for Powerpoint, see Top5.MolviZ.Org.)
Typically, an animation of a conformational change starts with two empirical PDB files representing two conformations. Unless the change is very small (slight shifts of a few sidechains), intermediate models will need to be interpolated in order to see and understand the structural changes. This is called molecular morphing. The main purpose of such morphing is not to predict the actual trajectory of the change, but to allow one to follow it with the eye. (For examples, beyond the JTAT Demo Tutorial, here are morphs and movies that I made using RasMol and Chime in the pre-Jmol era.)
The resulting multiple-model PDB file can then be animated in Jmol with a few simple commands, such as:
anim mode palindrome; anim on; anim fps 8;
These commands can be seen in action in the chapter on Animations and Movies in the JTAT Demonstration Tutorial, for example, in jtat/jtatdemo/ch_anim/view01.spt.
Protein Explorer has an NMR Models and Animation control panel which is quite powerful for viewing animations of multiple-model PDB files. But it works only on Windows in Firefox, and requires that you install the free plugin MDL Chime. For more details, go to ProteinExplorer.Org.
Creating a Morph PDB File. The easiest way to morph between two empirical PDB files is by submitting them to the Yale Morph Server. This server first does a linear interpolation (see below), and then a little energy minimization on each step, producing a "chemically possible" trajectory. Yale will generally produce a satisfactory result unless you want to show ligand(s) in the animation. It can handle multiple chains including both protein and nucleic acid chains, and it can handle the situation when the empirical models have somewhat different sequences. Don't hesitate to ask the Yale team for help if at first you don't succeed -- they have been quite helpful to me.
Ligands in a Morph. Although the Yale Morph Server will strip any ligand out of submitted PDB files, you can put a ligand back into the morph it produces -- provided you only want the ligand in the starting or ending model. This is what is typically needed when the ligand induces the conformational change. The ligand ATOM lines of the PDB file can simply be copied into the appropriate (first or last) model in the morph PDB file. However, it may need to be realigned first. This can be done with the free program DeepView. If you need help, please contact me directly (emartz AT microbio DOT umass DOT edu -- I enjoy making morphs) or contact the molvis-list.
Linear Interpolation Morphing. If the Yale Morph Server does not produce the result you seek, you can perform a simple linear interpolation using free software that I wrote. Its big limitation is that the starting PDB files (first and last frames of the animation) have to have exactly the same atoms in the same order. In a linear interpolation, each atom moves in a straight line between its initial and final positions. This causes bond lengths and angles to violate normal values, and may even cause atoms to pass through each other. The result is a "chemically impossible" trajectory. However, obvious violations of chemistry serve to remind the viewer of the usual purpose of a morph (see above). Again, feel free to contact me for help or a collaboration on morph construction (emartz AT microbio DOT umass DOT edu).
Movie Formats vs. Browser Compatibility If you are going to use a movie in JTAT, you should be aware of the following issues concerning the data formats of movie files.
Making a Molecular Movie. The Polyview-3D server is the easiest place to create publication-quality movies of macromolecules. It produces multi-gif (.gif) movies that work in all popular browsers without installing any special plugins. If you want a really simple movie, such as a molecule rotating about its vertical axis, or rocking back and forth, all you need is a PDB code or PDB file.
If you want to animate a conformational change, you'll need a multiple-model "morph" PDB file. For information on creating these, please see Animations.
If Polyview-3D does not lend itself to the rendering you want in your movie, you can make an mpeg with the Jmol application. This will involve direct scripting. The Jmol application can write jpeg files, so you can write an animating script loop that writes a jpeg file for each step in the animation. You can then assemble these .jpeg files into an mpeg movie. We are told that this can be done with the free program GIMP, but we have no experience with this. For help, please ask on the jmol-users email list.
How do you put a movie in JTAT? Small movies can be placed directly in the control panel of a JTAT Tutorial, as illustrated in the chapter on Animations and Movies in the JTAT Demonstration Tutorial. Also illustrated there is the use of a link in the control panel to open a new browser tab or window to show a large movie. If you want to use a movie in your tutorial, please take a look at the code in jtat/jtatdemo/ch_anim/chapter.js, for a small movie in the control panel (look for lacrep_anim_small.gif), or jtat/jtatdemo/ch_anim/lacrepan.htm, for a large movie in a separate window.