Getting Started

[ Program Manual | User's Guide | Data Files | Databases ]

Table of Contents

Overview

Fundamentals: Using UNIX

Getting Help for UNIX

Logging On

Working with Directories

Displaying Directory Contents

Creating Directories

Changing Directories

Defining and Using Logical Names for Directories

Working with Files

Creating and Editing Files

Specifying Files

Deleting Files

Displaying and Changing File Protections

Using Wildcards

Viewing Files

Using Command-Line Redirection

Controlling Program Execution

Running Jobs in the Background

Displaying Background Jobs

Moving a Job to the Foreground

Terminating a Background Job

Logging Off

Quick Reference

UNIX Commands

Controlling Screen Output

Getting Started with the Wisconsin Package

Initializing the Package

For Advanced Users

Customizing Your Login

Initializing the Wisconsin Package

Automating Program Commands

Defining Logical Names

Defining Your Graphics Configuration

Overview

[ Top | Next ]

This chapter helps prepare you to use the Wisconsin Package. Written with the novice user in mind, it provides you with the fundamentals of working with the UNIX operating system. While the commands and procedures in later chapters and in the Program Manual often assume that you have a working knowledge of UNIX commands, this chapter assumes you have little or no experience working with the computer, and it provides you with that basic groundwork.

You can find the details on working with files and directories, logging on and off the system, and customizing your login environment in this chapter. It also explains how to start running the Package.

The Wisconsin Package you use is installed on a minicomputer using a UNIX operating system. You are connecting to that computer in one of two ways: 1) you are directly connected to the computer, or 2) you connect to the computer over the network. The device you are using could be a dumb terminal, a console, an X Windows terminal, or a PC or Macintosh running terminal emulation software. Regardless of what device you are using to access the Package, you must become familiar with UNIX commands to use the Wisconsin Package programs and manipulate the output.

Fundamentals: Using UNIX

[ Previous | Top | Next ]

Note: If you are more familiar with OpenVMS commands than UNIX commands, see Appendix D, Command and Keystroke Differences between OpenVMS and UNIX.

Your system manager has just set up a UNIX account for you to use the Wisconsin Package. But what if you've never used UNIX before and you're not sure where to start? This chapter will walk you through the basics of using the UNIX operating system. If you take a little time now to learn the basics of UNIX, you will increase the efficiency with which you can later work with the Wisconsin Package.

This section teaches you how to

• Get help for UNIX.

• Log on.

• Work with directories.

• Work with files.

• Customize your login.

• Use command-line redirection.

• Control program execution.

• Log off.

UNIX Shells

The Wisconsin Package supports two shells in UNIX: C shell and Korn shell. Commands vary slightly between UNIX shells, so you must know which shell you are using to get the results you want. How do you know which shell you are using? Ask the computer by typing % echo $SHELL. (Note that UNIX commands are case sensitive.) The system displays the shell you are using. Where commands differ between the two shells, this manual gives the commands for both.

UNIX Command-Line Conventions

Keep the following points in mind as you work with the commands and tasks in this chapter and manual.

• UNIX commands are case sensitive. That is, uppercase commands are distinguished from lowercase commands which are distinguished from mixed case commands. Type carefully!

• Some UNIX commands require input files. For example, rm (remove) requires the name of the file to be deleted.

• UNIX commands support parameters, also known as command-line switches, which modify the action of the command. You precede parameters with a space and a dash (-), and you can use multiple parameters to modify a command. For example, consider the command % ls -l -a. The -l parameter modifies the command ls (list) to display each file in your directory with its file protection (read, write, execute) information. The -a parameter modifies the command to list all files in your directory, including those that begin with a period.

Directories and Files

You use UNIX commands to manipulate files and directories. Think of a directory as being similar to a file cabinet. Within the file cabinet you can find drawers (subdirectories) and files. Subdirectories, like file cabinet drawers, help you organize your files into loosely related groups. Files are where you store information in the computer--for example, sequence information or the output of a program. Most Wisconsin Package programs require a file as input and produce an output file of results.

Directory and File Protection

Each directory and file in the UNIX system is under file protection. This protects you and others from writing in directories or reading or executing files for which you do not have the privilege. For example, you can set a file's protection so that only you can read it.

Text Editors

In your work with the UNIX files, there are times when you must use a text editor to complete a task. The default text editor in UNIX is vi. However, you can use other text editors, if available.

It is beyond the scope of this manual to provide detailed instructions in the use of text editors. However, we do provide the basics to get started using vi in Appendix B, Text Editor Basics. For more information about the default text editor vi, see the documentation for your UNIX system. For other text editors, see the appropriate program documentation.

Getting Help for UNIX

[ Previous | Top | Next ]

- To access online help for UNIX commands:

Type % man command_name. For example, % man ls displays online help for the UNIX command ls (list).

The UNIX commands are also described in detail in your UNIX operating system manuals. For more information, see your system manager.

Logging On

[ Previous | Top | Next ]

To use the Wisconsin Package, you will be in one of two possible situations: 1) you are directly connected to the computer, or 2) you connect to the computer over the network. The device you are using could be a dumb terminal, a console, an X Windows terminal, or a PC or Macintosh running terminal emulation software.

- To log on to a UNIX machine:

Note: You must have an approved account, also called a login, from the system manager to use any UNIX computer. The system manager usually sets up a user name, which is typically your first or last name, and lets you specify a password for security. No one can access the system through your account without your password. Keep your password secret.

1. - - Because each site is different, ask your system manager for instructions on how to connect to the UNIX computer.

   When you are connected, you should see the prompt "Login:" on the screen. If you don't, press <Return> until you do.

2. - - Type your user name and press <Return>. The system displays the prompt "Password:".

   Note: Your user name and password are case sensitive; that is, the computer distinguishes uppercase letters from lowercase letters. Therefore, type your login name and password exactly as they are set up in the system.

3. - - Type your password and press <Return>. For security, you will not see your password appear on the screen as you type. The system welcomes you and logs you in.

   Note: If you make a mistake in typing your user name or password, press <Delete> to delete the error or press <Return> and try again.

   When you see the operating system prompt (%) in the left margin of your screen, the computer is ready for your commands. Note that the % prompt is a convention used in this guide. Your site may have set up a different prompt.

Working with Directories

[ Previous | Top | Next ]

You can think of a directory as being similar to a file cabinet. Within the file cabinet you can find drawers (or subdirectories) and files. Subdirectories, like file cabinet drawers, help you organize your files into loosely related groups.

When you log in, you will be in your top directory, also known as your home directory. Your current (or working) directory refers to whatever directory you are presently working in.

For more information on working with directories and UNIX commands, see the documentation for your UNIX operating system or your system manager.

Displaying Directory Contents

[ Previous | Top | Next ]

- To display the contents (that is, the files and subdirectories) of your current directory:

Type % ls (list).

- To display what directory you are currently working in:

Type % pwd (print working directory).

Creating Directories

[ Previous | Top | Next ]

Your system manager probably provided you with one directory in which to maintain your files--your home directory. To help organize your files, you may want to create subdirectories within your current directory.

- To create a subdirectory:

1. - - Move to the directory in which you want to create a subdirectory.

2. - - Type % mkdir subdirectory, for example % mkdir project. The subdirectory project appears in your current directory.

Changing Directories

[ Previous | Top | Next ]

You've learned how to create directories, and now you want to know how to move between them. Consider the following example of a directory tree as you read through the tasks below.

Figure 1

- To move from one directory to another:

Choose from the following.

• Use the complete file specification, also known as the absolute pathname, to move to a different directory. For example, if your current directory was Patterson, you could change directories by typing % cd /users/smith.

• To move down from your current directory, type the relative path specification, % cd subdirectory. For example, if you are in the directory /users/smith, you could type % cd project to move down one directory or % cd project/data to move down two directories.

• To move up one directory, type % cd .. The ".." always signifies the parent directory.

• To move to a parallel directory, type % cd ../directory. For example, if your current directory is /users/smith/project and you want to change to the directory /users/smith/test, you would type % cd ../test.

• To move to another user's home directory, type % cd ~username. For example, to move from the Patterson directory to the Smith directory, type % cd ~smith.

• To move to your home directory, type % cd.

GCG Navigational Commands

GCG has defined simple commands to aid you in easily changing directories. These commands are especially helpful when you have many subdirectories to work with. Choose from the following.

Note: The following commands are provided by GCG and are only available when the Wisconsin Package has been initialized (see "Getting Started with the Wisconsin Package" in this chapter for more information). They are not standard UNIX commands.

• To move down one directory, type % down subdirectory, for example % down project.

• To move up one directory, type % up.

• To move to a parallel directory, type % over subdirectory. This command takes the place of first moving up one directory and then back down to a different directory. For example, if you are in the directory called /smith/project and you want to move to the /smith/test directory, you could type % over test.

• To move to your top (or home) directory, type % home.

• To move to a relative directory, or to a directory defined by a logical name, type % to directory or % to logical_name. For example, % to genmoredata moves you to a directory with the logical name genmoredata, where you can find alternative data files supplied by GCG.

Defining and Using Logical Names for Directories

[ Previous | Top | Next ]

If you move to a directory other than your home directory often, you can assign it a logical name. A logical name is a shorthand name you can give a filename or directory. Logical names often reduce typing and are easier to remember than full specifications. The GCG utility Name lets you create logical names within a UNIX operating system.

For example, let's say you assigned /smith/project the logical name proj. Regardless of the directory you are located in, you can move to /smith/project with the command % to proj instead of typing the entire directory specification.

Note that before you define a logical name, you first should check to make sure you will not overwrite an existing logical name. To check if a logical name is already defined. To do so, type % name logical_name.

Wisconsin Package programs use logical names to refer to various resources in the UNIX file system. These resources consist of directories, databases, system utilities, shell scripts, devices, or files. For example, the logical name genrundata is assigned to the directory containing the sequence databases and other data files. The logical names and their specifications are maintained in a table you can view by typing % name.

- To define logical names for directories:

1. - - Type % name -Set. The program displays the prompt "Set what name?"

   Note: Logical names are case insensitive; that is, they can appear in uppercase, lowercase, or mixed case. For example, the logical name GenRunData is the same as genrundata.

2. - - Type the logical name you want to set, for example, proj. The program displays the prompt "Set to what value?"

3. - - Type the directory specification of the resource for which you want to define the logical name, for example, /smith/project. Note that directory specifications are case sensitive. The program defines the new logical name in the logical names table.

Note: For more information about the Name program, see the Program Manual.

- To specify a directory logical name:

Type the logical name followed by a colon and a filename, for example proj:gamma.seq. You must use a colon (:) between a directory logical name and the filename that follows it.

If you forget what a logical name is defined as, type % name logical_name. For example
% name proj
/smith/project.

Note: Because logical names are created within the Wisconsin Package, you can use them only with Wisconsin Package programs and commands. The UNIX shell does not understand logical names.

Working with Files

[ Previous | Top | Next ]

Files are where you store information in the computer--for example, sequence information or the output of a program. Most Wisconsin Package programs require one or more files as input and produce an output file of results.

Filename Conventions

Filenames have a particular format: /directory/filename, where directory is the directory in which the file belongs; and filename is the name of the file. Directory names and filenames are case sensitive. You can use all alphanumeric characters as part of the name; however, you should avoid using characters with special meaning in UNIX, such as / \ " ' * ; - ? $ [ ] { } ~ ! < >. In addition, avoid including spaces within the name. Try to make the directory or filenames as descriptive as possible to help you remember their contents.

Unlike some other operating systems, UNIX doesn't assign file extensions to distinguish types of files. You can, however, add your own extensions to group similar types of files together. The Wisconsin Package often adds extensions to help distinguish output files.

Note that UNIX saves only the most recent version of a file. Therefore, use care in saving and naming files: if the filename already exists, the system writes the new information over the existing file without warning you. All previous information is lost.

For more information on working with files and UNIX commands, see the UNIX documentation for your system or your system manager.

Creating and Editing Files

[ Previous | Top | Next ]

Most Wisconsin Package programs create output files, some of which you can use as input to other programs. To create files in a directory, you must have privileges to write in that directory (see "Displaying and Changing File Protections" in this chapter). If you don't, change the directory protections (if possible) or move to another directory in which you do have the necessary privileges.

We recommend that you learn to use a text editor to create and edit files. Files written by most Wisconsin Package programs are easily edited using text editors.

- To create and edit files:

Use a UNIX text editor, for example vi. You can use other text editors as well. For more information about vi, see Appendix B, Text Editor Basics or refer to the documentation for your UNIX operating system. For more information about other text editors, see the appropriate program documentation.

Note: If you create and save a file under a filename that already exists in the directory, UNIX replaces the original file with the new information. That is, UNIX writes over the data in the original file without warning you.

Specifying Files

[ Previous | Top | Next ]

UNIX and Wisconsin Package commands often require one or more filename(s) to do their job. A simple example of a UNIX command is when you type % rm, the computer expects you to supply it with the name of the file to remove. As an example of a Wisconsin Package command, when you run the Map program, it asks you "MAP of what sequence?" In such instances you need to specify a filename.

- To specify a file to a program or command:

Choose one of the following.

• Files in your current directory. If the file is in your current directory, type the filename, for example gamma.seq.

• Files in other directories. If the file is in a directory other than your current directory, type the entire file specification, for example /smith/project/gamma.seq. If the file is in a subdirectory of your current directory, use the relative file specification, for example project/gamma.seq. When you are using Wisconsin Package commands, you can use logical names within the specification, for example genmoredata:tfsites.dat.

  Note: For more information about directories, see "Working with Directories" in this chapter.

Deleting Files

[ Previous | Top | Next ]

You will find it necessary to clean up your directories at times and to delete unnecessary files. You can do this with two commands: rm (remove file) and rmdir (remove directory).

- To delete files from a directory:

Choose from the following.

• rm. Type % rm filename where filename is the name of the file(s) you want to delete. For example, % rm gamma.seq deletes a file named "gamma.seq" in your current directory; % rm gam* deletes all files beginning with "gam."

• rmdir. Type % rmdir directory_name where directory_name is the name of the directory you want to delete. For example, % rmdir project deletes the "project" directory from your current directory.

Displaying and Changing File Protections

[ Previous | Top | Next ]

File protection is a means of security by which three categories of users are assigned privileges to each file: user (you), group (the group(s) you belong to, for example your lab), and other (everyone outside your group). Each category has certain privileges of access and use:

(r) read - Users can read the contents of the file or directory.

(w) write - Users can write in and edit the files or directory.

(x) execute - Users can execute the file or files in the directory or can display the contents of the directory.

- To display protections for files in your current directory:

Type % ls -l.

The system displays the name of each file followed by the protections (rwx) grouped by user, group, and other. For example

Figure 2

As you can see in this example, directories as well as files have protections assigned to them.

- To change file protections:

Type % chmod u=protections filename, where u defines the category of user (u [user], g [group], or o [other]) and protections defines the protections you want to set (r [read], w [write], or x [execute]).

Using Wildcards

[ Previous | Top | Next ]

Use wildcards to specify multiple files. An asterisk (*) wildcard serves as an ambiguous replacement for one or more characters; the * means "anything or nothing." You can also use a percent sign (%) wildcard as an ambiguous replacement for a single character. Consider the following examples:

• Bov* includes all files that begin with "Bov".

• gamma%.seq includes all files that contain "gamma" followed by a single character, for example gamma1.seq.

• % ls *.seq displays all files in your current directory with the extension ".seq".

• % cp *.* /smith/project copies every file in the current directory to the directory /smith/project.

Most UNIX commands and some Wisconsin Package programs accept wildcards in file specifications.

Note: If a command allows two file specifications on the command line, never use wildcards in the second parameter, for example % cp *.txt *.seq. Using wildcards in this manner will produce unexpected results.

Viewing Files

[ Previous | Top | Next ]

- To view the contents of files:

Choose from the following.

• cat. To display the entire contents of a file, type % cat filename, for example % cat gamma.seq.

• more. To display the contents of a file screen by screen, type % more filename, for example % more gamma.seq. Press the <Space Bar> to advance from screen to screen. Press q to exit more and return to the command line.

Using Command-Line Redirection

[ Previous | Top | Next ]

Every UNIX program or command can read or write to:

• Standard input. The stream from which a command takes its input, such as from the terminal, a file, or the previous process in the command line.

• Standard output. The stream to which a command sends its output, such as to the terminal, a file, or the next process in the command line.
  
  For example, "piping" ( | ) means redirecting the standard output of one program to the standard input of another.

• Standard error. The stream by which a command sends error messages, such as the terminal, a file, or to the next process in the command line.

The table below describes the command line characters you can use to redirect standard input, output, and error. Notice that you can combine input and output redirection characters on the command line.

Table 1 (Preformatted Version)

Controlling Program Execution

[ Previous | Top | Next ]

With UNIX, you can run several programs at once from the same terminal. UNIX allows you to do this by running programs in the foreground or background.

• Foreground jobs. A foreground job allows you direct input from the keyboard. You can have only one job running in the foreground; the terminal cannot be used for another job until the current foreground job finishes.

• Background jobs. If a job is running in the background, the system is working on it out of view, freeing your terminal for other work. You can have multiple jobs running in the background.

  The ability to put jobs in the background is very useful; it allows you to keep working at your terminal even though you are running one or more programs which take some time to complete.

  If you want to run one or more jobs in the background, keep the following points in mind:

  • You can't give background jobs input from the terminal or keyboard. Thus, if a program you are running has prompts which require your input, it will stop when it reaches the first unanswered prompt. Therefore to run such programs, you must use the necessary command-line parameters which answer those prompts and allow the program to run to completion.

    In the Wisconsin Package, you can bypass most program prompts by using parameters on the command line. For more information on using command-line parameters, see "Using Program Parameters" in Chapter 3, Running Programs.

  • If a foreground job typically sends output to the terminal screen, it also will do so when it is a background job. Therefore, to avoid output scrolling on your screen from a background job while you are working on a foreground job, redirect the output from the background job into a file.

Running Jobs in the Background

[ Previous | Top | Next ]

Although you can run only one program in the foreground, you can run multiple programs in the background.

- To run a job in the background:

Add an & (ampersand) to the end of the command line, for example % fasta ggammacod.seq -Default &.

The system puts the job in the background and displays a response similar to the following:

[1] 14999
%

The number in square brackets [ ] is your job number, in this case job number 1. If you ran a second job in the background, it would have a job number [2]. The second set of numbers is the process identification (PID) number assigned by the system. The system prompt (%) tells you the system is ready for your next command.

A job will stop running if it needs information that you must enter at the keyboard, such as a filename or other parameter. When this happens to a background job, the system displays a message similar to the following on your screen:

[1] + Stopped (tty input) fasta

To continue the job, bring it to the foreground. The job, requiring your input, continues from where it stopped. For more information, see "Moving a Job to the Foreground" in this chapter.

If you log out while running a background job, the job continues to run. When the job finishes processing, its output file appears in the directory you specified.

Note: Some programs, such as those that search the databases, are computationally intensive and take some time to execute. You can use the -Batch parameter to submit these programs to the batch queue to execute at a later time. For more information about the batch queue, see "Using the Batch Queue" in Chapter 3, Using Programs.

Displaying Background Jobs

[ Previous | Top | Next ]

- To see a list of all jobs currently running:

Type % jobs. A list of each background job you are running appears on your screen, marked as either running or stopped. A running job is executing in the background. A stopped job is one that either you or the system put on hold. For example

[1] +Running - (set noglob; $GCGUTILDIR/fasta ggammacod.seq -def)
[2] -Stopped - (set noglob; $GCGUTILDIR/mfold -save ala-trna.seq -def)

Moving a Job to the Foreground

[ Previous | Top | Next ]

Let's say you ran a program and put it in the background. But the program stopped after encountering an unanswered prompt. What do you do? You can move the program into the foreground. The program continues from where it left off in the background.

- To move a background job to the foreground:

1. - - Type % jobs to see a list of the jobs running in the background.

2. - - Type % fg %job_number, where job_number is the number appearing between square brackets [ ] in the job listing. For example, % fg %2 brings job number 2 into the foreground.

You can put a foreground job in the background again by pressing <Ctrl>z to stop the job then typing % bg (background) to put it in the background for processing. The job will continue running in the background

Terminating a Background Job

[ Previous | Top | Next ]

- To terminate a background job:

1. - - Type % jobs to see a list of the jobs running in the background.

2. - - Type % kill %job_number, where job_number is the number appearing between square brackets [ ] in the job listing. For example, % kill %2 terminates job number 2.

Logging Off

[ Previous | Top | Next ]

- To end a session with a UNIX system and log out:

Type % logout.

Note: If you are running a program in the background when you log out, and you redirected the output to a file, the program runs to completion and places the output file in the directory you specified. However, if you haven't directed your output to a file when you log out, the program is terminated before completion.

Quick Reference

[ Previous | Top | Next ]

UNIX Commands

[ Previous | Top | Next ]

You should become familiar with the following UNIX operating system commands to use the UNIX system and Wisconsin Package programs effectively and efficiently. For more information on UNIX commands, see the documentation for your UNIX operating system.

Table 2 (Preformatted Version)

Controlling Screen Output

[ Previous | Top | Next ]

The following is a partial list of key combinations you will find helpful in controlling screen output. For more information on terminal keyboard combinations, see the documentation for your UNIX operating system.

Table 3 (Preformatted Version)

Getting Started with the Wisconsin Package

[ Previous | Top | Next ]

Note: Chapters 2-5 in this guide provide general instructions for all programs in the Wisconsin Package. For detailed instructions about a specific program, see the Program Manual.

Initializing the Package

[ Previous | Top | Next ]

To use the Wisconsin Package, you must first initialize your environment. Initializing your environment gives you access to the Wisconsin Package programs, the databases, data files the programs need, logical names, and other information required for the Package to run smoothly.

- To initialize the Wisconsin Package:

Type % gcg. The system takes a few seconds to initialize the Package and displays a banner similar to the following:

Figure 3

The banner displays the version of the Package you are running, as well as the reference you can cite if you use the Wisconsin Package in your publishable research. (Because the banner changes with each update to the available databases, your banner may look slightly different than the one above.)

When you see the operating system prompt (%), the Wisconsin Package is ready for use.

Note: The % prompt is a convention used in this guide. Your site may have set up a different prompt. Also, if the command % gcg does not initialize the Wisconsin Package on your system, see your system manager.

For help working with the Wisconsin Package, check the documentation, look in the GenManual or GenHelp online help, or contact technical support. For more information, see "Getting Help" in the preface "Before You Begin."

TIP - If your primary reason for using the UNIX system is to use the Wisconsin Package, you may want to customize your login to automatically initialize it. To do so, you need to create or edit your .login or .profile file. For more information on working with login initialization files, see "Customizing Your Login" in the "For Advanced Users" section of this chapter.

For Advanced Users

[ Previous | Top | Next ]

The information in this section is intened for users who are familair with the operating system. This section teaches you how to

• Initialize the Wisconsin Package in your login.

• Automate program commands in your login.

• Define logical names in your login.

• Define your graphics configuration in your login.

Customizing Your Login

[ Previous | Top | Next ]

You or your system manager can customize your login to ensure that certain commands execute or are available every time you log in. For example, you may want to customize your login to automatically initialize the Wisconsin Package. Or, you can assign logical names for filenames and directories so that each time you log in, they will be defined automatically. To do these things and more, you can do this with two files:

Note: To determine which shell your system runs under, type % echo $SHELL.

• .login (csh) or .profile (ksh). A shell script that defines your UNIX user environment. For example, if your primary reason for using UNIX is to use the Wisconsin Package, you may want to customize your login to automatically initialize it. UNIX executes the .login or .profile file each time you log in.

• .gcgrc (csh) or .gcgrc.ksh (ksh). A shell script that defines your Wisconsin Package operating environment. For example, if you find that you frequently use a program with the same parameters, you can define an alias as a shortcut command for the program and parameters. (For more information about shell scripts, see "Working with Shell Scripts" in the "For Advanced Users" section of Chapter 3, Using Programs.)

  When you initialize the GCG environment, the last step in the initialization process is the execution of your .gcgrc or .gcgrc.ksh file, if one exists. This file is not executed until after the logical name and symbol service is fully initialized and after all environment tables are set. Because of this, the .gcgrc or .gcgrc.ksh file is the best place to put your customized commands.

- To create a .login, .profile, .gcgrc, or a .gcgrc.ksh file:

Use a text editor of your choice, for example vi. Create the file(s) in your top directory.

Note: To test your login file after you've edited and saved it, type % source filename (csh) or % . filename (ksh), for example % source .login (csh) or % . .profile (ksh). The system reruns the file.

Initializing the Wisconsin Package

[ Previous | Top | Next ]

- To set up your login to automatically initialize the Wisconsin Package:

1. - - Open your .login (csh) or .profile (ksh) file in the text editor of your choice, for example vi.

2. - - Use the following as an example of what to type:
   
   (csh) - source /usr/users/gcg/gcgstartup
   - gcg
   
   (ksh) - . /usr/users/gcg/gcgstartup
   - . $GCGCOMMAND

   Note: The first line of each of the csh and ksh examples sets environment variables for working with the Wisconsin Package. See your system manager for the correct specification at your site.
   
   The second line of each of the examples initializes the Package.

3. - - Save the file and exit from the text editor.

   Note: For more information, see "Working with Shell Scripts" in the "For Advanced Users" section of Chapter 3, Using Programs.

Automating Program Commands

[ Previous | Top | Next ]

You may find that you frequently run a Wisconsin Package program using the same parameters each time. You can define an alias in your .gcgrc (csh) or .gcgrc.ksh (ksh) file to create a shortcut command for the program and its parameters.

Before you create an alias, you should check to make sure the alias is not already defined. To do so, type % alias alias_name. Then (if the alias is not defined, or if you want to redefine the alias) use the following syntax to define an alias:

% alias command_line

If you define an alias at the operating system prompt, it will be in effect until you log out. To save your alias from one session to the next, add it to your .gcgrc (csh) or .gcgrc.ksh (ksh) file.

- To define an alias:

1. - - Open your .gcgrc or .gcgrc.ksh file in the text editor of your choice, for example vi.

2. - - Type the alias(es). For example, let's say you frequently run the MapPlot program with the parameter -CIRcular. To create an alias, use the following as an example to write your own program commands.

   (csh) - alias mc mapplot -CIRcular
   
   (ksh) - alias mc=mapplot -CIRcular

3. - - Save the file and exit from the text editor.

   Note: Make sure the .gcgrc or .gcgrc.ksh file is located in your top directory.

4. - - Test the alias(es).
   1. - Type % source .login (csh) or % . .profile (ksh) to rerun your .login or .profile file.

   2. - Type the alias you assigned, for example % mc. The alias should run the specified program and parameters (mapplot -CIRcular).

Defining Logical Names

[ Previous | Top | Next ]

You can assign logical names to files you use frequently or directories that you move to frequently. When you define logical names in your .gcgrc (csh) or .gcgrc.ksh (ksh) file, they are available every time you initialize the Wisconsin Package.

Note that before you define a logical name, you first should check to make sure the logical name is not already defined. To do so, type % name logical_name.

- To define logical names in your .gcgrc (csh) or .gcgrc.ksh (ksh) file:

1. - - Open your .gcgrc (csh) or .gcgrc.ksh (ksh) file in the text editor of your choice, for example vi.

2. - - On a single line, type name -s logical_name ~/directory, for example name -s Proj ~/project. The ~ (tilde) represents your home directory.

3. - - Save the file and exit from the text editor.

For more information on defining logical names, see the topic "Defining and Using Logical Names for Directories" earlier in this chapter.

Defining Your Graphics Configuration

[ Previous | Top | Next ]

Before you run a Wisconsin Package program that produces graphic output, you must define your graphics configuration. Defining your graphics configuration means telling the computer what graphics language you want to use and on what device you want to display. For more information, see "Initializing Your Graphics Configuration" in Chapter 5, Using Graphics.

- To define your graphics configuration in your .gcgrc (csh) or .gcgrc.ksh (ksh) file:

1. - - Determine what graphics commands you need to add to your .gcgrc or .gcgrc.ksh file by running through a configuration interactively. That is, type the name of the graphics configuration command you are interested in, for example postscript, press <Return>, and answer the graphics configuration prompts. Remember the order of the prompts and your answers to them; you will add them later to your .gcgrc or .gcgrc.ksh file.

2. - - Open your .gcgrc or .gcgrc.ksh file in the text editor of your choice, for example vi.

3. - - Move to the point in your .gcgrc or .gcgrc.ksh file where you want to define the configuration commands.

4. - - On a single line, type the commands you defined in step 1, separating each with a single space. Most graphics configuration commands use the following format:
   
   graphics_language graphics_device port_or_queue
   
   where

   graphics_language is the name of the graphics language you want to use. For more information about what graphics languages are available, see "Configuring Graphics Languages and Devices" in Appendix C, Graphics.

   graphics_device is the device you want to send output to, for example a graphics terminal screen, printer, or plotter. Supported devices also are listed in "Configuring Graphics Languages and Devices" in Appendix C, Graphics.

   port_or_queue is where the graphics device is attached, for example term or /dev/tty11.

   For example, to set up a graphics configuration for a LaserWriter, you might type postscript laserwriter /dev/tty11.

   Note: Some graphics configuration commands have fewer prompts, such as XWindows, and some have more, such as HPGL. Make sure you answer all the prompts when you set up your graphics configuration in your .gcgrc or .gcgrc.ksh file.

   TIP - "Initializing Your Graphics Configuration" in Chapter 5, Using Graphics describes using the SetPlot command to define your graphics configuration from the command line. You also can use the SetPlot command in your .gcgrc or .gcgrc.ksh file to define your graphics configuration for you when you log in. To do so, follow these steps:

   1. - - Open your .gcgrc or .gcgrc.ksh file in the text editor of your choice, for example vi.

   2. - - Move to the point in your .gcgrc or .gcgrc.ksh file where you want to define the configuration commands.

   3. - - Type setplot graphics_device where graphics_device is the name of one of the menu items when you run SetPlot.

   4. - - Save the file and exit from the text editor. The next time you log in, your graphics configuration will automatically be initialized.
      

[ Program Manual | User's Guide | Data Files | Databases ]

Documentation Comments: doc-comments@gcg.com
Technical Support: help@gcg.com

Copyright (c) 1982, 1983, 1985, 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1997 Genetics Computer Group, Inc. a wholly owned subsidiary of Oxford Molecular Group, Inc. All rights reserved.

All other product names mentioned in this documentation may be trademarks, and if so, are trademarks or registered trademarks of their respective holders and are used in this documentation for identification purposes only.

www.gcg.com