Computational science and engineering involves the synthesis of data structures, algorithms, numerical analysis, programming methodologies, simulation, visualization, data analysis, performance optimization, and use of emerging technologies, all applied to the study of complex problems in science and engineering. Physics 7682 is a graduate computational science laboratory course, emphasizing hands-on programming to address a number of interesting problems arising in physics, biology, engineering, applied mathematics, and computer science. The course is largely self-paced, allowing students to choose from among a variety of topics, and explore new problems of particular interest. Unlike other courses focused more specifically on algorithms, data structures or numerical analysis, this course emphasizes the integration of those and other topics to understand a variety of scientific phenomena and computational methods.

Topics

The course is organized around computational modules, which are drawn from a number of different fields. The course originally was a core element in the curriculum of Cornell's IGERT Program in Nonlinear Systems, which was organized broadly around the themes of complex networks, biolocomotion and manipulation, gene regulation, and pattern formation. Topics have evolved organically from that starting point. Modules are designed to expose students to techniques and methods from a variety of disciplines, not normally encompassed in a single course. Computational methods include solution of ordinary and partial differential equations, root finding, graph traversal, stochastic simulation via Monte Carlo, and various techniques in data analysis. Scientific topics include:

• Complex networks, small worlds, and percolation
• Human locomotion and models of walking
• Dynamical systems, chaos, and iterated maps
• Pattern formation and spiral waves in cardiac tissue
• Chemical kinetics and gene regulatory networks
• Random matrix theory
• Random walks, extremal statistics, and stock fluctuations
• Lattice Monte Carlo and the Ising model
• Satisfiability and phase transitions in NP-complete problems
• Molecular dynamics and the emergence of thermodynamics

Texts

There are no required texts. There are a number of online materials and optional books which are linked to in the navigation bar at the left, and in this list of materials on Python, relevant Python libraries, and associated computational methods.

Course structure

This course is run mostly as a self-paced computer lab that provides an introduction to techniques arising in a wide variety of problems in computational science and engineering. For the most part, the course consists of implementing and analyzing scientific computations based on exercises and published papers, using skeletal code fragments provided as a starting point. There are a wide variety of course modules, and students are not expected to complete every module by the end of the semester. (Most students complete approximately 3-6 modules during the course.) Rather, it is useful to work on a set of exercises that span a range of scientific and computational topics, to get a sense of the breadth of techniques and applications. Opportunities also exist for motivated students to implement computations described in other papers of interest or in research-related projects. Students work on exercises in class, and the instructor is available to answer questions, help debug programs, and to discuss scientific and computational issues of interest. Students can work either individually, or in groups, as they like.

The class involves some lectures by the instructor, both at the beginning of the semester to provide some background and introduction to the course, and then scattered throughout the semester to describe course exercises in their scientific and computational context.

In addition, each student will be expected to give at least one 15-minute presentation at some point during the semester, describing a relevant programming language feature, computational library or method of interest that they have investigated. Students can discuss possible ideas for lecture topics with the instructor, or to obtain suggestions for topics.

Prerequisites

No formal prerequisites exist. A wide variety of computational backgrounds among students is anticipated, with some students having considerable experience in computational science research and others having little or no previous exposure to programming or the topics in this course. The course is largely autonomous, self-paced, and broken into modular units. In each module, everyone should complete the basic introductory sections, and most modules include opportunities for interested students to pursue problems in greater detail.

Time commitment

The course is structured to avoid substantial efforts outside of normal class hours, other than reading some background material on course modules and preparing a lecture for the class (see Course Structure above). Therefore, regular attendance and participation during class time is paramount. Because of the flexible and self-paced nature of the course, however, time missed due to occasional conflicts can be easily made up outside normal class hours. Be sure to discuss any anticipated conflicts with the instructor.

Grading

It is highly recommended that you take this course S/U, since there are no graded assignments or tests, unless your program demands that you take it for a grade to fulfill a specific requirement. If you need to take the course for a grade, your performance will be evaluated through a review of the course modules that you have worked on during the semester, as well as an additional projects you might have undertaken in consultation with the instructor. This review will involve both an oral examination and an inspection of codes, results and reported generated. For all students, attending regularly, being productively engaged, and seeking help when needed throughout the semester are the most important factors. Working together in groups is encouraged and can be useful in learning the material, with the caveat that all group members should take turns in writing and running code.