Running@ecmwf

Indice dei contenuti

1 installing and using PERL modules
2 Building an operational chain (at ECMWF)
3 Endianess (HPCE)
4 Info on 32/64 bit
5 Info on single/double precision (HPCE)
6 GRIB-2 coding/encoding using GRIB API

installing and using PERL modules

download:

perl -MCPAN -e 'install Chocolate::Belgian'

change dir to
```
$HOME/.cpan/build/<module> 
```

run

perl Makefile.PL LIB=$HOME/<mylib> PREFIX=$HOME/<mylib>

run
```
make install
```
in the perl script:
```
use lib '$HOME/<mylib>'
```
in your .kshrc file put:
```
export OBJECT_MODE=32
```
N.B. if you are going to compile BOLCHEM, remove the "export OBJECT_MODE=32" from .kshrc otherwise the compilation will not succeed!

Building an operational chain (at ECMWF)

In general the operational chain is made of the following sequential steps:

Data Retrieval (e.g. real time2 data from MARS)
Preprocessing
Run the model
Post-processing

To this scope it is first necessary to have a tool that allow us to retrieve the data (e.g. to start step1) once it is avaliable. At ECMWF, the command ecjput allows to start a job if a condition is verified. For example, the command
```
ecjput hpce job.cmd -ni 180
```
submits the job.cmd on hpce; the job remains in stand-by until the condition 180 (avaliability of 12utc day 3 deterministic forecast) is verified. The command ecels gives a list of the events (code, name, and description) that can be used in the -ni option in conditioning the execution of a job. See for reference http://www.ecmwf.int/services/computing/docs/tc_apps/tc_opt1.html.
The second need is a multi step job, in general a job divided in more steps, that can reproduce the chain steps listed above. The first step is called sustaining step, the other(s) dependent. A dependent step begins depending on the exit status of the sustaining step. To implement a multiple steps job at ECMWF see the manual http://www.ecmwf.int/publications/manuals/hpcf/ll.pdf (page 166 and following)

Endianess (HPCE)

Environment variable:
```
XLFRTEOPTS=ufmt_littleendian=unit list
```
(N.B. The variable is to be set Runtime, before launching the executable; not in compilation!!!) http://www.fz-juelich.de/conference/datapool/parco07/mpitut-jordan-parco07.pdf
Runtime ... ..SETRTEOPTS http://publib.boulder.ibm.com/infocenter/lnxpcomp/v9v111/topic/com.ibm.xlf111.linux.doc/xlfcr/runpgms.htm

Info on 32/64 bit

On HPCE at ECMWF the addressing mode is at 64 bit ($OBJECT_MODE).
Ecgate has a default addressing at 32 bit.

Info on single/double precision (HPCE)

Grib library compiler option for working at double precision: $EMOSLIB
Grib library compiler option for working at single precision: -lemos.R32.D64.I32

GRIB-2 coding/encoding using GRIB API

Some info (Installation, description and examples in C and FORTRAN) regarding the use of GRIB API library: here.

Here are a summary of the steps to follow reading a grib (1 or 2) file (refer for example to this code:

It is good to have a template grib file, in order to start with a pre-defined grib message retrieved opening the file:
```
call grib_check(grib_open_file(infile,'template_file.grib2','r'))
```
Then open an output file if you are going to encode in grib2:
```
call grib_check(grib_open_file(outfile,output_filename,'w'))
```

Read a grib message from the template file:

call grib_check( grib_new_from_file(infile,igrib)

Decode/encode using calls to grib_get_.../grib_set_...
example:

call grib_check(grib_set_int(id_grib,'year',year))

call grib_check(grib_set_real8_array(id_grib,'values',array_of_values,array_dimension))

Write the modified message to the output file:

 call grib_check(grib_write(id_grib,outfile))

Closing calls:

call grib_check(grib_close_file(infile))

call grib_check(grib_release(id_grib))

 call grib_check(grib_close_file(outfile))

GRIB tools are available at the ECMWF machines. A useful tool is grib_dump, that allows to get the message from a file. An example output from "grib_dump -a" (writes also the aliases of the keys) can be found here.

T&D

internal area