Introduction to Advanced UNIX

1
Introduction to Advanced UNIX

• March 16 2009
• Kevin Keay

2
Outline

• Overview
• Resources
• The basic form of a typical C-shell script
• Introduction to C-Shell Programming
• Advanced UNIX materials The following are PDF
  documents that may be used for reference but
  wont be discussed in detail during this short
  course
• Part 1 Scripts
• Part 2 A summary of useful software
• Part 3 Reanalysis products
• Lab session (informal) 2-330 PM UNIX Lab
• See http//www.earthsci.unimelb.edu.au/kev
  in/UNIX_Course/Advanced_UNIX_Lab_Session_2009.pdf

3
Overview

• This is a practical course that is designed to
  give you the basic skills to write UNIX C-shell
  scripts
• You can only truly understand the concepts by
  putting them into practice!

4
Overview (2)

• We will look at the basic form of a C-shell
  script
• There will be a quick tour through Introduction
  to C-Shell Programming
• There are some extra advanced UNIX materials
  (Parts 1-3) that you may need to reference. Some
  aspects will be looked at during the lab session
  but they are intended for personal reference
• Part 1 covers C-shell scripts and some additional
  concepts
• Part 2 is a summary of some useful software
• Part 3 focuses on downloading and decoding
  reanalysis data (NetCDF and GRIB)
• Finally, there is a short Lab session

5
Resources

• A very useful and concise reference book covering
  UNIX and the C shell is
• UNIX in a Nutshell, OReilly and Associates
  (Engineering Library 005.43 GILL).
• A useful online resource from the University of
  Surrey, UNIX Tutorial for Beginners, is available
  at http//www.ee.surrey.ac.uk/Teaching/Unix/
• For PDF files of the handouts see
  http//www.earthsci.unimelb.edu.au/kevin/UNIX_Cou
  rse/
• All UNIX commands should have a manual (man) page
  on the machine that you are using e.g. man awk.
  However sometimes the pages are not installed or
  are in an unexpected location. It may be more
  convenient to use a search engine like Google to
  find information on a command.

6
The basic form of a typical C-shell script

• The first line of a C-shell script (text file)
  is
• !/bin/csh f
• The f option tells the script not to source
  (read) the users .cshrc file this is faster and
  also makes the script more portable.
• All other lines starting with are comments
• Commands may be continued onto subsequent lines
  with \
• Multiple commands can be placed on a single line
  with
• Spaces around operators and commands are required
  but there are no other restrictions

7
The basic form of a typical C-shell script (2)

• For neatness, end the script with exit (not
  essential)
• Shell variables start with a (this is only
  omitted with using set or _at_ - see below)
• The shell variable argv contains the number of
  arguments (items) typed on the command line. The
  items are referred to as shell variables 1, 2,
  3, , argv

8
The basic form of a typical C-shell script (3)

• For example
• myscript jja -4.56 yes
• would give
• argv 3
• 1 jja
• 2 -4.56
• 3 yes

9
The basic form of a typical C-shell script (4)

• Shell variables are either string (text) or
  numeric
• A string variable is set (defined) by
• set var value
• e.g. set x Fred
• Note Variables and values are case-sensitive
  i.e. x is not the same as X
• Variable names can be several characters e.g. set
  Case2 3
• To print (display) the value of a variable
• echo var
• e.g. echo x
• Fred

10
The basic form of a typical C-shell script (5)

• A numeric variable is set (defined) by
• _at_ var integer
• e.g. _at_ k -7
• Simple calculations may be performed
• e.g. _at_ j (k 1) j would be 7 1 -6
• _at_ k (k 1) would change k from -7 to -6
• Could also use C notation _at_ k
• _at_ j (2 k - 5) k -7 would give j -19
• Note Put spaces around operators like , etc.
• Floating point operations are not normally used
  in scripts but can be done with the command bc
• e.g. echo "2.1 6.3" bc
• would print 8.4 on the screen
• set y echo "2.1 6.3" bc
• would save the answer in variable y

11
The basic form of a typical C-shell script (6)

• A shell variable may be given the output of a
  command (or user program) as in the bc example.
  In general
• set var command
• e.g. set ff ls .dat
• Remember ls is used to list files.
• If the files are 5.dat 12.dat 13.dat then
• echo ff would display
• 5.dat 12.dat 13.dat

12
The basic form of a typical C-shell script (7)

• To extract the individual elements of variable ff
  we can use ff to find the number of items
  (similar to argv)
• e.g. echo ff would display 3
• echo ff1 would display 5.dat
• echo ff2 would display 12.dat
• echo ff3 would display 13.dat

13
The basic form of a typical C-shell script (8)

• A while loop is used to set up an iterative or
  repetitive procedure
• while (condition is true)
• commands
• end
• e.g. _at_ k 1 Initialise k
• while (k lt 3) Process loop while k lt 3
• echo k Display k
• _at_ k (k 1) Increment k by 1
• end

14
The basic form of a typical C-shell script (9)

• An if-else-endif structure is used to control
  script branching
• if (condition 1 is true)
• commands
• else if (condition 2 is true)
• commands
• else
• commands
• endif
• Note use else if not elseif

15
The basic form of a typical C-shell script (10)

• e.g.
• if (x 6 s sea) then
• do something
• else if (x gt 10) then
• do something else
• else
• go here if neither of the above conditions is
  true
• endif
• Simpler or more complex forms are possible
• e.g. if (y 2) ls l .dat

16
The basic form of a typical C-shell script (11)

• The while or if (condition) uses C notation for
  logical operations
• or
• and
• equal
• gt greater than or equal
• lt less than or equal
• ! not equal
• gt greater than
• lt less than

17
The basic form of a typical C-shell script (12)

• An example
• !/bin/csh f
• if (argv ! 1) then
• echo Usage myscript name
• exit If incorrect usage end the script
• else If only 1 argument, branch here
• set n (1) Put n equal to 1
• endif
• echo Your name is n
• You could do other things here
• exit

18
The basic form of a typical C-shell script (13)

• Another example
• !/bin/csh f
• set ff ls .dat ff contains filenames
  .dat
• _at_ nf ff nf equals the no. of files
  (items in ff)
• _at_ j 1 Set counter j to 1
• while (j lt nf) Loop while j lt nf
• set f ffj Set f to be the jth file
  
• ls l f List the details of f
• We could use the file f as an argument to a
  command or program
• myprog f
• _at_j (j 1) Increment counter j by 1
• end Go here when j gt nf
• echo We are finished! A message to the
  screen
• exit

19
Introduction to C-shell programming

• Refer to the PDF guide
• http//www.earthsci.unimelb.edu.au/kevin/UNIX_Cou
  rse/Intro_to_C-Shell_Programming_2008.pdf

20
Advanced UNIX materials

• The following are PDF documents that may be used
  for reference but wont be discussed in detail
  during this short course
• Part 1 Scripts
• Part 2 A summary of useful software
• Part 3 Reanalysis products

21
Lab session

• Lab session (informal) 2-330 PM UNIX Lab
• See http//www.earthsci.unimelb.edu.au/kevi
  n/UNIX_Course/Advanced_UNIX_Lab_Session_2009.pdf