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
©1994-2014   |   Shodor   |   Privacy Policy   |   NSDL   |   XSEDE   |   Blue Waters   |   ACM SIGHPC   |   feedback  |   facebook   |   twitter   |   rss   |   youtube Not Logged In. Login