Flags:¶

-h | -help | --help

Prints a brief usage message and exits

-v | --version

Prints the version of GRASS and exits

-c

Creates new GRASS unprojected location in specified GISDBASE

-c geofile

Creates new GRASS projected location in specified GISDBASE based on georeferenced file

-c EPSG:code

Creates new GRASS projected location in specified GISDBASE with given EPSG code

-c EPSG:code:datum_trans

Creates new GRASS projected location in specified GISDBASE with given EPSG code and datum transform parameters

-e

Exit after creation of location or mapset. Only with -c flag

-f

Forces removal of .gislock if exists (use with care!). Only with --text flag

--text

Indicates that Text-based User Interface should be used (skip welcome screen)

--gtext

Indicates that Text-based User Interface should be used (show welcome screen)

--gui

Indicates that Graphical User Interface (wxGUI) should be used

--config

Prints GRASS configuration parameters (options: arch, build, compiler, date, path, python_path, revision, svn_revision, version)

--exec EXECUTABLE

Execute GRASS module or script. The provided executable will be executed in a GRASS GIS non-interactive session.

--tmp-location

Run using a temporary location which is created based on the given coordinate reference system and deleted at the end of the execution (use with the --exec flag). The active mapset will be the PERMANENT mapset.

--tmp-mapset

Run using a temporary mapset which is created in the specified location and deleted at the end of the execution (use with the --exec flag).

Parameters:¶

GISDBASE

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

LOCATION

Initial location directory which is a subdirectory of GISDBASE

MAPSET

Initial mapset directory which is a subdirectory of LOCATION Note: These parameters must be specified in one of the following ways:

    MAPSET


    LOCATION/MAPSET


    GISDBASE/LOCATION/MAPSET
    

Running non-interactive jobs¶

The --exec flag can run an executable on path, GRASS module, or a script. All are executed as a subprocess and any additional arguments are passed to it. A script needs to be specified by full or relative path and on unix-likes systems, the script file must have its executable bit set. Calling the interpreter (e.g., python) and providing the script as a parameter is possible, too. When it is finished GRASS will automatically exit using the return code given by the subprocess. Although the execution itself is non-interactive (no GUI or shell), the subprocess itself can be interactive if that is what the user requires.

Config flag¶

The flag --config option prints GRASS GIS configuration and version parameters, with the options:

User Interface Environment Variable¶

The grass 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 grass is run, then it will be created and then saved in the $HOME/.grass8/rc file for the next time GRASS is run. It can be set to text, gtext or gui.

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

1

Command line argument

2

Environment variable GRASS_GUI

3

Value set in $HOME/.grass8/rc (GUI)

4

Default value - gui

Python Environment Variables¶

If you choose to use wxGUI interface, then the GRASS_PYTHON environment variable can be used to override your system default python command.

Suppose for example your system has Python 3.6 installed and you install a personal version of the Python 3.8 binaries under $HOME/bin. You can use the above variables to have GRASS use the Python 3.8 binaries instead.

   GRASS_PYTHON=python3.8

Addon Path to Extra User Scripts¶

This environment variable allows the user to extend the GRASS program search paths to include locally developed/installed GRASS modules or user scripts.

   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.

Addon Base for Extra Local GRASS Addon Modules¶

This environment variable allows the user to extend the GRASS program search paths to include locally installed (see g.extension for details) GRASS Addon modules which are not distributed with the standard GRASS release.

   GRASS_ADDON_BASE=/usr/grass-addons

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

If not defined by user, this variable is set by GRASS startup program to $HOME/.grass8/addons on GNU/Linux and %APPDATA%\Roaming\GRASS8\addons on MS Windows.

HTML Browser Variable¶

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

Batch jobs with the exec interface¶

Creating a new Location based on a geodata file’s projection (-c) and exit (-e) immediately:

grass -c elevation.tiff -e /path/to/grassdata/test1/

Linking external raster data to PERMANENT Mapset:

grass /path/to/grassdata/test1/PERMANENT/ --exec r.external input=basins.tiff output=basins
grass /path/to/grassdata/test1/PERMANENT/ --exec r.external input=elevation.tiff output=elevation

Get statistics for one raster map:

grass /path/to/grassdata/test1/PERMANENT/ --exec r.univar map=elevation

Compare the rasters visually:

grass /path/to/grassdata/test1/PERMANENT/ --exec g.gui.mapswipe first=elevation second=basins

Execution of shell and Python scripts instead of single commands¶

A sequence of commands can be bundled in a script and executed using the exec interface.

Shell script example: the command to execute a shell script might be:

grass /path/to/grassdata/test1/PERMANENT/ --exec sh test.sh

#!/bin/bash
g.region -p
g.list type=raster
r.info elevation

Python script example: the command to execute a Python script might be:

grass /path/to/grassdata/test1/PERMANENT/ --exec python test.py

#!/usr/bin/env python3
# import GRASS Python bindings (see also pygrass)
import grass.script as gs
import grass.script.setup as gsetup
gs.message(’Current GRASS GIS 8 environment:’)
print(gs.gisenv())
gs.message(’Available raster maps:’)
for raster in gs.list_strings(type=’raster’):


    print(raster)
gs.message(’Available vector maps:’)
for vector in gs.list_strings(type=’vector’):


    print(vector)

Using temporary location¶

Creating a new temporary location based on a georeferenced file’s projection coordinate reference system (CRS) and simultaneously starting computation in a shell script:

grass --tmp-location elevation.tiff --exec test.sh

The same, but using an EPSG code and a Python script:

grass --tmp-location EPSG:3358 --exec test.py

Finally, for special cases, we can create an XY location without any CRS:

grass --tmp-location XY --exec test.py

Temporary location is automatically deleted after computation, so the script is expected to export, link or otherwise preserve the output data before ending.

A single command can be also executed, e.g. to examine properties of the temporary location:

grass --tmp-location EPSG:3358 --exec g.proj -p

grass --tmp-location XY --exec r.neighbors --help

Using temporary mapset¶

A single command can be executed, e.g., to examine properties of a location (here using the NC SPM sample location):

grass --tmp-mapset /path/to/grassdata/nc_spm_08/ --exec g.proj -p

Computation in a Python script can be executed in the same way:

grass --tmp-mapset /path/to/grassdata/nc_spm_08/ --exec processing.py

Additional parameters are just passed to the script, so we can run the script with different sets of parameters (here 5, 8 and 3, 9) in different temporary mapsets which is good for parallel processing.

grass --tmp-mapset /path/to/grassdata/nc_spm_08/ --exec processing.py 5 8
grass --tmp-mapset /path/to/grassdata/nc_spm_08/ --exec processing.py 3 9

The same applies to Bash scripts (and other scripts supported on you platform):

grass --tmp-mapset /path/to/grassdata/nc_spm_08/ --exec processing.sh 5 8

The temporary mapset is automatically deleted after computation, so the script is expected to export, link or otherwise preserve the output data before ending.

Troubleshooting¶

Importantly, to avoid an "[Errno 8] Exec format error" there must be a shebang line at the top of the script (like #!/bin/sh, #!/bin/bash, or #!/usr/bin/env python3) indicating which interpreter to be used for the script. The script file must have its executable bit set.