Man Linux: Main Page and Category List

NAME

       grass64  - The GRASS startup program

SYNOPSIS

       grass64  [-]  [-v]  [-h  |  -help  |  --help]  [-text | -gui | -tcltk |
       -oldtcltk | -wxpython | -wx]] [[[/]/] ]

DESCRIPTION

       This command is used to launch GRASS GIS. It  will  parse  the  command
       line  arguments  and  then  initialize  GRASS for the user. Since GRASS
       programs require a specific environment, this program  must  be  called
       before  any other GRASS program can run. The command line arguments are
       optional and provide the user with a method  to  indicate  the  desired
       user interface, as well as the desired mapset to work on.

FEATURES

       The  grass64  startup  program  will  remember  both  the  desired user
       interface and mapset. Thus, the next time the user runs  GRASS,  typing
       grass64  (without  any  options)  will  start  GRASS  with the previous
       settings for the user interface and mapset selected.

       If you specify a graphical user  interface  (Tcl/Tk  or  wxPython)  the
       grass64 program will try to verify that the system you specified exists
       and that you can access it successfully. If any of  these  checks  fail
       then  grass64 will automatically switch back to the text user interface
       mode.

OPTIONS

       All command line options are optional.

   Flags:
       -
               Tries to start GRASS using location environment variables  (see
              below)

       -h -help --help
               Prints a brief usage message

       -text
               Indicates that the text based user interface should be used

       -gui (or -tcltk)
               Indicates  that  the  old Tcl/Tk based graphical user interface
              should be used

       -oldtcltk
               Indicates that the  even  older  Tcl/Tk  based  graphical  user
              interface should be used

       -wxpython (or -wx)
               Indicates  that  the  new Python based graphical user interface
              should be used

       -v --version
               Prints the version of GRASS and exits

   Parameters:
       GISDBASE
               Initial database directory which should be  a  fully  qualified
              path (e.g., /usr/local/share/grassdata)

       LOCATION_NAME
               Initial location directory which is a subdirectory of GISDBASE

       MAPSET
               Initial   mapset   directory   which   is   a  subdirectory  of
              LOCATION_NAME

       Note- These parameters must be specified in one of the following ways:
       MAPSET
       LOCATION_NAME/MAPSET
       GISDBASE/LOCATION_NAME/MAPSET

ENVIRONMENT VARIABLES

       A number of environment variables are available  at  GRASS  startup  to
       assist  with  automation and customization. Most users will not need to
       bother with these.

       In addition to these shell  environment  variables  GRASS  maintains  a
       number  of  GIS environment variables in the $HOME/.grassrc6 file. User
       changes to this file will be read during the next startup of GRASS.  If
       this  file  becomes corrupted the user may edit it by hand or remove it
       to start afresh.  See the list of implemented GRASS variables for  more
       information.   The  rest  of  this  help  page will only consider shell
       environment variables.

   User Interface Environment Variable
       The grass64 program will check for  the  existence  of  an  environment
       variable  called  GRASS_GUI  which indicates the type of user interface
       for GRASS to use. If this variable is not set when grass64 is run, then
       it  will  be created and then saved in the $HOME/.grassrc6 file for the
       next time GRASS is run. In addition to "text", "tcltk"  or  "wxpython",
       the GRASS_GUI variable can be set to the name of the Tcl/Tk GUI to use,
       for example "gis.m" or "d.m".

       There is an order of precedence in the way grass64 determines the  user
       interface   to  use.  The  following  is  the  hierarchy  from  highest
       precedence to lowest.

       Interface precedence
              • Command line argument
              • Environment variable GRASS_GUI
              • Value set in $HOME/.grassrc6
              • Default value - currently gis.m

   Tcl/Tk and Python Environment Variables
       If you choose to use the Tcl/Tk  graphical  user  interface,  then  the
       following  environment  variables  can  be used to override your system
       default tclsh and wish commands.

       GRASS_TCLSH
               Command to use to override tclsh

       GRASS_WISH
               Command to use to override wish

       GRASS_PYTHON
               Command to use to override python

   Example Use of GRASS Tcl/Tk Environment Variables
       Suppose your system has Tcl/Tk 8.3 installed and you install a personal
       version  of  the  Tcl/Tk  8.5 binaries under $HOME/bin. You can use the
       above variables to have GRASS use the Tcl/Tk 8.5 binaries instead.

          GRASS_TCLSH = $HOME/bin/tclsh8.5
          GRASS_WISH  = $HOME/bin/wish8.5

   Example Use of the GRASS Python Environment Variable
          GRASS_PYTHON=python2.5

   Addon path to extra local GRASS modules
       This environment variable allows the user to extend the  GRASS  program
       search paths to include locally developed/installed addon modules which
       are not distributed with the standard GRASS release.

          GRASS_ADDON_PATH=/usr/mytools
          GRASS_ADDON_PATH=/usr/mytools:/usr/local/othertools

       In this example above path(s) would be added to the standard GRASS path
       environment.

   HTML browser variable
       The  GRASS_HTML_BROWSER environment variable allows the user to set the
       HTML web browser to use for dispalying help pages.

   Location Environment Variables
       The Synopsis and Options sections above describe options  that  can  be
       used  to  set the location and mapset that GRASS will use. These values
       can also be set with environment  variables.  However,  specifying  the
       location  and  mapset variables on the command line will override these
       environment variables. The available variables are as follows:

       LOCATION
               A    fully    qualified    path     to     a     mapset     (eg
              /usr/local/share/grassdata/spearfish60/PERMANENT).          This
              environment variable overrides the GISDBASE, LOCATION_NAME,  and
              MAPSET variables.

       GISDBASE
               Initial  database  directory  which should be a fully qualified
              path (eg /usr/local/share/grassdata)

       LOCATION_NAME
               Initial location directory which is a subdirectory of GISDBASE

       MAPSET
               Initial  mapset  directory   which   is   a   subdirectory   of
              LOCATION_NAME

   Running non-interactive batch jobs
       If the GRASS_BATCH_JOB environment variable is set to the full path and
       filename of a shell script then  GRASS  will  be  launched  in  a  non-
       interactive  way  and  the script will be run. The script itself can be
       interactive if that is what the user  requires.  When  it  is  finished
       GRASS  will automatically exit using the exit-success code given by the
       script.  The script file must have its executable bit set.

   Note
       Note that you will need to set these variables  using  the  appropriate
       method  required for the UNIX shell that you use. (e.g. in a Bash shell
       you must "export" the variables for them to propogate)

EXAMPLES

       The following are some examples of how you could start GRASS

       grass64
               Start GRASS using the default user interface. The user will  be
              prompted to choose the appropriate location and mapset.

       grass64 -gui
               Start  GRASS  using  the  Tcl/Tk based user interface. The user
              will be prompted to choose the appropriate location and  mapset.

       grass64 -text
               Start  GRASS using the text based user interface. The user will
              be prompted to choose the appropriate location and mapset.

       grass64 ~/grassdata/spearfish60/user1
               Start GRASS using the default user interface and  automatically
              launch  into  the  given  mapset, bypassing the mapset selection
              menu.

       grass64 -gui -
               Start GRASS using the Tcl/Tk based user interface  and  try  to
              obtain the location and mapset from environment variables.

   Other examples
       There are a variety of ways in which the location environment variables
       (see above) can be used to specify the mapset to  use.   The  following
       are some possible examples.

       Example 1
               The environment variables are defined as follows:
              LOCATION = /usr/local/share/grassdata/spearfish60/PERMANENT
              GISDBASE = /usr/local/share/grassdata
              LOCATION_NAME = spearfish60
              MAPSET = PERMANENT
              Start GRASS with the following command:
              grass64 -
              GRASS  will  start with the mapset defined by LOCATION since the
              LOCATION variable overrides the other variables.

       Example 2
               The environment variables are defined as follows:
              GISDBASE = /usr/local/share/grassdata
              LOCATION_NAME = spearfish60
              MAPSET = PERMANENT
              Start GRASS with the following command:
              grass64 -
              GRASS    will    start    with    the    mapset    defined    by
              GISDBASE/LOCATION_NAME/MAPSET.

       Example 3
               The environment variables are defined as follows:
              LOCATION = /usr/local/share/grassdata/spearfish60/PERMANENT
              GISDBASE = /usr/local/share/grassdata
              LOCATION_NAME = spearfish60
              MAPSET = PERMANENT
              Start GRASS with the following command:
              grass64 /usr/home/grass/data/thailand/forests
              GRASS        will        start       with       the       mapset
              /home/grass/data/thailand/forests    which     overrides     the
              environment variables.

       Example 4
               The environment variables are defined as follows:
              LOCATION = /usr/local/share/grassdata/spearfish60/PERMANENT
              GISDBASE = /usr/local/share/grassdata
              LOCATION_NAME = spearfish60
              MAPSET = PERMANENT
              Start GRASS with the following command:
              grass64 swamps
              GRASS    will    start    with    the    mapset    defined    by
              GISDBASE/LOCATION_NAME/swamps since the  command  line  argument
              for the mapset overrides the environment variable MAPSET.

       Example 5
               The environment variables are defined as follows:
              LOCATION = /usr/local/share/grassdata/spearfish60/PERMANENT
              GISDBASE = /usr/local/share/grassdata
              LOCATION_NAME = spearfish60
              MAPSET = PERMANENT
              Start GRASS with the following command:
              grass64 thailand/forests
              GRASS    will    start    with    the    mapset    defined    by
              GISDBASE/thailand/forests since the command line  arguments  for
              the  location  and  mapset  overrides  the environment variables
              LOCATION_NAME and MAPSET.

CAVEAT

       If you start GRASS using the Tcl/Tk interface  you  must  have  a  wish
       command in your $PATH variable. That is, the command must be named wish
       and not something like wish8.3. By default, some  Tcl/Tk  installations
       do  not  create a wish command. In these cases the system administrator
       must create an appropriate link to the actual wish program.

       For  example,  suppose   Tcl/Tk   8.3   programs   are   installed   in
       /usr/local/bin.   Then  the  system  administrator  should  go  to  the
       /usr/local/bin directory and run the commands "ln -s wish8.3 wish"  and
       "ln -s tclsh8.3 tclsh" to properly install Tcl/Tk for use with GRASS.

       Furthermore,  if  you  have  more than one version of Tcl/Tk installed,
       make sure that the version you want to use  with  GRASS  is  the  first
       version  found  in  your  $PATH  variable.  GRASS  searches  your $PATH
       variable until it finds the first version of wish.

FILES

       $UNIX_BIN/grass64 - GRASS startup program (Linux, MacOSX etc.)
       $WINDOWS_BIN/grass64.bat - GRASS startup program (MS-Windows)
       $GISBASE/etc/Init.sh - GRASS initialization script called by grass64
       $GISBASE/etc/gis_set.tcl - Tcl/Tk script to set the location and mapset
       to use. Called by Init.sh

SEE ALSO

       List of implemented GRASS environment variables.

       GRASS Web site

       GRASS 6 Programmer’s Manual

AUTHORS (of this page)

       Justin Hickey
       Markus Neteler
       Hamish Bowman

       Last changed: $Date: 2009-02-24 06:01:00 +0100 (mar, 24 feb 2009) $

       Help Index