def test_linVnln(self): """Test ss UVLM output equations against full nonlinear calcs.""" # Init steady problem at 1 deg AoA aoa = 1 * np.pi / 180.0 V = 1 m = 2 n = 2 mW = 3 delS = 1 chords = np.linspace(-1.0, 0.0, m + 1, True) chordsW = np.linspace(0.0, 10000.0, mW + 1, True) spans = np.linspace(-10000, 10000, n + 1, True) zeta0 = np.zeros(3 * len(chords) * len(spans)) zetaW0 = np.zeros(3 * len(chordsW) * len(spans)) kk = 0 for c in chords: for s in spans: zeta0[3 * kk] = np.cos(aoa) * c zeta0[3 * kk + 1] = s zeta0[3 * kk + 2] = -np.sin(aoa) * c kk = kk + 1 # end for s # end for c kk = 0 for c in chordsW: for s in spans: zetaW0[3 * kk] = c zetaW0[3 * kk + 1] = s kk = kk + 1 # end for s # end for c zetaPri0 = np.zeros((3 * len(chords) * len(spans))) gamPri0 = np.zeros((m * n)) nu = np.zeros((3 * len(chords) * len(spans))) # atmospheric velocity nu[0::3] = V # to be solved gam0 = np.zeros((m * n)) gamW0 = np.zeros((mW * n)) f0 = np.zeros((3 * len(chords) * len(spans))) # forces # initialise nonlinear options VMOPTS = VMopts( m, n, False, # image methods mW, True, # steady True, # KJ is true True, delS, False, 1) #numCores # solve nonlinear Cpp_Solver_VLM(zeta0, zetaPri0, nu, zetaW0, VMOPTS, f0, gam0, gamW0) # generate linear output eqs at x0, u0 foo1, foo2, foo3, C, D = genSSuvlm(gam0, gamW0, gamPri0, zeta0, zetaW0, zetaPri0, nu, m, n, mW, delS) del foo1, foo2, foo3 # init delta vectors for testing dX = np.zeros((2 * m * n + mW * n)) dU = np.zeros((9 * len(chords) * len(spans))) # variations in gamma-------------------------------------------------- for i in range(m * n): dX[i] = 0.00002 / (m * n) * (i + 1) gamPdX = gam0 + dX[0:m * n] f = np.zeros_like(f0) gam_tm1 = gam0 - delS * gamPri0 Cpp_KJForces(zeta0, gamPdX, zetaW0, gamW0, zetaPri0, nu, VMOPTS, gam_tm1, f) f_dGamma = f - f0 dfApprox = np.dot(C, dX) + np.dot(D, dU) # lift dLexact = sum(f_dGamma[2::3]) dLapprox = sum(dfApprox[2::3]) self.assertLess(np.abs((dLapprox - dLexact) / dLexact), 0.001) # drag dDexact = sum(f_dGamma[0::3]) dDapprox = sum(dfApprox[0::3]) self.assertLess(np.abs((dDapprox - dDexact) / dDexact), 0.001) # side force dSexact = sum(f_dGamma[1::3]) dSapprox = sum(dfApprox[1::3]) self.assertLess(dSexact, 1e-7) self.assertLess(dSapprox, 1e-7) # variations in gamma w ------------------------------------------------ f[:] = 0.0 dX[:] = 0.0 for i in range(m * n, mW * n): dX[i] = 0.00002 / (mW * n) * (i + 1) gamWpDx = gamW0 + dX[m * n:m * n + mW * n] Cpp_KJForces(zeta0, gam0, zetaW0, gamWpDx, zetaPri0, nu, VMOPTS, gam_tm1, f) f_dGammaW = f - f0 dfApprox = np.dot(C, dX) + np.dot(D, dU) # lift dLexact = sum(f_dGammaW[2::3]) dLapprox = sum(dfApprox[2::3]) self.assertLess(np.abs((dLapprox - dLexact) / dLexact), 0.001) # drag dDexact = sum(f_dGammaW[0::3]) dDapprox = sum(dfApprox[0::3]) self.assertLess(np.abs((dDapprox - dDexact) / dDexact), 0.001) # side force dSexact = sum(f_dGammaW[1::3]) dSapprox = sum(dfApprox[1::3]) self.assertLess(dSexact, 1e-7) self.assertLess(dSapprox, 1e-7) # variations in gamPri ------------------------------------------------ f[:] = 0.0 dX[:] = 0.0 for i in range(m * n + mW * n, 2 * m * n + mW * n): dX[i] = 0.002 / (m * n) * (i + 1) gam_tm1pDx = gam0 - 2.0 * delS * dX[m * n + mW * n:] VMOPTS.Steady = ct.c_bool(False) Cpp_KJForces(zeta0, gam0, zetaW0, gamW0, zetaPri0, nu, VMOPTS, gam_tm1pDx, f) f_dGamPri = f - f0 dfApprox = np.dot(C, dX) + np.dot(D, dU) # lift dLexact = sum(f_dGamPri[2::3]) dLapprox = sum(dfApprox[2::3]) self.assertLess(np.abs((dLapprox - dLexact) / dLexact), 0.001) # drag dDexact = sum(f_dGamPri[0::3]) dDapprox = sum(dfApprox[0::3]) self.assertLess(np.abs((dDapprox - dDexact) / dDexact), 0.001) # side force dSexact = sum(f_dGamPri[1::3]) dSapprox = sum(dfApprox[1::3]) self.assertLess(dSexact, 1e-7) self.assertLess(dSapprox, 1e-7) # variations in zetaPri ------------------------------------------------ f[:] = 0.0 dX[:] = 0.0 for i in range(3 * (m + 1) * (n + 1)): dU[i] = 0.002 / (3 * (m + 1) * (n + 1) * (i + 1)) zetaPriPdX = zetaPri0 + dU[0:3 * (m + 1) * (n + 1)] VMOPTS.Steady = ct.c_bool(True) Cpp_KJForces(zeta0, gam0, zetaW0, gamW0, zetaPriPdX, nu, VMOPTS, gam_tm1, f) f_dZetaPri = f - f0 dfApprox = np.dot(C, dX) + np.dot(D, dU) # lift dLexact = sum(f_dZetaPri[2::3]) dLapprox = sum(dfApprox[2::3]) self.assertLess(np.abs((dLapprox - dLexact) / dLexact), 0.001) # drag dDexact = sum(f_dZetaPri[0::3]) dDapprox = sum(dfApprox[0::3]) self.assertLess(np.abs((dDapprox - dDexact) / dDexact), 0.001) # side force dSexact = sum(f_dZetaPri[1::3]) dSapprox = sum(dfApprox[1::3]) self.assertLess(np.abs((dSapprox - dSexact) / dSexact), 0.001) # variations in nu ----------------------------------------------------- f[:] = 0.0 dU[:] = 0.0 for i in range(6 * (m + 1) * (n + 1), 9 * (m + 1) * (n + 1)): dU[i] = 0.002 / (3 * (m + 1) * (n + 1) * (i + 1)) nuPdX = nu + dU[6 * (m + 1) * (n + 1):] Cpp_KJForces(zeta0, gam0, zetaW0, gamW0, zetaPri0, nuPdX, VMOPTS, gam_tm1, f) f_dNu = f - f0 dfApprox = np.dot(C, dX) + np.dot(D, dU) # lift dLexact = sum(f_dNu[2::3]) dLapprox = sum(dfApprox[2::3]) self.assertLess(np.abs((dLapprox - dLexact) / dLexact), 0.001) # drag dDexact = sum(f_dNu[0::3]) dDapprox = sum(dfApprox[0::3]) self.assertLess(np.abs((dDapprox - dDexact) / dDexact), 0.001) # side force dSexact = sum(f_dNu[1::3]) dSapprox = sum(dfApprox[1::3]) self.assertLess(np.abs((dSapprox - dSexact) / dSexact), 0.001)
def test_linVnln(self): """Test ss UVLM output equations against full nonlinear calcs.""" # Init steady problem at 1 deg AoA aoa = 1*np.pi/180.0 V = 1 m=2 n=2 mW=3 delS=1 chords = np.linspace(-1.0, 0.0, m+1, True) chordsW = np.linspace(0.0, 10000.0, mW+1, True) spans = np.linspace(-10000, 10000, n+1, True) zeta0=np.zeros(3*len(chords)*len(spans)) zetaW0=np.zeros(3*len(chordsW)*len(spans)) kk=0 for c in chords: for s in spans: zeta0[3*kk]=np.cos(aoa)*c zeta0[3*kk+1]=s zeta0[3*kk+2]=-np.sin(aoa)*c kk=kk+1 # end for s # end for c kk=0 for c in chordsW: for s in spans: zetaW0[3*kk]=c zetaW0[3*kk+1]=s kk=kk+1 # end for s # end for c zetaPri0 = np.zeros((3*len(chords)*len(spans))) gamPri0=np.zeros((m*n)) nu = np.zeros((3*len(chords)*len(spans))) # atmospheric velocity nu[0::3]=V # to be solved gam0=np.zeros((m*n)) gamW0=np.zeros((mW*n)) f0 = np.zeros((3*len(chords)*len(spans))) # forces # initialise nonlinear options VMOPTS = VMopts(m, n, False, # image methods mW, True, # steady True, # KJ is true True, delS, False, 1) #numCores # solve nonlinear Cpp_Solver_VLM(zeta0, zetaPri0, nu, zetaW0, VMOPTS, f0, gam0, gamW0) # generate linear output eqs at x0, u0 foo1, foo2, foo3, C, D = genSSuvlm(gam0, gamW0, gamPri0, zeta0, zetaW0, zetaPri0, nu, m, n, mW, delS) del foo1, foo2, foo3 # init delta vectors for testing dX = np.zeros((2*m*n+mW*n)) dU = np.zeros((9*len(chords)*len(spans))) # variations in gamma-------------------------------------------------- for i in range(m*n): dX[i] = 0.00002/(m*n)*(i+1) gamPdX = gam0+dX[0:m*n] f = np.zeros_like(f0) gam_tm1=gam0-delS*gamPri0 Cpp_KJForces(zeta0, gamPdX, zetaW0, gamW0, zetaPri0, nu, VMOPTS, gam_tm1, f) f_dGamma = f - f0 dfApprox = np.dot(C,dX)+np.dot(D,dU) # lift dLexact = sum(f_dGamma[2::3]) dLapprox = sum(dfApprox[2::3]) self.assertLess(np.abs((dLapprox-dLexact)/dLexact), 0.001) # drag dDexact = sum(f_dGamma[0::3]) dDapprox = sum(dfApprox[0::3]) self.assertLess(np.abs((dDapprox-dDexact)/dDexact), 0.001) # side force dSexact = sum(f_dGamma[1::3]) dSapprox = sum(dfApprox[1::3]) self.assertLess(dSexact, 1e-7) self.assertLess(dSapprox, 1e-7) # variations in gamma w ------------------------------------------------ f[:]=0.0 dX[:]=0.0 for i in range(m*n,mW*n): dX[i] = 0.00002/(mW*n)*(i+1) gamWpDx = gamW0 + dX[m*n:m*n+mW*n] Cpp_KJForces(zeta0, gam0, zetaW0, gamWpDx, zetaPri0, nu, VMOPTS, gam_tm1, f) f_dGammaW = f - f0 dfApprox = np.dot(C,dX)+np.dot(D,dU) # lift dLexact = sum(f_dGammaW[2::3]) dLapprox = sum(dfApprox[2::3]) self.assertLess(np.abs((dLapprox-dLexact)/dLexact), 0.001) # drag dDexact = sum(f_dGammaW[0::3]) dDapprox = sum(dfApprox[0::3]) self.assertLess(np.abs((dDapprox-dDexact)/dDexact), 0.001) # side force dSexact = sum(f_dGammaW[1::3]) dSapprox = sum(dfApprox[1::3]) self.assertLess(dSexact, 1e-7) self.assertLess(dSapprox, 1e-7) # variations in gamPri ------------------------------------------------ f[:]=0.0 dX[:]=0.0 for i in range(m*n+mW*n,2*m*n+mW*n): dX[i] = 0.002/(m*n)*(i+1) gam_tm1pDx = gam0-2.0*delS*dX[m*n+mW*n:] VMOPTS.Steady = ct.c_bool(False) Cpp_KJForces(zeta0, gam0, zetaW0, gamW0, zetaPri0, nu, VMOPTS, gam_tm1pDx, f) f_dGamPri = f - f0 dfApprox = np.dot(C,dX)+np.dot(D,dU) # lift dLexact = sum(f_dGamPri[2::3]) dLapprox = sum(dfApprox[2::3]) self.assertLess(np.abs((dLapprox-dLexact)/dLexact), 0.001) # drag dDexact = sum(f_dGamPri[0::3]) dDapprox = sum(dfApprox[0::3]) self.assertLess(np.abs((dDapprox-dDexact)/dDexact), 0.001) # side force dSexact = sum(f_dGamPri[1::3]) dSapprox = sum(dfApprox[1::3]) self.assertLess(dSexact, 1e-7) self.assertLess(dSapprox, 1e-7) # variations in zetaPri ------------------------------------------------ f[:]=0.0 dX[:]=0.0 for i in range(3*(m+1)*(n+1)): dU[i] = 0.002/(3*(m+1)*(n+1)*(i+1)) zetaPriPdX = zetaPri0+dU[0:3*(m+1)*(n+1)] VMOPTS.Steady = ct.c_bool(True) Cpp_KJForces(zeta0, gam0, zetaW0, gamW0, zetaPriPdX, nu, VMOPTS, gam_tm1, f) f_dZetaPri = f - f0 dfApprox = np.dot(C,dX)+np.dot(D,dU) # lift dLexact = sum(f_dZetaPri[2::3]) dLapprox = sum(dfApprox[2::3]) self.assertLess(np.abs((dLapprox-dLexact)/dLexact), 0.001) # drag dDexact = sum(f_dZetaPri[0::3]) dDapprox = sum(dfApprox[0::3]) self.assertLess(np.abs((dDapprox-dDexact)/dDexact), 0.001) # side force dSexact = sum(f_dZetaPri[1::3]) dSapprox = sum(dfApprox[1::3]) self.assertLess(np.abs((dSapprox-dSexact)/dSexact), 0.001) # variations in nu ----------------------------------------------------- f[:]=0.0 dU[:]=0.0 for i in range(6*(m+1)*(n+1),9*(m+1)*(n+1)): dU[i] = 0.002/(3*(m+1)*(n+1)*(i+1)) nuPdX = nu + dU[6*(m+1)*(n+1):] Cpp_KJForces(zeta0, gam0, zetaW0, gamW0, zetaPri0, nuPdX, VMOPTS, gam_tm1, f) f_dNu = f - f0 dfApprox = np.dot(C,dX)+np.dot(D,dU) # lift dLexact = sum(f_dNu[2::3]) dLapprox = sum(dfApprox[2::3]) self.assertLess(np.abs((dLapprox-dLexact)/dLexact), 0.001) # drag dDexact = sum(f_dNu[0::3]) dDapprox = sum(dfApprox[0::3]) self.assertLess(np.abs((dDapprox-dDexact)/dDexact), 0.001) # side force dSexact = sum(f_dNu[1::3]) dSapprox = sum(dfApprox[1::3]) self.assertLess(np.abs((dSapprox-dSexact)/dSexact), 0.001)
def test_linVnln_dZeta(self): """Test ss UVLM output equations against full nonlinear calcs.""" # Init steady problem at 1 deg AoA aoa = 1.0 * np.pi / 180.0 V = 1 m = 4 n = 3 mW = 11 delS = 1 chords = np.linspace(-1.0, 0.0, m + 1, True) chordsW = np.linspace(0.0, 10000.0, mW + 1, True) spans = np.linspace(-10000, 10000, n + 1, True) zeta0 = np.zeros(3 * len(chords) * len(spans)) zetaW0 = np.zeros(3 * len(chordsW) * len(spans)) kk = 0 for c in chords: for s in spans: zeta0[3 * kk] = np.cos(aoa) * c zeta0[3 * kk + 1] = s zeta0[3 * kk + 2] = -np.sin(aoa) * c kk = kk + 1 # end for s # end for c kk = 0 for c in chordsW: for s in spans: zetaW0[3 * kk] = c zetaW0[3 * kk + 1] = s kk = kk + 1 # end for s # end for c zetaPri0 = np.zeros((3 * len(chords) * len(spans))) gamPri0 = np.zeros((m * n)) nu = np.zeros((3 * len(chords) * len(spans))) # atmospheric velocity nu[0::3] = V # to be solved gam0 = np.zeros((m * n)) gamW0 = np.zeros((mW * n)) f0 = np.zeros((3 * len(chords) * len(spans))) # forces # initialise nonlinear options VMOPTS = VMopts( m, n, False, # image methods mW, True, # steady True, # KJ is true True, delS, False, 1) #numCores # solve nonlinear Cpp_Solver_VLM(zeta0, zetaPri0, nu, zetaW0, VMOPTS, f0, gam0, gamW0) # set to unsteady mode and calculate with zetaPri0 f0[:] = 0.0 VMOPTS.Steady = ct.c_bool(False) gamPri0 = 0.01 * np.ones_like(gamPri0) gam_tm1 = gam0 - 2.0 * delS * gamPri0 Cpp_KJForces(zeta0, gam0, zetaW0, gamW0, zetaPri0, nu, VMOPTS, gam_tm1, f0) # generate linear output eqs at x0, u0 foo1, foo2, foo3, C, D = genSSuvlm(gam0, gamW0, gamPri0, zeta0, zetaW0, zetaPri0, nu, m, n, mW, delS) del foo1, foo2, foo3 # init delta vectors for testing dX = np.zeros((2 * m * n + mW * n)) dU = np.zeros((9 * len(chords) * len(spans))) # variations in zeta ----------------------------------------------------- f = np.zeros_like(f0) for i in range(3 * (m + 1) * (n + 1), 6 * (m + 1) * (n + 1)): if isodd(i): dU[i] = 0.1 / (m * 3 * (m + 1) * (n + 1) * (i + 1)) else: dU[i] = -0.1 / (m * 3 * (m + 1) * (n + 1) * (i + 1)) zetaPdX = zeta0 + dU[3 * (m + 1) * (n + 1):6 * (m + 1) * (n + 1)] gam_tm1 = gam0 - 2.0 * delS * gamPri0 Cpp_KJForces(zetaPdX, gam0, zetaW0, gamW0, zetaPri0, nu, VMOPTS, gam_tm1, f) # calculate diffs f_dZeta = f - f0 dfApprox = np.dot(C, dX) + np.dot(D, dU) # lift dLexact = sum(f_dZeta[2::3]) dLapprox = sum(dfApprox[2::3]) self.assertLess(np.abs((dLapprox - dLexact) / dLexact), 0.01) # drag dDexact = sum(f_dZeta[0::3]) dDapprox = sum(dfApprox[0::3]) self.assertLess(np.abs((dDapprox - dDexact) / dDexact), 0.01) # side force dSexact = sum(f_dZeta[1::3]) dSapprox = sum(dfApprox[1::3]) self.assertLess(np.abs((dSapprox - dSexact) / dSexact), 0.01)
def test_linVnln_dZeta(self): """Test ss UVLM output equations against full nonlinear calcs.""" # Init steady problem at 1 deg AoA aoa = 1.0*np.pi/180.0 V = 1 m=4 n=3 mW=11 delS=1 chords = np.linspace(-1.0, 0.0, m+1, True) chordsW = np.linspace(0.0, 10000.0, mW+1, True) spans = np.linspace(-10000, 10000, n+1, True) zeta0=np.zeros(3*len(chords)*len(spans)) zetaW0=np.zeros(3*len(chordsW)*len(spans)) kk=0 for c in chords: for s in spans: zeta0[3*kk]=np.cos(aoa)*c zeta0[3*kk+1]=s zeta0[3*kk+2]=-np.sin(aoa)*c kk=kk+1 # end for s # end for c kk=0 for c in chordsW: for s in spans: zetaW0[3*kk]=c zetaW0[3*kk+1]=s kk=kk+1 # end for s # end for c zetaPri0 = np.zeros((3*len(chords)*len(spans))) gamPri0=np.zeros((m*n)) nu = np.zeros((3*len(chords)*len(spans))) # atmospheric velocity nu[0::3]=V # to be solved gam0=np.zeros((m*n)) gamW0=np.zeros((mW*n)) f0 = np.zeros((3*len(chords)*len(spans))) # forces # initialise nonlinear options VMOPTS = VMopts(m, n, False, # image methods mW, True, # steady True, # KJ is true True, delS, False, 1) #numCores # solve nonlinear Cpp_Solver_VLM(zeta0, zetaPri0, nu, zetaW0, VMOPTS, f0, gam0, gamW0) # set to unsteady mode and calculate with zetaPri0 f0[:]=0.0 VMOPTS.Steady = ct.c_bool(False) gamPri0=0.01*np.ones_like(gamPri0) gam_tm1=gam0-2.0*delS*gamPri0 Cpp_KJForces(zeta0, gam0, zetaW0, gamW0, zetaPri0, nu, VMOPTS, gam_tm1, f0) # generate linear output eqs at x0, u0 foo1, foo2, foo3, C, D = genSSuvlm(gam0, gamW0, gamPri0, zeta0, zetaW0, zetaPri0, nu, m, n, mW, delS) del foo1, foo2, foo3 # init delta vectors for testing dX = np.zeros((2*m*n+mW*n)) dU = np.zeros((9*len(chords)*len(spans))) # variations in zeta ----------------------------------------------------- f = np.zeros_like(f0) for i in range(3*(m+1)*(n+1),6*(m+1)*(n+1)): if isodd(i): dU[i] = 0.1/(m*3*(m+1)*(n+1)*(i+1)) else: dU[i] = -0.1/(m*3*(m+1)*(n+1)*(i+1)) zetaPdX = zeta0 + dU[3*(m+1)*(n+1):6*(m+1)*(n+1)] gam_tm1=gam0-2.0*delS*gamPri0 Cpp_KJForces(zetaPdX, gam0, zetaW0, gamW0, zetaPri0, nu, VMOPTS, gam_tm1, f) # calculate diffs f_dZeta = f - f0 dfApprox = np.dot(C,dX)+np.dot(D,dU) # lift dLexact = sum(f_dZeta[2::3]) dLapprox = sum(dfApprox[2::3]) self.assertLess(np.abs((dLapprox-dLexact)/dLexact), 0.01) # drag dDexact = sum(f_dZeta[0::3]) dDapprox = sum(dfApprox[0::3]) self.assertLess(np.abs((dDapprox-dDexact)/dDexact), 0.01) # side force dSexact = sum(f_dZeta[1::3]) dSapprox = sum(dfApprox[1::3]) self.assertLess(np.abs((dSapprox-dSexact)/dSexact), 0.01)