Cover image
Normal view MARC view ISBD view

Scientific software design : the object-oriented way /

by Rouson, Damian; Xia, Jim; Xu, Xiaofeng.
Publisher: New York : Cambridge University Press, 2011Description: xxii, 382 p. : ill. ; 26 cm.ISBN: 9780521888134 (hardback); 0521888131 (hardback).Subject(s): Science -- Data processing | Engineering -- Data processing | Software engineering
Contents:
Development Costs and Complexity -- Introduction -- Conventional Scientific Programming Costs -- Conventional Programming Complexity -- Alternative Programming Paradigms -- How Performance Informs Design -- How Design Informs Performance -- Elements of Style -- The Object-Oriented Way -- Nomenclature -- Object-Oriented Analysis and Design -- Encapsulation and Information Hiding -- Wrapping Legacy Software -- Composition, Aggregation, and Inheritance -- Static and Dynamic Polymorphism -- OOP Complexity -- More on Style -- Scientific OOP -- Abstract Data Type Calculus -- Analysis-Driven Design -- Design Metrics -- Complexity Theory -- Information Theory -- Still More on Style -- The Tao of SOOP
Design Patterns Basics -- Essentials -- Foundations -- Building Architecture -- Software Architecture -- Scientific Software Architecture -- Canonical Contexts -- The Lorenz Equations: A Chaotic Dynamical System -- Quantum Vortex Dynamics in a Superfluid -- Burgers' Equation: Shock Formation and Dissipation -- The Object Pattern -- The Problem -- The Solution -- Fortran Implementation -- C++ Style and Tools -- C++ Implementation of Vortex -- The Consequences -- Related Patterns -- The Abstract Calculus Pattern -- The Problem -- The Solution -- Fortran Implementation -- C++ Implementation -- The Consequences -- Related Patterns -- The Strategy and Surrogate Patterns -- The Problem -- The Solution -- Fortran Implementation -- C++ Implementation
The Consequences -- Related Patterns -- The Puppeteer Pattern -- The Problem -- The Solution -- Fortran Implementation -- A C++ Tool: 2D Allocatable Arrays -- C++ Implementation -- The Consequences -- Related Patterns -- Factory Patterns -- The Problem -- The Solution -- Fortran Implementation -- C++ Implementation -- The Consequences -- Related Patterns -- Formal Constraints -- Why Be Formal? -- Problem Statement -- Side Effects in Abstract Calculus -- Formal Specification -- Modeling Arrays with OCL -- Hermeticity -- Economy -- The Shell Pattern -- An Assertion Utility for Fortran -- Case Study: A Fluid Turbulence Solver -- Mixed-Language Programming -- Automated Interoperability Tools -- Manual Interoperability: C++/Fortran 95
Case Study: ForTrilinos and CTrilinos -- C Interoperability in Fortran 2003 -- Method Invocation -- Tabulation, Construction, and Destruction -- Polymorphism and Hierarchy Mirroring -- Discussion -- Multiphysics Architectures -- Toward a Scalable Abstract Calculus -- Amdahl's Law and Parallel Efficiency -- Automatic Parallelization: Compiler Technology -- Directive-Based Parallelization: OpenMP -- Library-Based Parallelization: ForTrilinos and MPI -- Intrinsic Parallelization: Fortran 2008 Coarrays -- Case Studies: Multiphysics Modeling -- Quantum Turbulence in Superfluid Liquid Helium -- Lattice-Boltzman Biofluid Dynamics -- Particle Dispersion in Magnetohydrodynamics -- Radar Scattering in the Atmospheric Boundary Layer -- The Morfeus Framework -- Interpolation
Lagrange Interpolation -- Linear Solvers -- Gaussian Elimination -- LU Decomposition -- Nonlinear Solvers -- Newton's Method in 1D -- Newton's Method in Multiple Dimensions -- Partial Differential Equations -- The Heat Equation -- The Burgers Equation -- Numerical Analysis -- Finite Differences -- Numerical Methods for Differential Equations -- Use Case Diagrams -- Class Diagrams -- Classes -- Relationships -- Object Diagrams -- Sequence Diagrams -- Interactions and Messages -- Sequence Diagrams -- The Object Constraint Language -- The Context of OCL Expression -- Initial Value Rule -- Specifying Object Invariants -- Adding Pre- and Postconditions to Operations.
Summary: "This book concerns software design. Although many current discussions of scientific programming focus on scalable performance, this book focuses on scalable design. The authors analyze how the structure of a package determines its developmental complexity according to such measures as bug search times and documentation information content. The work presents arguments for why these issues impact solution cost and time more than does scalable performance. The final chapter explores the question of scalable execution and it shows how scalable design relates to scalable execution. The book's focus is on program organization, which has received considerable attention in the broader software engineering community, where graphical description standards for modeling software structure and behavior have been developed by computer scientists. These discussions might be enriched by engineers who write scientific codes. This book aims to bring such scientific programmers into discussion with computer scientists. The authors do so by introducing object-oriented software design patterns in the context of scientific simulation"--Provided by publisher.
Item type Location Call number Copy Status Date due
BOOK BOOK Foothills Lab Q183.9 .R68 2011 (Browse shelf) 1 Available
BOOK BOOK Foothills Lab Q183.9 .R68 2011 (Browse shelf) 2 Checked out 07/10/2014
BOOK BOOK Mesa Lab Q183.9 .R68 2011 (Browse shelf) 3 Available
BOOK BOOK Mesa Lab Q183.9 .R68 2011 (Browse shelf) 4 Available
BOOK BOOK Mesa Lab Q183.9 .R68 2011 (Browse shelf) 5 Checked out 07/13/2014

Includes bibliographical references (p. 373-378) and index.

"This book concerns software design. Although many current discussions of scientific programming focus on scalable performance, this book focuses on scalable design. The authors analyze how the structure of a package determines its developmental complexity according to such measures as bug search times and documentation information content. The work presents arguments for why these issues impact solution cost and time more than does scalable performance. The final chapter explores the question of scalable execution and it shows how scalable design relates to scalable execution. The book's focus is on program organization, which has received considerable attention in the broader software engineering community, where graphical description standards for modeling software structure and behavior have been developed by computer scientists. These discussions might be enriched by engineers who write scientific codes. This book aims to bring such scientific programmers into discussion with computer scientists. The authors do so by introducing object-oriented software design patterns in the context of scientific simulation"--Provided by publisher.

Machine generated contents note: 1. Development Costs and Complexity -- 1.1. Introduction -- 1.2. Conventional Scientific Programming Costs -- 1.3. Conventional Programming Complexity -- 1.4. Alternative Programming Paradigms -- 1.5. How Performance Informs Design -- 1.6. How Design Informs Performance -- 1.7. Elements of Style -- 2. The Object-Oriented Way -- 2.1. Nomenclature -- 2.2. Object-Oriented Analysis and Design -- 2.3. Encapsulation and Information Hiding -- 2.4. Wrapping Legacy Software -- 2.5. Composition, Aggregation, and Inheritance -- 2.6. Static and Dynamic Polymorphism -- 2.7. OOP Complexity -- 2.8. More on Style -- 3. Scientific OOP -- 3.1. Abstract Data Type Calculus -- 3.2. Analysis-Driven Design -- 3.2.1. Design Metrics -- 3.2.2. Complexity Theory -- 3.2.3. Information Theory -- 3.3. Still More on Style -- 3.4. The Tao of SOOP

4. Design Patterns Basics -- 4.1. Essentials -- 4.2. Foundations -- 4.2.1. Building Architecture -- 4.2.2. Software Architecture -- 4.2.3. Scientific Software Architecture -- 4.3. Canonical Contexts -- 4.3.1. The Lorenz Equations: A Chaotic Dynamical System -- 4.3.2. Quantum Vortex Dynamics in a Superfluid -- 4.3.3. Burgers' Equation: Shock Formation and Dissipation -- 5. The Object Pattern -- 5.1. The Problem -- 5.2. The Solution -- 5.2.1. Fortran Implementation -- 5.2.2. C++ Style and Tools -- 5.2.3. C++ Implementation of Vortex -- 5.3. The Consequences -- 5.4. Related Patterns -- 6. The Abstract Calculus Pattern -- 6.1. The Problem -- 6.2. The Solution -- 6.2.1. Fortran Implementation -- 6.2.2. C++ Implementation -- 6.3. The Consequences -- 6.4. Related Patterns -- 7. The Strategy and Surrogate Patterns -- 7.1. The Problem -- 7.2. The Solution -- 7.2.1. Fortran Implementation -- 7.2.2. C++ Implementation

7.3. The Consequences -- 7.4. Related Patterns -- 8. The Puppeteer Pattern -- 8.1. The Problem -- 8.2. The Solution -- 8.2.1. Fortran Implementation -- 8.2.2. A C++ Tool: 2D Allocatable Arrays -- 8.2.3. C++ Implementation -- 8.3. The Consequences -- 8.4. Related Patterns -- 9. Factory Patterns -- 9.1. The Problem -- 9.2. The Solution -- 9.2.1. Fortran Implementation -- 9.2.2. C++ Implementation -- 9.3. The Consequences -- 9.4. Related Patterns -- 10. Formal Constraints -- 10.1. Why Be Formal? -- 10.2. Problem Statement -- 10.3. Side Effects in Abstract Calculus -- 10.4. Formal Specification -- 10.4.1. Modeling Arrays with OCL -- 10.4.2. Hermeticity -- 10.4.3. Economy -- 10.5. The Shell Pattern -- 10.6. An Assertion Utility for Fortran -- 10.7. Case Study: A Fluid Turbulence Solver -- 11. Mixed-Language Programming -- 11.1. Automated Interoperability Tools -- 11.2. Manual Interoperability: C++/Fortran 95

11.3. Case Study: ForTrilinos and CTrilinos -- 11.3.1. C Interoperability in Fortran 2003 -- 11.3.2. Method Invocation -- 11.3.3. Tabulation, Construction, and Destruction -- 11.3.4. Polymorphism and Hierarchy Mirroring -- 11.3.5. Discussion -- 12. Multiphysics Architectures -- 12.1. Toward a Scalable Abstract Calculus -- 12.1.1. Amdahl's Law and Parallel Efficiency -- 12.1.2. Automatic Parallelization: Compiler Technology -- 12.1.3. Directive-Based Parallelization: OpenMP -- 12.1.4. Library-Based Parallelization: ForTrilinos and MPI -- 12.1.5. Intrinsic Parallelization: Fortran 2008 Coarrays -- 12.2. Case Studies: Multiphysics Modeling -- 12.2.1. Quantum Turbulence in Superfluid Liquid Helium -- 12.2.2. Lattice-Boltzman Biofluid Dynamics -- 12.2.3. Particle Dispersion in Magnetohydrodynamics -- 12.2.4. Radar Scattering in the Atmospheric Boundary Layer -- 12.3. The Morfeus Framework -- A.1. Interpolation

A.1.1. Lagrange Interpolation -- A.2. Linear Solvers -- A.2.1. Gaussian Elimination -- A.2.2. LU Decomposition -- A.3. Nonlinear Solvers -- A.3.1. Newton's Method in 1D -- A.3.2. Newton's Method in Multiple Dimensions -- A.4. Partial Differential Equations -- A.4.1. The Heat Equation -- A.4.2. The Burgers Equation -- A.5. Numerical Analysis -- A.5.1. Finite Differences -- A.5.2. Numerical Methods for Differential Equations -- B.1. Use Case Diagrams -- B.2. Class Diagrams -- B.2.1. Classes -- B.2.2. Relationships -- B.3. Object Diagrams -- B.4. Sequence Diagrams -- B.4.1. Interactions and Messages -- B.4.2. Sequence Diagrams -- B.5. The Object Constraint Language -- B.5.1. The Context of OCL Expression -- B.5.2. Initial Value Rule -- B.5.3. Specifying Object Invariants -- B.5.4. Adding Pre- and Postconditions to Operations.

Any questions? Ask a Librarian.

Not finding what you are looking for? Request-It - InterLibrary Loan.

Languages: