GEOG0111
UCL Geography MSc notes.
| Author: P. Lewis and J. Gomez-Dans | version 1.1.0 |
GEOG0111 Scientific Computing
Course information
Course Convenor
Teaching Staff 2021-2022
| Prof P. Lewis |
Support Staff 2021-2022
| Wanxin Yang |
Contributing Staff
| Dr Qingling Wu | Dr. Jose Gomez-Dans | Feng Yin |
Purpose of this course
This course, GEOG0111 Scientific Computing, is a term 1 MSc module worth 15 credits (25% of the term 1 credits) that aims to:
- impart an understanding of scientific computing
- give students a grounding in the basic principles of algorithm development and program construction
- to introduce principles of computer-based image analysis and model development
It is open to students from a number of MSc courses run by the Department of Geography UCL, but the material should be of wider value to others wishing to make use of scientific computing.
The module will cover:
- Computing in Python
- Computing for image analysis
- Computing for environmental modelling
- Data visualisation for scientific applications
Learning Outcomes
At the end of the module, students should:
- have an understanding of the Python programmibng language and experience of its use
- have an understanding of algorithm development and be able to use widely used scientific computing software to manipulate datasets and accomplish analytical tasks
- have an understanding of the technical issues specific to image-based analysis, model implementation and scientific visualisation
Running on UCL JupyterHub
Follow the instructions on UCL installation and running
Timetable
The course takes place over 10 weeks in term 1, on Monday in the UCL Computing Lab (113) in Torrington (1-19), UCL.
Classes take place from the second week of term to the final week of term, other than Reading week. See UCL term dates for further information.
The timetable is available on the UCL Academic Calendar. Live class sessions will take place in groups on Monday with help sessions on Thursdays.
The Thursday help sessions will be held in room 110 in the Northwest Wing (Geography Department, first floor)
Assessment
Assessment is through two pieces of coursework, submitted in both paper form and electronically via Moodle.
See the Moodle page for more details.
Useful links
Using the course notes
We will generally use jupyter notebooks for running interactive Python programs. If you are taking this course at UCL,
follow the instructions on UCL installation and running.
If you are interested in running the course notes from outside UCL on your own computer, there are several options:
- Do a local install of the required software to run the notebooks (basically, Anaconda Python and some packages, this is around 15 GB of space on my own setup, but you might get away with a smaller Pythjon install). Its quite easy to set up, particularly on linux or OS X. It is a little more involved on Windows, but quite achievable following these notes
- You can run a Docker container on your local computer. That Docker image contains all of the software you need to do the course, so all you have to do is to set up Docker on your computer. There are various ways to run it, but we adviuse that you make a copy of the notes on your local computer, then run the notebookjs using Docker. There are full instructions these here, but the basics of what you need are given in the docker hub.
- You could use or
to run the course. These use external resources (so, not UCL and not your own computer) to run the notebooks. The only problem for you is that the sessions are not persistent, so any changes or exercises you do in a notebook would be lost to you the next time you start a binder or colab session. There are ways around that that would work fine for the first half of the course. The simplest is for you to download any notebook that you change to your local computer, then relaod it the next time you run a session. Its a bit of a hassle, but the service is free, and you can run it simply from any browser (e.g. yopur phone or ipad).
Updating notes
From time to time, we need to update the notes because of a bug or some other change. That's great, because we are using git which allows and controls all of that.
At the same time, we don't want any update to mess up any work you may have already done, for example in a notebook.
There is a mechanism in git that allows this sort of thing, called a stash.
The way to use it is, when you are told to update the notes, first create a stash with some meaningful name/label, e.g. `my edits on monday'. First, go to the directory your work in in (the working directory):
cd ~/geog0111/notebooks
Then create the stash with your label:
git stash save "my edits on monday"
Now, pull the new notes:
git pull origin master
Suppose this pulled a new version of the file 001_Notebook_use.ipynb,m but you had edits in that file that you wasnted to keep. Then the pull wouyld overwrite your edits, BUT they would still be available via the stash.
You can see a diff (what changed from the last stash entry) by using:
git stash show -p stash@{0}
You have two main options then for using the stash:
apply the changes to the new file:
git stash apply STASH-NAME
Or move the old file back in place of the new file:
git stash pop STASH-NAME
For anything more complex than that, look at this explainer.