epanet-plus 0.0.1__cp310-cp310-macosx_10_9_x86_64.whl

epanet-msx-src/newton.c

@@ -0,0 +1,158 @@
+/******************************************************************************
+**  MODULE:        NEWTON.C
+**  PROJECT:       EPANET-MSX
+**  DESCRIPTION:   Newton-Raphson algorithm used to solve a set of nonlinear
+**                 algebraic equations.
+**  AUTHORS:       see AUTHORS
+**  Copyright:     see AUTHORS
+**  License:       see LICENSE
+**  VERSION:       2.0.00
+**  LAST UPDATE:   04/14/2021
+******************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include "msxutils.h"
+#include "newton.h"
+
+// Local declarations
+//-------------------
+MSXNewton MSXNewtonSolver;
+
+#pragma omp threadprivate(MSXNewtonSolver)
+
+//=============================================================================
+
+int newton_open(int n)
+/*
+**  Purpose:
+**    opens the algebraic solver to handle a system of n equations.
+**
+**  Input:
+**    n = number of equations
+**
+**  Returns:
+**    1 if successful, 0 if not.
+**
+**  Note:
+**    All arrays are 1-based so an extra memory location
+**    must be allocated for the unused 0-th position.
+*/
+{
+    int errorcode = 1;
+
+#pragma omp parallel
+{
+    MSXNewtonSolver.Nmax = 0;
+    MSXNewtonSolver.Indx = NULL;
+    MSXNewtonSolver.F = NULL;
+    MSXNewtonSolver.W = NULL;
+    MSXNewtonSolver.Indx = (int*)calloc(n + 1, sizeof(int));
+    MSXNewtonSolver.F = (double*)calloc(n + 1, sizeof(double));
+    MSXNewtonSolver.W = (double*)calloc(n + 1, sizeof(double));
+    MSXNewtonSolver.J = createMatrix(n + 1, n + 1);
+#pragma omp critical
+    {
+        if (!MSXNewtonSolver.Indx || !MSXNewtonSolver.F || !MSXNewtonSolver.W || !MSXNewtonSolver.J) 
+            errorcode = 0;
+    }
+    MSXNewtonSolver.Nmax = n;
+}
+
+    return errorcode;
+}
+
+//=============================================================================
+
+void newton_close()
+/*
+**  Purpose:
+**    closes the algebraic solver.
+**
+**  Input:
+**    none
+*/
+{
+
+#pragma omp parallel
+{
+    if (MSXNewtonSolver.Indx) { free(MSXNewtonSolver.Indx); MSXNewtonSolver.Indx = NULL; }
+    if (MSXNewtonSolver.F) { free(MSXNewtonSolver.F); MSXNewtonSolver.F = NULL; }
+    if (MSXNewtonSolver.W) { free(MSXNewtonSolver.W); MSXNewtonSolver.W = NULL; }
+    freeMatrix(MSXNewtonSolver.J);
+    MSXNewtonSolver.J = NULL;
+}
+
+}
+
+//=============================================================================
+
+int newton_solve(double x[], int n, int maxit, int numsig, 
+                 void (*func)(double, double*, int, double*))
+/*
+**  Purpose:
+**    uses newton-raphson iterations to solve n nonlinear eqns.
+**
+**  Input:
+**    x[] = solution vector
+**    n = number of equations
+**    maxit = max. number of iterations allowed
+**    numsig = number of significant digits in error
+**    func = pointer to the function that returns the function values at x.
+**
+**  Returns:
+**    number of iterations if successful, -1 if Jacobian is singular,
+**    -2 if it didn't converge, or -3 if n exceeds allowable size.
+**
+**  Note:
+**    the arguments to the function func are:
+**      t = a time value (not used here)
+**      x = vector of unknowns being solved for
+**      n = number of unknowns
+**      f = vector of function values evaluated at x.
+*/
+{
+    int i, k;
+	double errx, errmax, cscal, relconvg = pow(10.0, -numsig);
+
+    // --- check that system was sized adequetely
+
+    if ( n > MSXNewtonSolver.Nmax ) return -3;
+
+    // --- use up to maxit iterations to find a solution
+
+	for (k=1; k<=maxit; k++) 
+	{
+        // --- evaluate the Jacobian matrix
+
+        jacobian(x, n, MSXNewtonSolver.F, MSXNewtonSolver.W, MSXNewtonSolver.J, func);
+
+        // --- factorize the Jacobian
+
+        if ( !factorize(MSXNewtonSolver.J, n, MSXNewtonSolver.W, MSXNewtonSolver.Indx) ) return -1;
+
+        // --- solve for the updates to x (returned in F)
+
+		for (i=1; i<=n; i++) MSXNewtonSolver.F[i] = -MSXNewtonSolver.F[i];
+        solve(MSXNewtonSolver.J, n, MSXNewtonSolver.Indx, MSXNewtonSolver.F);
+		
+		// --- update solution x & check for convergence
+
+        errmax = 0.0;
+        for (i=1; i<=n; i++)
+        {
+			cscal = x[i];
+            if (cscal < relconvg) cscal = relconvg;
+			x[i] += MSXNewtonSolver.F[i];
+            errx = fabs(MSXNewtonSolver.F[i]/cscal);
+            if (errx > errmax) errmax = errx;
+        }
+		if (errmax <= relconvg) return k;
+	}
+
+    // --- return error code if no convergence
+
+	return -2;
+}

epanet-msx-src/newton.h

@@ -0,0 +1,34 @@
+/******************************************************************************
+**  MODULE:        NEWTON.H
+**  PROJECT:       EPANET-MSX
+**  DESCRIPTION:   header file for the equation solver contained in newton.c.
+**  AUTHORS:       see AUTHORS
+**  Copyright:     see AUTHORS
+**  License:       see LICENSE
+**  VERSION:       2.0.00
+**  LAST UPDATE:   04/14/2021
+******************************************************************************/
+
+#ifndef NEWTON_H
+#define NEWTON_H
+
+typedef struct
+{
+    int      Nmax;          // max. number of equations
+    int* Indx;         // permutation vector of row indexes     
+    double* F;            // function & adjustment vector
+    double* W;            // work vector
+    double** J;           // Jacobian matrix
+}MSXNewton;
+
+// Opens the equation solver system
+int  newton_open(int n);
+
+// Closes the equation solver system
+void newton_close(void);
+
+// Applies the solver to a specific system of equations
+int  newton_solve(double x[], int n, int maxit, int numsig,  
+                  void (*func)(double, double*, int, double*));
+
+#endif

epanet-msx-src/rk5.c

@@ -0,0 +1,287 @@
+/************************************************************************
+**  MODULE:        RK5.C
+**  PROJECT:       EPANET-MSX
+**  DESCRIPTION:   Numerical solution of a system of first order
+**                 ordinary differential equations dY/dt = F(t,Y).
+**  AUTHOR:        L. Rossman, US EPA - NRMRL
+**  VERSION:       2.0.00                                               
+**  LAST UPDATE:   04/14/2021
+**
+**  This is an explicit Runge-Kutta method of order (4)5  
+**  due to Dormand & Prince (with optional stepsize control).
+**  The code was adapted from the DOPRI5 code of E. Hairer
+**  and G. Wanner as described in:
+**    E. HAIRER, S.P. NORSETT AND G. WANNER, SOLVING ORDINARY
+**    DIFFERENTIAL EQUATIONS I. NONSTIFF PROBLEMS. 2ND EDITION.
+**    SPRINGER SERIES IN COMPUTATIONAL MATHEMATICS,
+**    SPRINGER-VERLAG (1993)               
+***********************************************************************/
+
+#include <stdlib.h>
+#include <math.h>
+#include "rk5.h"
+
+#define fmin(x,y) (((x)<=(y)) ? (x) : (y))     /* minimum of x and y    */
+#define fmax(x,y) (((x)>=(y)) ? (x) : (y))     /* maximum of x and y    */
+
+//  Local variables
+//-----------------
+MSXRungeKutta MSXRungeKuttaSolver;
+
+#pragma omp threadprivate(MSXRungeKuttaSolver)
+//=============================================================================
+
+int rk5_open(int n, int itmax, int adjust)
+/*
+**  Purpose:
+**    Opens the RK5 solver to solve system of n equations
+**
+**  Input:
+**    n = number of equtions
+**    itmax = maximum iterations allowed
+**    adjust = 1 if time step adjustment used, 0 if not
+**
+**  Returns:
+**    1 if successful and 0 if not.
+*/
+{
+    int n1 = n+1;
+    int errorcode = 1;
+    MSXRungeKuttaSolver.Report = NULL;
+
+#pragma omp parallel
+{
+    MSXRungeKuttaSolver.Nmax = 0;
+    MSXRungeKuttaSolver.Itmax = itmax;
+    MSXRungeKuttaSolver.Adjust = adjust;
+    MSXRungeKuttaSolver.Ynew = (double*)calloc(n1, sizeof(double));
+    MSXRungeKuttaSolver.Ak = (double*)calloc(6 * n1, sizeof(double));
+#pragma omp critical
+    {
+         if (!MSXRungeKuttaSolver.Ynew || !MSXRungeKuttaSolver.Ak) errorcode = 0;
+    }
+
+    MSXRungeKuttaSolver.Nmax = n;
+    MSXRungeKuttaSolver.K1 = (MSXRungeKuttaSolver.Ak);
+    MSXRungeKuttaSolver.K2 = ((MSXRungeKuttaSolver.Ak)+(n1));
+    MSXRungeKuttaSolver.K3 = ((MSXRungeKuttaSolver.Ak)+(2 * n1));
+    MSXRungeKuttaSolver.K4 = ((MSXRungeKuttaSolver.Ak)+(3 * n1));
+    MSXRungeKuttaSolver.K5 = ((MSXRungeKuttaSolver.Ak)+(4 * n1));
+    MSXRungeKuttaSolver.K6 = ((MSXRungeKuttaSolver.Ak)+(5 * n1));
+}
+
+    return errorcode;
+}
+
+//=============================================================================
+
+void rk5_close()
+/*
+**  Purpose:
+**    Closes the RK5 solver.
+*/
+{
+
+#pragma omp parallel
+{
+    if (MSXRungeKuttaSolver.Ynew) free(MSXRungeKuttaSolver.Ynew);
+    MSXRungeKuttaSolver.Ynew = NULL;
+    if (MSXRungeKuttaSolver.Ak) free(MSXRungeKuttaSolver.Ak);
+    MSXRungeKuttaSolver.Ak = NULL;
+    MSXRungeKuttaSolver.Nmax = 0;
+    MSXRungeKuttaSolver.Report = NULL;
+}
+
+}
+
+//=============================================================================
+
+int rk5_integrate(double y[], int n, double t, double tnext,
+                  double* htry, double atol[], double rtol[],
+                  void (*func)(double, double*, int, double*))
+/*
+**  Purpose:
+**    Integrates system of equations dY/dt = F(t,Y) over a
+**    given interval.
+**
+**  Input:
+**    y[]    =  values of dependent variables at start of interval
+**    n      =  number of dependent variables
+**    t      =  value of independent variable at start of interval
+**    tnext  =  value of independent variable at end of interval
+**    htry   =  initial step size
+**    atol[] =  absolute error tolerance on each dependent variable
+**    rtol[] =  relative error tolerance on each dependent variable
+**    func   =  pointer to function that evaluates dY/dt at given
+**              values of t and Y.
+**
+**  Output:
+**    y[]    =  values of dependent variables at end of interval
+**    htry   =  last step size used
+**
+**  Returns:
+**    number of function evaluations if successful, -1 if not
+**    successful within Itmax iterations or -2 if step size
+**    shrinks to 0.
+*/ 
+{
+    double c2=0.20, c3=0.30, c4=0.80, c5=8.0/9.0;
+    double a21=0.20, a31=3.0/40.0, a32=9.0/40.0,
+           a41=44.0/45.0, a42=-56.0/15.0, a43=32.0/9.0,
+           a51=19372.0/6561.0, a52=-25360.0/2187.0, a53=64448.0/6561.0,
+           a54=-212.0/729.0, a61=9017.0/3168.0, a62=-355.0/33.0,
+           a63=46732.0/5247.0, a64=49.0/176.0, a65=-5103.0/18656.0,
+           a71=35.0/384.0, a73=500.0/1113.0, a74=125.0/192.0,
+           a75=-2187.0/6784.0, a76=11.0/84.0;
+    double e1=71.0/57600.0, e3=-71.0/16695.0, e4=71.0/1920.0,
+           e5=-17253.0/339200.0, e6=22.0/525.0, e7=-1.0/40.0;
+
+    double tnew, h, hmax, hnew, ytol, err, sk, fac, fac11 = 1.0;
+    int    i;
+
+// --- parameters for step size control
+
+    double UROUND = 2.3e-16;
+    double SAFE = 0.90;
+    double fac1 = 0.2;
+    double fac2 = 10.0;
+    double beta = 0.04;
+    double facold = 1.e-4;
+    double expo1 = 0.2 - beta*0.75;
+    double facc1 = 1.0/fac1;
+    double facc2 = 1.0/fac2;
+
+// --- various counters
+
+    int    nstep = 1;
+    int    nfcn  = 0;
+    int    naccpt = 0;
+    int    nrejct = 0;
+    int    reject = 0;
+    int    adjust = MSXRungeKuttaSolver.Adjust;
+
+// --- initial function evaluation
+
+    func(t, y, n, MSXRungeKuttaSolver.K1);
+    nfcn++;
+
+// --- initial step size
+    h = *htry;
+    hmax = tnext - t;
+    if (h == 0.0)
+    {
+        adjust = 1;
+        h = tnext - t;
+        for (i=1; i<=n; i++)
+        {
+            ytol = atol[i] + rtol[i]*fabs(y[i]);
+            if (MSXRungeKuttaSolver.K1[i] != 0.0)
+                h = fmin(h, (ytol/fabs(MSXRungeKuttaSolver.K1[i])));
+        }
+    }
+    h = fmax(1.e-8, h);
+
+// --- while not at end of time interval
+
+    while (t < tnext)
+    {
+    // --- check for zero step size
+        if (0.10*fabs(h) <= fabs(t)*UROUND) return -2;
+
+    // --- adjust step size if interval exceeded
+        if ((t + 1.01*h - tnext) > 0.0) h = tnext - t;
+
+        tnew = t + c2*h;
+        for (i=1; i<=n; i++)
+            MSXRungeKuttaSolver.Ynew[i] = y[i] + h*a21* MSXRungeKuttaSolver.K1[i];
+        func(tnew, MSXRungeKuttaSolver.Ynew, n, MSXRungeKuttaSolver.K2);
+
+        tnew = t + c3*h;
+        for (i=1; i<=n; i++)
+            MSXRungeKuttaSolver.Ynew[i] = y[i] + h*(a31* MSXRungeKuttaSolver.K1[i] + a32* MSXRungeKuttaSolver.K2[i]);
+        func(tnew, MSXRungeKuttaSolver.Ynew, n, MSXRungeKuttaSolver.K3);
+
+        tnew = t + c4*h;
+        for (i=1; i<=n; i++)
+            MSXRungeKuttaSolver.Ynew[i]=y[i] + h*(a41* MSXRungeKuttaSolver.K1[i] + a42* MSXRungeKuttaSolver.K2[i] + a43* MSXRungeKuttaSolver.K3[i]);
+        func(tnew, MSXRungeKuttaSolver.Ynew, n, MSXRungeKuttaSolver.K4);
+
+        tnew = t + c5*h;
+        for (i=1; i<=n; i++)
+            MSXRungeKuttaSolver.Ynew[i] = y[i] + h*(a51* MSXRungeKuttaSolver.K1[i] + a52* MSXRungeKuttaSolver.K2[i] + a53* MSXRungeKuttaSolver.K3[i]+a54* MSXRungeKuttaSolver.K4[i]);
+        func(tnew, MSXRungeKuttaSolver.Ynew, n, MSXRungeKuttaSolver.K5);
+
+        tnew = t + h;
+        for (i=1; i<=n; i++)
+            MSXRungeKuttaSolver.Ynew[i] = y[i] + h*(a61* MSXRungeKuttaSolver.K1[i] + a62* MSXRungeKuttaSolver.K2[i] +
+	                  a63* MSXRungeKuttaSolver.K3[i] + a64* MSXRungeKuttaSolver.K4[i] + a65* MSXRungeKuttaSolver.K5[i]);
+        func(tnew, MSXRungeKuttaSolver.Ynew, n, MSXRungeKuttaSolver.K6);
+
+        for (i=1; i<=n; i++)
+            MSXRungeKuttaSolver.Ynew[i] = y[i] + h*(a71* MSXRungeKuttaSolver.K1[i] + a73* MSXRungeKuttaSolver.K3[i] +
+	                  a74* MSXRungeKuttaSolver.K4[i] + a75* MSXRungeKuttaSolver.K5[i] + a76* MSXRungeKuttaSolver.K6[i]);
+        func(tnew, MSXRungeKuttaSolver.Ynew, n, MSXRungeKuttaSolver.K2);
+        nfcn += 6;
+
+    // --- step size adjustment
+
+        err = 0.0;
+        hnew = h;
+        if (adjust)
+        {
+            for (i=1; i<=n; i++)
+                MSXRungeKuttaSolver.K4[i] = (e1* MSXRungeKuttaSolver.K1[i] + e3* MSXRungeKuttaSolver.K3[i] + e4* MSXRungeKuttaSolver.K4[i] + e5* MSXRungeKuttaSolver.K5[i] +
+                         e6* MSXRungeKuttaSolver.K6[i] + e7* MSXRungeKuttaSolver.K2[i])*h;
+ 
+            for (i=1; i<=n; i++)
+            {
+                sk = atol[i] + rtol[i]*fmax(fabs(y[i]), fabs(MSXRungeKuttaSolver.Ynew[i]));
+                sk = MSXRungeKuttaSolver.K4[i]/sk;
+                err = err + (sk*sk);
+            }
+            err = sqrt(err/n);
+
+            // --- computation of hnew
+            fac11 = pow(err, expo1);
+            fac = fac11/pow(facold, beta);               // LUND-stabilization
+            fac = fmax(facc2, fmin(facc1, (fac/SAFE)));  // must have FAC1 <= HNEW/H <= FAC2
+            hnew = h/fac;
+        }
+  
+    // --- step is accepted 
+
+        if( err <= 1.0 )
+        {
+           facold = fmax(err, 1.0e-4);
+            naccpt++;
+            for (i=1; i<=n; i++)
+            {
+                MSXRungeKuttaSolver.K1[i] = MSXRungeKuttaSolver.K2[i];
+                y[i] = MSXRungeKuttaSolver.Ynew[i];
+            }
+            t = t + h;
+            if ( adjust && t <= tnext ) *htry = h;
+            if (fabs(hnew) > hmax) hnew = hmax; 
+            if (reject) hnew = fmin(fabs(hnew), fabs(h));
+            reject = 0;
+            if (MSXRungeKuttaSolver.Report) MSXRungeKuttaSolver.Report(t, y, n);
+        } 
+  
+    // --- step is rejected
+
+        else
+        {
+            if ( adjust ) hnew = h/fmin(facc1, (fac11/SAFE));
+            reject = 1; 
+            if (naccpt >= 1) nrejct++;   
+        }
+
+    // --- take another step
+
+        h = hnew;
+        if ( adjust ) *htry = h;
+        nstep++;
+        if (nstep >= MSXRungeKuttaSolver.Itmax) return -1;
+    }
+    return nfcn;
+}

epanet-msx-src/rk5.h

@@ -0,0 +1,39 @@
+/************************************************************************
+**  MODULE:        RK5.H
+**  PROJECT:       EPANET-MSX
+**  DESCRIPTION:   Header file for the ODE solver contained in RK5.C.
+**  AUTHOR:        L. Rossman, US EPA - NRMRL
+**  VERSION:       2.0.00                                               
+**  LAST UPDATE:   04/14/2021
+***********************************************************************/
+
+#ifndef RK5_H
+#define RK5_H
+
+typedef struct
+{
+    int      Nmax;          // max. number of equations
+    int      Itmax;         // max. number of integration steps
+    int      Adjust;        // use adjustable step size
+    double* Ak;           // work arrays
+    double* K1;
+    double* K2;
+    double* K3;
+    double* K4;
+    double* K5;
+    double* K6;
+    double* Ynew;         // updated solution
+    void     (*Report) (double, double*, int);
+}MSXRungeKutta;
+// Opens the ODE solver system
+int  rk5_open(int n, int itmax, int adjust);
+
+// Closes the ODE solver system
+void rk5_close(void);
+
+// Applies the solver to integrate a specific system of ODEs
+int  rk5_integrate(double y[], int n, double t, double tnext,
+                   double* htry, double atol[], double rtol[],
+                   void (*func)(double, double*, int, double*));
+
+#endif