HPC University: Undergraduate Competencies

Minor Program in Computational Science Competency/Topic Overview

As part of the creation of an interdisciplinary undergraduate minor program in computational science put into place at a number of Ohio institutions, we formulated a set of competencies to serve as guidance in the creation of courses and course materials in computational science. The competency-based approach allows institutions to design their curriculum in a flexible way by integrating portions of the computational science materials into existing courses, by creating new courses focused on computational science, or doing a combination of the two.

The competencies were created by the participating faculty and then reviewed by a business advisory committee that offered some advice on topic emphasis and breadth. Since that time, a number of courses and instructional modules have been put into place and tested in a variety of instructional formats. In addition, there have been significant changes in computing technology with the advent of multi-core and many-core computational resources. The competencies below reflect the competencies based on these experiences.

Area 1: Simulation and Modeling

Explain the role of modeling in science and engineering:
- Discuss the importance of modeling to science and engineering
- Discuss the history and need for modeling
- Discuss the cost effectiveness of modeling
- Discuss the time-effect of modeling (e.g. the ability to predict the weather)
- Define the terms associated with modeling to science and engineering
- List questions that would check/validate model results
- Describe future trends and issues in science and engineering
- Identify specific industry related examples of modeling in engineering (e.g., Battelle; P&G, material science, manufacturing, bioscience, etc.)
- Discuss application across various industries (e.g., economics, health, etc.)
Analyze modeling and simulation in computational science:
- Identify different types of models and simulations
- Describe a model in terms of iterative process, linking physical and virtual worlds and the science of prediction
- Explain the use of models and simulation in hypothesis testing (e.g. scientific method)
Create a conceptual model:
- Illustrate a conceptual modeling process through examples
- Identify the key parameters of the model
- Estimate model outcomes
- Utilize modeling software and/or spreadsheets to implement model algebraic equations (e.g. Vensim, Excel, MATLAB, Mathematica)
- Construct a simple computer visualization of the model results (e.g. infectious disease model, traffic flow, etc.)
- Validate the model with data
- Discuss model quality and the sources of errors
Examine various mathematical representations of functions:
- Describe linear functions
- Define non-linear functions (e.g., polynomials, exponential, periodic, parameterized, etc.)
- Visualize functions utilizing software (e.g. Excel, Function flyer, etc.)
- Determine appropriate functional form to fit the data
- Demonstrate essential mathematical concepts related to modeling and simulation
Analyze issues in accuracy and precision:
- Describe various types of numerical and experimental errors
- Explain the concept of systematic errors
- Explain the concept of data dependent errors
- Illustrate calculation and measurement accuracy
- Identify sources of errors in modeling and approaches to checking whether model results are reasonable
Understand discrete and difference-based computer models:
- Explain the transition of a continuous function to its discrete computer representation
- Represent "rate of change" using finite differences
- Cite examples of finite differences
- Explain derivatives and how they relate to model implementation on a computer
- Write pseudo-code for finite difference modeling
Demonstrate computational programming utilizing a higher level language or modeling tool (e.g. Maple, MATLABTM, Mathematica, other):
- Describe the system syntax (e.g., menus, toolbars, etc.)
- Define elementary representations, functions, matrices and arrays, script files, etc.
- Explain programming and scripting processes (e.g., relational operations, logical operations, condition statements, loops, debugging programs, etc.)
- Create tabular and visual outputs (e.g., 2-D and 3-D subplots)
- Translate the conceptual models to run with this system and assess the model results (e.g. traffic flow and/or "spread of infectious disease")
- Illustrate other people's models utilizing the modeling program
Assess computational models:
- Assess problems with algorithms and computer accuracy
- Discuss techniques and standards for reviewing models
- Verify and validate the model
- Discuss the differences between the predicted outcomes of the model and the computed outcomes and relevance to the problem
- Discuss the suitability and limits of the model to address the problem for which the model was designed
Verification, Validation, and Accreditation:
- Understand the differences among verification, validation, and accreditation
- Define the typical VVA process for a model
- Describe specific approaches to model verification
- Describe validation of a model and its connection to experimental data
Complete a team-based, real-world model project:
- Identify a problem, create mathematical model and translate to computational modeling
- Organize and present project proposal
- Document model development and implementation
- Collaborate with team members to complete the project
Demonstrate technical communication:
- Demonstrate technical writing skills in the comprehensive report
- Demonstrate verbal communication skills in an oral presentation
- Create and present visual representation of model and results
- Address all components of a comprehensive technical report
- Respond to peer review

Area 2: Programming and Algorithms

Describe the fundamentals of problem solving
- Understand Top-Down thinking and program design Discuss breaking up a problem into its component tasks Understand how tasks acquire data
- Describe how tasks should be ordered
- Represent tasks in a flow-chart style format
- Understand the difference between high-level languages (for example Mathematica, Maple or MATLAB), medium level languages (for example FORTRAN or C) and low-level languages (assembler) and when each should be used
Understand and write Pseudo code:
- List the basic programming elements of Pseudo code
- Explain the logic behind an if/then/else statement
- Understand the iterative behavior of loops
- Describe the difference between several looping constructs
- Write Pseudo code to solve basic problems
- Understand how to represent data flow in and out of subprograms
Use subprograms in program design:
- Describe how logical tasks can be implemented as subprograms
- Understand the logical distinction between functions and subroutines
- Explain the control flow when a function is called
- Define dummy and actual arguments
- Discuss the different relationships dummy and actual arguments
- Explain how function output is used
- Understand how languages handle passed data into functions and subprograms, especially one- and two-dimensional arrays
Write code in a Programming language:
- Understand the concept of syntax in a programming language
- Describe the syntax of the programming language constructs
- List the type of subprograms available in the language
- Explain the concepts of argument pass-by-value and pass-by-reference
- Understand what a compiler and linker do
- Understand the difference between a compiled and interpreted language
- Understand the difference between a typed and an un-typed language
- Understand the difference between a source file and an executable file
- Write and run basic programs in the language of choice
- Understand how to de-bug code and how to "sanity check" code
- Understand the importance of user-interfaces: clear input instructions including physical units if needed and clearly formatted and labeled output
- Understand the numerical limits of various data types and the implications for numerical accuracy of results
Use different approaches to data I/O in a program:
- Explain the advantages and disadvantages of file I/O
- Describe the syntax for file I/O in your programming language
- Compare binary and ASCII file I/O
- Write code using file I/O and keyboard/monitor I/O
Understanding and use of fundamental programming Algorithms:
- Explain an algorithm as an ordered series of solution steps
- Describe an algorithm for a simple programming problem
- Learn and use "classic" programming algorithms from a field of interest to the student. If possible, these should be algorithms used in the student's discipline.
- Describe what a software library is
- Understand how library functions implement algorithms
- Write code to implement your own version of "classic" algorithm
- Compare with code using a library function
- Understand data flow into library functions and implications of selecting any "tuning parameters" or options that may be required
Explain various approaches to Program Design:
- Describe Functional decomposition (Top-down Problem Solving)
- Be familiar with different programming styles (e.g. function, procedural, rule based)
- Understand how to modularize code
- Understand the benefits of code re-use
- Explain the operation of a Boss-Worker design
- Compare designs based on Global Variables vs. self-contained functions
- Define Object-Oriented Programming (OOP)
- Contrast OOP with functional decomposition
- Explain the power of Inheritance in OOP
- Understand how to document code
- Understand how to write and when to use stubs and drivers
Possible Additions - Understand basic concepts of parallel programming:
- Identify independent operations or tasks in a computational problem
- Understand how to represent a computational problem as a task graph
- Explain the difference between a process and a thread
- Become familiar with a thread-parallel programming model such as OpenMP
- Write a thread-parallel program using OpenMP or language constructs
- Understand the difference between shared and local data
- Understand data dependencies and race conditions
- Use synchronization primitives to eliminate race conditions in a thread-parallel program

Area 3: Differential Equations and Discrete Dynamical Systems

Describe the solution methodology for first order linear differential and difference equations:
- Analyze modeling problems with first order differential equations and present their solution methodology (e.g. linear, homogeneous, exact)
- Analyze modeling problems with first order difference equations and present their solution methodology (e.g. homogeneous, non-homogeneous). Analyze long term behavior
Describe the solution methodology for systems of linear first order differential and difference equations:
- Describe modeling problems with systems of first order differential equations and present their solution methodology (e.g., homogeneous with constant coefficients, variation of parameters)
- Describe modeling problems with systems of first order difference equations and their solution methodology (e.g., homogeneous with constant coefficients)
Describe the solution methodology for higher order differential and difference equations:
- Describe modeling problems with higher order differential equations analyze their solution methodology (e.g., homogeneous, non-homogeneous, undetermined coefficients, variation of parameters)
- Describe modeling problems with higher order difference equations analyze their solution methodology (e.g., homogeneous, non-homogeneous). Analyze the long-term behavior.
Describe the solution methodology for differential equations using the Laplace Transforms:
- Discuss the Laplace transformation of (e.g., continuous, discontinuous, delta and convolution) functions
- Describe modeling problems with differential equations and present their solution methodology using Laplace transformations (use of CAS, Maple, Mathematica)
Describe the solution methodology for non-linear differential equations:
- Describe the concept of an equilibrium point
- Model with non-linear differential equations and present the phase-portrait analysis Understand and demonstrate how chaos is generated in the solution process of non-linear differential equations
Describe the solution methodology for non-linear difference equations:
- Describe the method of linearization
- Describe the concepts of Logistic and Henon Maps
- Model with non-linear difference equations and demonstrate understanding of fundamental concepts from Bifurcation theory (e.g., fixed, periodic points, chaos)
- Describe techniques for controlling chaos
- Understand concepts of numerical accuracy applied to each solution approach

Area 4: Numerical Methods

Understand number representation and computer errors:
- Understand the pros and cons of floating point and integer arithmetic
- Describe various kinds of computing errors (e.g., round-off, chopping)
- Describe absolute, relative error and percent error
- Discuss error propagation
- Describe loss of significance - methods to avoid loss of significance
Analyze methods for solving non-linear equations:
- Discuss and contrast fixed point methods (e.g., bisection, secant, Newton's) for a single equation
- Describe a fixed point method for a system of equations (e.g., Newton's)
Describe techniques for solving systems of linear equations:
- Describe the naive Gauss elimination and the partial pivoting method
- Understand the concepts of condition number and ill-conditioning problems
- Discuss and contrast factorization methods (e.g., LU, QR, Cholesky, SVD)
- Discuss and contrast iterative methods (e.g., Jacobi, Gauss Siedel)
- Describe convergence and stopping criteria of iterative methods
Analyze techniques for computing eigenvalues/eigenvectors (Optional):
- Describe and give examples of eigenvalue/eigenvector problems using specific, applied examples and their significance
- Describe canonical forms of matrices
- Describe and contrast direct methods for computing eigenvalues (e.g., power method, inverse power method)
- Describe and contrast transformation methods (e.g., QR algorithm)
Describe interpolation and approximation methods:
- Describe and contrast interpolation methods (e.g., Lagrange, Chebyshev, FFT)
- Describe interpolation with spline functions (e.g., piecewise linear, quadratic, natural cubic)
- Discuss approximation using the method of least squares (linear vs. non-linear)
Describe numerical methods for Ordinary Differential Equations:
- Describe and compare basic methods for IVPs (e.g., Euler, Taylor, Runge-Kutta)
- Describe and compare predictor-corrector methods
- Describe and compare multistep methods
- Discuss and contrast numerical methods for BVPs (e.g., shooting method, finite difference method)
- Compare the accuracy, memory requirements, and precision of each of the approaches
Describe numerical methods for Partial Differential Equations:
- Describe and compare numerical methods for parabolic PDEs (e.g., finite difference, Crank-Nicolson)
- Describe numerical methods for hyperbolic PDEs
- Describe numerical methods for elliptic PDEs (e.g. finite difference, Gauss- Seidel)
- Discuss the finite element method for solving PDEs
- Describe Monte Carlo Methods
- Describe applications of Monte Carlo models with examples Discuss algorithms for Monte Carlo methods

Area 5: Optimization

Describe and use Optimization techniques:
- Describe and contrast unconstrained optimization methods (e.g., Golden section search, Steepest descent, Newton's method, conjugate gradient, simulated annealing, genetic algorithms)
- Describe and contrast constrained optimization methods (e.g., Lagrange multiplier, quasi-Newton, penalty function method
Implement linear and non-linear programs:
- Analyze linear programming methods (e.g., simplex method)
- Describe non-linear programming methods (e.g., interior, exterior, mixed methods)
- Demonstrate ability to correctly use software systems (e.g., Matlab, IMSL, NAG) to solve practical optimization problems

Area 6: Parallel Programming

Describe the fundamental concepts of parallel programming and related architectures:
- Describe the differences between distributed and shared memory architectures
- Describe the difference between domain and functional decomposition in parallel
- Describe a parallel programming approach to an introductory problem
- Compare parallel, distributed, and grid computing concepts
Demonstrate parallel programming concepts using MPI:
- Describe the MPI programming model
- Create, compile, and run an MPI parallel program
- Create MPI programs that utilize point-to-point communications
- Create an MPI program that uses point-to-point blocking communications
- Create an MPI program that uses point-to-point non-blocking communications
- Create an MPI program that uses collective communications
- Create an MPI programs that use parallel I/O
- Create MPI programs that use derived data types
- Create MPI programs that use vector derived data type
- Create MPI programs that use structure derived data type
Demonstrate knowledge of parallel scalability:
- Use mathematical formulas to determine speed-up and efficiency metrics for a parallel algorithm
- Demonstrate the use of graphical systems such as MATLAB to display speed-up and efficiency graphs
Demonstrate knowledge of parallel programming libraries and tools:
- Demonstrate the use of performance tools for profiling programs (e.g., GNU GPROF or MATLAB profiler)
- Create parallel programs with calls to parallel libraries (e.g. BLAS, BLACS, ScaLAPACK or FFTW)
- Demonstrate the use of MPI tracing tools (e.g., VAMPIR) to determine parallel performance bottlenecks

Area 7: Scientific Visualization

Define SciVis needs; relationships to human visualization; basic techniques:
- Define Scientific Visualization (Sci Vis)
- Discuss needs of SciVis (in the framework of a large variety of possible application areas)
- Survey different platforms for Visualization (e.g. AVS, VTK, OpenGL, VRLM)
- Discuss the different techniques and visualization methods used in SciVis
- Explain the human visualization system capabilities and perceptions
- Explain the different steps in the visualization pipeline
- Discuss different sources of data for SciVis and explain the terms applied to data types (i.e. scalar, vector, normal, tensor)
- Discuss different types of grids (e.g., regular vs. irregular grids)
- Discuss the different methods used to gather data
- Describe and explore the use of different file formats for sharing data (netCDF, XML, TIFF, GIF, JPEG, Wavefront OBJ)
- Discuss limitations of different methods
- Discuss future applications in emerging fields
- Metadata needs for graphics libraries
Overview of computer graphic concepts:
- Overview of SciVis concepts (pixels, rgb colors, 3D coordinate system, mapping 3D data to a 2Dscreen, continuous vs. discrete)
- Discuss polygonal representation
- Discuss lighting/shading
- Overview of classification/segmentation and transfer functions
- Discuss concept of rendering pipeline (no details about matrices)
- Discuss hardware rendering (mainly for polygonal models, few specialized volumetric hardware cards)
- Identify terms used in virtual space and in graphics elements
- Navigate in virtual space and manipulate primitive objects
- Explore colormaps and examine conceptual definitions for different color maps (pertaining to color spaces HSV, RGB, etc.) as related to representing data and relationships to perception
Describe approaches to visualization for different scientific problems:
- Examine different computational solutions to scientific problems
- Explain the different techniques used in visualization (i.e. glyphs, iso-contours, streamlines, image processing, volume-data)
- Examine the application of problems to visualization techniques
- Utilize software tools to implement visual image of a solution
- Discuss the use of time in animation
Utilize software to implement grid representations of data:
- Identify the various cell representations (i.e. points, polygons, 3d geometries)
- Discuss the application to different grid types (i.e. structured, unstructured, random)
- Discuss raycasting methods and texture mapping
- Examine the details of raycasting sampling FAT (low-resolution sampling), interpolation techniques)
- Examine algorithms: Direct Composite, SFP, use of transparency
- Identify the grid representation and data (color reps.) (regular grids, 1, 8, 24 and 32 bit color information)
- Discuss algorithms for manipulating images, distortion, fft's, enhancement, restoration, and frequency domains
- Utilize software to implement different grid types
- Discuss limitations of grids
Use visualization software to display an isosurface:
- Discuss different data types used: scalar vs. vector data
- Discuss the different grid types
- Discuss the different algorithms (Marching Cubes, etc.)
- Introduce details of the system being used in a course (e.g., VTK, AVS, etc.)
- Apply the system to extract and display an isosurface of some data set (could be tailored towards the teacher's and student's interests/application areas)
- Discuss limitations of these methods
Use visualization software to complete a volumetric rendering:
- Discuss direct volumetric rendering (raycasting and texture mapping) and its advantages/disadvantages vs. surface rendering
- Discuss segmentation/classification and transfer functions
- Discuss and illustrate how to use a system (VTK, AVS, etc.) to do volumetric rendering)
- Using the system, visualize a data set using raycasting
- Using the system, visualize a data set using texture mapping
- Discuss limitations of this method
Utilize visualization software to visualize a vector dataset:
- Discuss vector data
- Discuss different methods for vector visualizing (particles, stream ribbons, vector glyphs, etc.)
- Discuss the use of structured grid types: (ir)regular, cylindrical, spherical Discuss application areas for vector visualization (air flow, etc.)
- Using a system (VTK, AVS, etc.), visualize a vector data set
- Discuss limitations of this method
Explore examples of image processing:
- Discuss basic steps and goals in image processing
- Discuss variety of data sources of images and how they can be represented
- Discuss algorithms used for image processing
- Explore examples of image processing (e.g., noise reduction, image enhancement, feature extraction etc)
- Discuss challenges and limitations in image processing
Use advanced techniques applied to a real problem:
- To be chosen by instructor based on instructor/student interest. Among suggested topics are:
  - visualizing an irregular grid
  - visualizing a data set specific to the area of interest (see 3.2 and 3.3 for specific examples)
  - writing a segmentation tool
  - implementing a visualization algorithm from scratch (such as marching cubes or raycasting)
Examine SciVis problems for Biological Sciences "OMICS" applications:
- Examine different problems existing in OMICS sciences that require visualization solution (overview)
- Discuss challenges of representing biomedical/biological data (i.e., representing protein structure or genomic sequence with all their attributes as a visual metaphor)
- Discuss challenges associated with visualization of scattered data such as text information and bioinformatics data (e.g., phylogenetic information)
- Gene finding in genomic sequences
  - Examine different components of a gene structure
  - Visualize genomic structure of an individual gene
  - Build a comparison between genomic features from several genomes
    - Visualize (and examine) similarities and differences
    - Discuss goal-dependent options of parsing the results to be explored elsewhere (e.g., as plain text, XML-marked)
- Protein folding and protein structure prediction
  - Discuss the differences between protein folding and protein structure prediction
  - Explore different methods used in protein folding and structure prediction
  - Apply different methods of protein structure prediction and compare the results
  - Construct, visualize and examine structure-based protein alignment
  - Biological networks (e.g., protein-protein or protein-DNA interaction networks)
  - Visualization of various types of expression data
  - Discuss and contrast different types of expression data e.g., microarray gene expression data, protein expression data
  - Discuss different visualization (and analyses) techniques used for expression data
  - Apply (and compare outcomes) hierarchical clustering and k- means clustering to the same gene microarray expression data
  - Discuss pros and cons of different clustering methods, their shortcomings, and ways to access the quality of clusters
- Discuss potential applications of SciVis techniques in biomedical and drug design fields
- Utilize MATLAB to implement/solve the above problems
Explore SciVis techniques in BioMedical applications:
- Explore a variety of biomedical applications of SciVis to explore large datasets such as MRI and confocal microscopy data
- Overview of volume visualization techniques in biomedical problems
- Examine and different ways MRI (Magnetic Resonance Imaging) data can be visualized (e.g., 2-D image versus isocontour slices)
- Discuss potential applications (interpretation) of each of the techniques
- Utilize software tools (MATLAB, VTK) to apply the techniques above