1 Motivating Questions. 2 An Illustrating Example. 3 Software Quality. 4 An Example of OOP

Size: px

Start display at page:

Download "1 Motivating Questions. 2 An Illustrating Example. 3 Software Quality. 4 An Example of OOP"

Bonnie Watts
6 years ago
Views:

1 Qinghai Zhang An Introduction to Software Engineering for Mathematicians 2014-SEP-30 1 Motivating Questions Q1. What is math? Q2. Why do we care about math? Q3. What is software and software engineering? Q4. Why do we care about software engineering? 2 An Illustrating Example Consider numerically solving the diffusion equation φ t = f(x, t) + ν 2 φ, (1) on a rectangular domain Ω R D, where u is a given velocity field and f a given forcing term. The initial condition is φ(x, t) = φ 0 (x) and the boundary condition is Dirichlet, Neumann, Robin, or a mixed one of the above. The problem domain Ω is discretized into square control volumes, each of which denoted by a multi-index i Z D ; the region of cell i is represented by C i := [ x O + ih, x O + (i + 1) h ], (2) where x O is some fixed origin of the coordinates, h the uniform grid size, and 1 Z D the multi-index with all its components equal to one. The averaged φ over cell i is denoted by φ i := 1 h D φ (x) dx. (3) C i A fourth-order finite-volume discretization of the Laplacian is L φ i = 2 φ C i + O(h 4 ) with L φ i := 1 ( 12h 2 d φ i+2e d + 16 φ i+e d (4) 30 φ i + 16 φ i e d φ i 2e d where e d Z D is a multi-index with 1 as its d-th component and 0 otherwise. Integrating (1) and applying (3) and (4) yield a system of ODEs that approximates (1) within O(h 4 ): d φ dt ), = L φ + f(t), (5) for which we can use the method of lines to advance the solution for each time step. For example, an implicitexplicit (IMEX) scheme has the following steps: for s = 1, 2,, n s, n s φ (s) = φ n + k a [E] s,j (t f (j)) n s + k a [I] s,j (φ L (j), t (j)), j=1 j=1 (6a) n s ( φ n+1 = φ n + k b [E] s f t (s)) n s ( + k b [I] s L φ (s), t (s)), s=1 s=1 (6b) where the superscript (s) denotes an intermediate stage, t (s) = t n + c s k the time of that stage, n s the number of stages, and A, b, c the standard coefficients of the Butcher tableau. 3 Software Quality S1. Correctness: perform the tasks as defined by their specifications; S2. Ease of use S3. Reusability: serve for the construction of many different applications; S4. Extendibility: easily adapt to changes of specifications; S5. Robustness: react appropriately to abnormal conditions; S6. Efficiency: place as few demands as possible on hardware resources to achieve a certain metric; S7. Compatibility: easily to be combined with others; S8. Portability: easily to be transferred to various hardware and software environments; 4 An Example of OOP Below is some pseudo-code illustrating the paradigm of object-oriented programming (OOP). LevelData data; data.define(xo, ncells, h); ScalarFunction initfunc; initfunc.setdata(data); ScalarFunction bcfunc; bcfunc.define(...); BoundaryCondition bc; bc.define("dirichlet", bcfunc); DiscreteLaplacian<4> lapl; 1

2 Qinghai Zhang An Introduction to Software Engineering for Mathematicians 2014-SEP-30 lapl.define(xo, ncells, h); ScalarFunction forcingfunc; forcingfunc.define(...); TimeIntegrator ti; ti.define("erk-esdirk", lapl, forcingfunc); for (int i=0; i<ntimesteps; i++) { Real t = t0 + i*dt; ti.timestep(data, t); } ti.report(data); Some real C++ code are also included at the end of this document. TimeIntegrator.H: interface class for time integrators. ExplicitRungeKutta.H: an concrete class capturing explicit Runge-Kutta methods. ExplicitRungeKutta.cpp: the definition of various explicit Runge-Kutta methods. 5 Some OOP principles 5.1 Abstraction 5.2 Encapsulation 5.3 Inheritance: reusing the interface 5.4 Polymorphism: interchanging objects 6 Testing T1. unit tests; T2. acceptance test. 7 Debugging D1. a NP-complete problem; D2. use patterns to avoid cross-level bugs; D3. search by bisections. 2

3 File: /home/tsinghai/dao/src/timeintegrators/timeintegrator.h Page 1 of 1 1 #ifndef _TIMEINTEGRATOR_H_ 2 #define _TIMEINTEGRATOR_H_ /** 6 * Abstract base interface for time integrators. 7 * F is either FArrayBox or FluxBox 8 */ 9 template<class F> 10 class TimeIntegrator 11 { 12 public: virtual ~TimeIntegrator(){} virtual void updatetimestepsize(const Real& dt) = 0; /// 19 /// Advance one time step for the unknown. 20 /// 21 virtual void timestep(vector<leveldata<f>*>& U, Real time) = 0; }; #endif

4 File: /home/tsinghai/dao/src/timeintegrators/explicitrungekutta.h Page 1 of 3 1 #ifndef _EXPLICITRUNGEKUTTA_H_ 2 #define _EXPLICITRUNGEKUTTA_H_ 3 4 #include "BoundaryConditionFactory.H" 5 #include "HierarchyDataOps.H" 6 7 /// The list of implemented ERK methods. 8 enum ERK_Type 9 { 10 ForwardEuler=1, 11 ClassicRK4, 12 nerk_type 13 }; /// The compile time constants of orders-of-accuracy 16 template<erk_type Type> 17 struct ERK_Order; template<> 20 struct ERK_Order<ForwardEuler> 21 { 22 enum {val=1}; 23 }; template<> 26 struct ERK_Order<ClassicRK4> 27 { 28 enum {val=4}; 29 }; /// The compile time constants of numbers of stages 32 template<erk_type Type> 33 struct ERK_NumStages; template<> 36 struct ERK_NumStages<ForwardEuler> 37 { 38 enum {val=1}; 39 }; template<> 42 struct ERK_NumStages<ClassicRK4> 43 { 44 enum {val=4}; 45 }; /// The Butcher Tableau of ERK methods 49 template <ERK_Type Type> 50 struct ERK_ButcherTableau 51 { 52 static const int ns = ERK_NumStages<Type>::val; 53 // The first nstages numbers are the nominators 54 // while the last one their common denominator. 55 static const int a[ns][ns+1]; 56 static const int b[ns+1]; 57 static const int c[ns+1]; 58 }; /// default ERK methods for different orders-of-accuracy. 61 template<unsigned int Order> 62 struct ERK_DefaultMethods; template<> 65 struct ERK_DefaultMethods<1> 66 { 67 enum {val=forwardeuler}; 68 }; template<> 71 struct ERK_DefaultMethods<4> 72 { 73 enum {val=classicrk4}; 74 };

5 File: /home/tsinghai/dao/src/timeintegrators/explicitrungekutta.h Page 2 of /** 78 * This class encapsulates timestepping algorithms 79 * of an ERK (explicit Runge-Kutta) method. 80 * To implement a new ERK method, 81 * all one needs to do is to 82 * (1) add a new key to the enumerations in ERK_Type; 83 * (2) set its order with template specialization of ERK_Order; 84 * (3) set its # of stages with template specialization of ERK_NumStages; 85 * (4) specify its Butcher tableau in ExplicitRungeKutta.cpp. 86 * In other words, the following class stays the same 87 * if the ERK method can be expressed with a single Butcher tableau. 88 */ template<erk_type Type, /// The type of the ERK method 91 class F, /// FArrayBox or FluxBox? 92 class EOS> /// Equation Op strategies 93 class ExplicitRungeKutta 94 { 95 public: /// type acronyms 98 typedef BoundaryConditionBase BCB; 99 typedef RefCountedPtr<BCB> BCP; 100 typedef ERK_ButcherTableau<Type> ERC; 101 typedef HierarchyDataOps HOP; 102 typedef Vector<LevelData<F>*> VLF; 103 typedef Vector<Vector<LevelData<F>*> > VVL; static const int nstages = ERC::nS; 106 /// gamma is never used, just for interface uniformality 107 static const int gamma = 1; void define(const Real& dx, const Vector<int>& refv, const BCP phibc) 110 { 111 m_dx = dx; 112 m_refv = refv; 113 m_phibc = phibc; 114 // initialize the Butcher arrays from ERC 115 a.resize(nstages); 116 for (int i=0; i<a.size(); i++) 117 a[i].resize(nstages); 118 b.resize(nstages); 119 c.resize(nstages); 120 for (int i=0; i<a.size(); i++) 121 { 122 for (int j=0; j<a[i].size(); j++) 123 a[i][j] = static_cast<real>(erc::a[i][j])/erc::a[i][erc::ns]; 124 b[i] = static_cast<real>(erc::b[i])/erc::b[erc::ns]; 125 c[i] = static_cast<real>(erc::c[i])/erc::c[erc::ns]; 126 } 127 } /// 131 /// Advance one time step for the unknown. 132 /// The container imp here is intended for interface uniformity 133 /// and never used. 134 /// 135 void timestep(const Real& time, const Real& dt, 136 VLF& u, VVL& phi, VVL& exp, VVL& imp, EOS& eos) 137 { 138 for (int s=0; s<nstages; s++) 139 HOP::assign(phi[s], u); // Loop over all the stages 142 for (int ns=0; ns<nstages; ns++) 143 { 144 pout() << " ERK stage: " << ns+1 << endl; 145 for (int j=0; j<ns; j++) 146 { 147 HOP::incr(phi[ns], exp[j], a[ns][j]*dt); 148 }

6 File: /home/tsinghai/dao/src/timeintegrators/explicitrungekutta.h Page 3 of // The current intermediate time 151 const Real ts = time + c[ns]*dt; 152 m_phibc->settime(ts); 153 eos.computeoperators(phi[ns], exp[ns], imp[ns], ts); 154 // add results of implicit operators to explicit results 155 // since we are using explicit Runge-Kutta methods. 156 HOP::incr(exp[ns], imp[ns], 1.0); 157 eos.stagesteppostprocessing(phi[ns], ts); 158 } // calculate the results of the final stage 161 HOP::assign(u, phi[0]); 162 for (int s=0; s<nstages; s++) 163 HOP::incr(u, exp[s], b[s]*dt); 164 HOP::checkData(*u[0]); // set BC of u for other operators like vorticity. 167 m_phibc->fillghostcells(u, m_dx, m_refv, false); // false: homogeneous 168 } private: // The Butcher arrays from ERC 174 Vector<Vector<Real> > a; 175 Vector<Real> b; 176 Vector<Real> c; BCP m_phibc; 179 Real m_dx; 180 Vector<int> m_refv; 181 }; #endif

7 File: /home/tsinghai/dao/src/timein grators/explicitrungekutta.cpp Page 1 of 1 1 #include "ExplicitRungeKutta.H" 2 3 /// /// Butcher tableau of the forward Euler method 5 /// template<> 7 const int ERK_ButcherTableau<ForwardEuler>::a[][2] = 8 { 9 {0, 1} 10 }; template<> 13 const int ERK_ButcherTableau<ForwardEuler>::b[] = 14 { 15 1, 1 16 }; template<> 19 const int ERK_ButcherTableau<ForwardEuler>::c[] = 20 { 21 0, 1 22 }; /// /// Butcher tableau of the fourth-order Runge-Kutta method 27 /// template<> 29 const int ERK_ButcherTableau<ClassicRK4>::a[][5] = 30 { 31 {0, 0, 0, 0, 1}, 32 {1, 0, 0, 0, 2}, 33 {0, 1, 0, 0, 2}, 34 {0, 0, 1, 0, 1} 35 }; template<> 38 const int ERK_ButcherTableau<ClassicRK4>::b[] = 39 { 40 1, 2, 2, 1, 6 41 }; template<> 44 const int ERK_ButcherTableau<ClassicRK4>::c[] = 45 { 46 0, 1, 1, 2, 2 47 };

Queens College, CUNY, Department of Computer Science Numerical Methods CSCI 361 / 761 Spring 2018 Instructor: Dr. Sateesh Mane.

Queens College, CUNY, Department of Computer Science Numerical Methods CSCI 361 / 761 Spring 2018 Instructor: Dr. Sateesh Mane c Sateesh R. Mane 2018 16 Lecture 16 May 3, 2018 Numerical solution of systems