def test_d_factor(self): nd = differentiate( lambda s: self.model.hist_factor(s, self.L, self.T, self.fixed), self.strength) d = self.model.d_hist_factor(self.strength, self.L, self.T, self.fixed) self.assertTrue(np.isclose(nd, d))
def test_damage_damage(self): act = self.model.d_damage_rate_d_damage(self.shear, self.sliprate, self.normal, self.damage) res = differentiate( lambda d: self.model.damage_rate(self.shear, self.sliprate, self. normal, d), self.damage) self.assertAlmostEqual(act, res)
def test_dshear(self): for i in range(self.lattice.ngroup): for j in range(self.lattice.nslip(i)): rs = lambda S: np.einsum('ij,ij', np.dot(self.QM,np.dot(np.outer(self.lattice.slip_directions[i][j].data, self.lattice.slip_planes[i][j].data), self.QM.T)), S) num = tensors.Symmetric(differentiate(rs, self.S)[0])
def test_damage_slip(self): act = self.model.d_damage_rate_d_slip(self.shear, self.sliprate, self.normal, self.damage) dfn = lambda s: self.model.damage_rate(self.shear, list(s), self. normal, self.damage) res = differentiate(dfn, np.array(self.sliprate))[0] self.assertTrue(np.allclose(act, res))
def test_d_sslip_d_strength(self): for g in range(self.L.ngroup): for i in range(self.L.nslip(g)): nd = differentiate( lambda s: self.model.scalar_sslip(g, i, self.tau, s, self.T ), self.strength) d = self.model.scalar_d_sslip_dstrength( g, i, self.tau, self.strength, self.T) self.assertTrue(np.isclose(nd, d))
def drive(self, model): d_n = np.zeros((6, )) w_n = np.zeros((3, )) s_n = np.zeros((6, )) h_n = model.init_store() t_n = 0.0 u_n = 0.0 p_n = 0.0 for i in range(self.nsteps): t_np1 = t_n + self.dt d_np1 = d_n + self.Ddir * self.dt w_np1 = w_n + self.Wdir * self.dt s_np1, h_np1, A_np1, B_np1, u_np1, p_np1 = model.update_ld_inc( d_np1, d_n, w_np1, w_n, self.T, self.T, t_np1, t_n, s_n, h_n, u_n, p_n) A_num = common.differentiate( lambda d: model. update_ld_inc(d, d_n, w_np1, w_n, self.T, self.T, t_np1, t_n, s_n, h_n, u_n, p_n)[0], d_np1) # This is somewhat iffy print(A_np1) print(A_num) self.assertTrue(np.allclose(A_np1, A_num, rtol=1.0e-3)) B_num = common.differentiate( lambda w: model. update_ld_inc(d_np1, d_n, w, w_n, self.T, self.T, t_np1, t_n, s_n, h_n, u_n, p_n)[0], w_np1) # Again, why the loose tolerance? self.assertTrue(np.allclose(B_np1, B_num, rtol=1.0e-3)) s_n = np.copy(s_np1) h_n = np.copy(h_np1) d_n = np.copy(d_np1) w_n = np.copy(w_np1) t_n = t_np1 u_n = u_np1 p_n = p_np1
def test_slip_tau(self): for g in range(self.L.ngroup): for i in range(self.L.nslip(g)): rs = self.L.shear(g, i, self.Q, self.S) nd = differentiate( lambda t: self.model.sslip(g, i, t, self.strength_values, self.T), rs) d = self.model.d_sslip_dtau(g, i, rs, self.strength_values, self.T) self.assertTrue(np.isclose(d, nd, rtol=1e-4))
def test_jacobian(self): fn = lambda x: self.model.RJ(x, self.ts)[0] Jn = common.differentiate(fn, self.x) R, J = self.model.RJ(self.x, self.ts) print(J) print(Jn) print((J - Jn)) self.assertTrue(np.allclose(J, Jn, rtol=1.0e-4))
def test_slip_strength(self): for g in range(self.L.ngroup): for i in range(self.L.nslip(g)): rs = self.L.shear(g, i, self.Q, self.S) nd = differentiate( lambda s: self.model.sslip(g, i, rs, s, self.T), np.array(self.strength_values)) d = self.model.d_sslip_dstrength(g, i, rs, self.strength_values, self.T) self.assertTrue(np.allclose(nd, d))
def test_map_normal(self): for v in self.vals: exact = self.function.d_map_d_normal(v, self.n) num = differentiate(lambda x: self.function.map(v, x), self.n) self.assertAlmostEqual(exact, num)
def test_map_damage(self): for v in self.vals: exact = self.function.d_map_d_damage(v, self.n) num = differentiate(lambda x: self.function.map(x, self.n), v) self.assertAlmostEqual(exact, num)