def verify_warp3d():
E = 30000.0
nu = 0.3
sy = 100.0
Q = 50.0
b = 100.0
C = 1000.0
g = 10.0
mu = E / (2 * (1.0 + nu))
K = E / (3 * (1 - 2 * nu))
elastic = elasticity.IsotropicLinearElasticModel(mu, "shear", K, "bulk")
surface = surfaces.IsoKinJ2()
iso = hardening.VoceIsotropicHardeningRule(sy, Q, b)
hrule = hardening.Chaboche(iso, [C], [hardening.ConstantGamma(g)], [0.0],
[1.0])
flow = ri_flow.RateIndependentNonAssociativeHardening(surface, hrule)
model = models.SmallStrainRateIndependentPlasticity(elastic,
flow,
verbose=False)
res = drivers.strain_cyclic(model, 0.0075, -1.0, 1.0e-4, 50)
strain = res['strain']
stress = res['stress']
data_warp = np.load('data_fa_warp.npy')
plt.plot(strain, stress, 'k-')
plt.plot(data_warp[0], data_warp[1], 'r-')
plt.show()
def setUp(self):
E = 200000.0
nu = 0.27
mu = E / (2 * (1.0 + nu))
K = E / (3 * (1 - 2 * nu))
s0 = 300.0
Kp = 0.0
c = [30000.0]
r = [60.0]
A = [0.0]
n = [1.0]
elastic = elasticity.IsotropicLinearElasticModel(
mu, "shear", K, "bulk")
surface = surfaces.IsoKinJ2()
iso = hardening.LinearIsotropicHardeningRule(s0, Kp)
gmodels = [hardening.ConstantGamma(g) for g in r]
hrule = hardening.Chaboche(iso, c, gmodels, A, n)
flow = ri_flow.RateIndependentNonAssociativeHardening(surface, hrule)
self.model = models.SmallStrainRateIndependentPlasticity(
elastic, flow, verbose=False, check_kt=False)
self.umodel = uniaxial.UniaxialModel(self.model)
self.de = 0.001
self.dt = 1.0
self.dT = 0.0
self.T0 = 0.0
self.nsteps = 100
def setUp(self):
self.model1 = parse.parse_xml("test/examples.xml", "test_nonassri")
mu = 40000.0
K = 84000.0
ys = 100.0
r = 100.0
d = 1000.0
cs = [5.0, 10.0]
gs = [1000.0, 1000.0]
As = [0.0, 0.0]
ns = [1.0, 1.0]
elastic = elasticity.IsotropicLinearElasticModel(
mu, "shear", K, "bulk")
surface = surfaces.IsoKinJ2()
iso = hardening.VoceIsotropicHardeningRule(ys, r, d)
gammas = [hardening.ConstantGamma(g) for g in gs]
hmodel = hardening.Chaboche(iso, cs, gammas, As, ns)
flow = ri_flow.RateIndependentNonAssociativeHardening(surface, hmodel)
self.model2 = models.SmallStrainRateIndependentPlasticity(
elastic, flow)
self.T = 300.0
self.tmax = 10.0
self.nsteps = 100
self.emax = np.array([0.05, 0, 0, 0, 0, 0])
def complete(self):
self.E = 92000.0
self.nu = 0.3
self.s0 = 180.0
self.Kp = 1000.0
self.H = 1000.0
self.elastic = elasticity.IsotropicLinearElasticModel(self.E, "youngs",
self.nu, "poissons")
surface = surfaces.IsoKinJ2()
iso = hardening.LinearIsotropicHardeningRule(self.s0, self.Kp)
kin = hardening.LinearKinematicHardeningRule(self.H)
hrule = hardening.CombinedHardeningRule(iso, kin)
flow = ri_flow.RateIndependentAssociativeFlow(surface, hrule)
self.bmodel = models.SmallStrainRateIndependentPlasticity(self.elastic,
flow)
self.xi = 0.478
self.phi = 1.914
self.A = 10000000.0
self.model = damage.ModularCreepDamageModel_sd(
self.elastic,
self.A, self.xi, self.phi,
self.effective_model(),
self.bmodel)
self.stress = np.array([100,-50.0,300.0,-99,50.0,125.0])
self.T = 100.0
self.s_np1 = self.stress
self.s_n = np.array([-25,150,250,-25,-100,25])
self.d_np1 = 0.5
self.d_n = 0.4
self.e_np1 = np.array([0.1,-0.01,0.15,-0.05,-0.1,0.15])
self.e_n = np.array([-0.05,0.025,-0.1,0.2,0.11,0.13])
self.T_np1 = self.T
self.T_n = 90.0
self.t_np1 = 1.0
self.t_n = 0.0
self.u_n = 0.0
self.p_n = 0.0
# This is a rather boring baseline history state to probe, but I can't
# think of a better way to get a "generic" history from a generic model
self.hist_n = np.array([self.d_n] + list(self.bmodel.init_store()))
self.x_trial = np.array([50,-25,150,-150,190,100.0] + [0.41])
self.nsteps = 10
self.etarget = np.array([0.1,-0.025,0.02,0.015,-0.02,-0.05])
self.ttarget = 10.0
def setUp(self):
self.model1 = parse.parse_xml("test/examples.xml", "test_perzyna")
mu = 40000.0
K = 84000.0
elastic = elasticity.IsotropicLinearElasticModel(
mu, "shear", K, "bulk")
sy = 100.0
r = 100.0
d = 1000.0
KK = 1000.0
n = 5.0
eta = 500.0
surface = surfaces.IsoKinJ2()
iso = hardening.VoceIsotropicHardeningRule(sy, r, d)
kin = hardening.LinearKinematicHardeningRule(KK)
hmodel = hardening.CombinedHardeningRule(iso, kin)
gmodel = visco_flow.GPowerLaw(n, eta)
vmodel = visco_flow.PerzynaFlowRule(surface, hmodel, gmodel)
flow = general_flow.TVPFlowRule(elastic, vmodel)
self.model2 = models.GeneralIntegrator(elastic, flow)
self.T = 550.0 + 273.15
self.tmax = 10.0
self.nsteps = 100.0
self.emax = np.array([0.1, 0, 0, 0, 0, 0])
def verify_Cg():
E = 30000.0
nu = 0.3
sy = 100.0
Q = 0.0
b = 0.0
C = 1000.0
g = 10.0
mu = E / (2 * (1.0 + nu))
K = E / (3 * (1 - 2 * nu))
elastic = elasticity.IsotropicLinearElasticModel(mu, "shear", K, "bulk")
surface = surfaces.IsoKinJ2()
iso = hardening.VoceIsotropicHardeningRule(sy, Q, b)
hrule = hardening.Chaboche(iso, [C], [hardening.ConstantGamma(g)], [0.0],
[1.0])
flow = ri_flow.RateIndependentNonAssociativeHardening(surface, hrule)
model = models.SmallStrainRateIndependentPlasticity(elastic,
flow,
verbose=False)
res = drivers.strain_cyclic(model, 0.4, -1.0, 1.0e-4, 1)
strain = res['strain']
stress = res['stress']
mv = np.max(np.abs(stress))
hu = mv - sy
print("C/y: %f / %f" % ((C / g), hu))
def setUp(self):
self.n = 12.0
self.K = 150.0
self.k = 6.0
self.C = 24800.0
self.g0 = 300.0
self.Q = 86 - self.k
self.gs = 300.0
self.b = 10.0
self.beta = 0.0
self.surface = surfaces.IsoKinJ2()
self.iso = hardening.VoceIsotropicHardeningRule(self.k, self.Q, self.b)
cs = [self.C]
gs = [hardening.SatGamma(self.gs, self.g0, self.beta)]
As = [0.0]
ns = [1.0]
self.hardening = hardening.Chaboche(self.iso, cs, gs, As, ns)
self.fluidity = visco_flow.ConstantFluidity(self.K)
self.model = visco_flow.ChabocheFlowRule(self.surface, self.hardening,
self.fluidity, self.n)
self.hist0 = np.zeros((7, ))
self.T = 300.0
def verify_Q():
E = 30000.0
nu = 0.3
sy = 100.0
Q = 50.0
b = 100.0
C = 0.0
g = 0.0
mu = E / (2 * (1.0 + nu))
K = E / (3 * (1 - 2 * nu))
elastic = elasticity.IsotropicLinearElasticModel(mu, "shear", K, "bulk")
surface = surfaces.IsoKinJ2()
iso = hardening.VoceIsotropicHardeningRule(sy, Q, b)
gmodels = [hardening.ConstantGamma(g)]
hrule = hardening.Chaboche(iso, [C], gmodels, [0.0], [1.0])
flow = ri_flow.RateIndependentNonAssociativeHardening(surface, hrule)
model = models.SmallStrainRateIndependentPlasticity(elastic,
flow,
verbose=False)
res = drivers.uniaxial_test(model, 1.0e-2, emax=0.2)
stress = res['stress']
print("Q: %f / %f" % (Q, stress[-1] - sy))
def setUp(self):
n = 20.0
eta = 108.0
sY = 89.0
Q = 165.0
b = 12.0
self.m = 3
C1 = 80.0e3
C2 = 14.02e3
C3 = 3.333e3
y1 = 0.9e3
y2 = 1.5e3
y3 = 1.0
surface = surfaces.IsoKinJ2()
iso = hardening.VoceIsotropicHardeningRule(sY, Q, b)
cs = [C1, C2, C3]
gs = [y1, y2, y3]
gmodels = [hardening.ConstantGamma(g) for g in gs]
A = [0.0, 0.0, 0.0]
ae = [1.0, 1.0, 1.0]
hmodel = hardening.Chaboche(iso, cs, gmodels, A, ae)
fluidity = visco_flow.ConstantFluidity(eta)
self.hist0 = np.zeros((19, ))
self.T = 300.0
self.model = visco_flow.ChabocheFlowRule(surface, hmodel, fluidity, n)
def simple_ex():
E = 92000.0
nu = 0.3
s0 = 180.0
Kp = 1000.0
H = 1000.0
elastic = elasticity.IsotropicLinearElasticModel(E, "youngs", nu,
"poissons")
surface = surfaces.IsoKinJ2()
iso = hardening.LinearIsotropicHardeningRule(s0, Kp)
kin = hardening.LinearKinematicHardeningRule(H)
hrule = hardening.CombinedHardeningRule(iso, kin)
flow = ri_flow.RateIndependentAssociativeFlow(surface, hrule)
bmodel = models.SmallStrainRateIndependentPlasticity(elastic, flow)
A = 0.0e-6
a = 2.2
model_off = damage.NEMLPowerLawDamagedModel_sd(elastic, A, a, bmodel)
A = 2e-5
model_on = damage.NEMLPowerLawDamagedModel_sd(elastic, A, a, bmodel)
res_off = drivers.uniaxial_test(model_off, 1.0e-2, emax=0.13)
res_on = drivers.uniaxial_test(model_on, 1.0e-2, emax=0.13)
plt.plot(res_off['strain'], res_off['stress'], 'k-')
plt.plot(res_on['strain'], res_on['stress'], 'r-')
plt.show()
def setUp(self):
self.E = 92000.0
self.nu = 0.3
self.s0 = 180.0
self.Kp = 1000.0
self.H = 1000.0
self.elastic = elasticity.IsotropicLinearElasticModel(self.E, "youngs",
self.nu, "poissons")
surface = surfaces.IsoKinJ2()
iso = hardening.LinearIsotropicHardeningRule(self.s0, self.Kp)
kin = hardening.LinearKinematicHardeningRule(self.H)
hrule = hardening.CombinedHardeningRule(iso, kin)
flow = ri_flow.RateIndependentAssociativeFlow(surface, hrule)
self.bmodel = models.SmallStrainRateIndependentPlasticity(self.elastic,
flow)
self.fn = interpolate.PolynomialInterpolate([-6.653e-9,2.952e-4,-6.197e-1])
self.C = 32.06
self.lmr = larsonmiller.LarsonMillerRelation(self.fn, self.C)
self.effective = damage.VonMisesEffectiveStress()
self.model = damage.LarsonMillerCreepDamageModel_sd(
self.elastic, self.lmr, self.effective, self.bmodel)
self.stress = np.array([100,-50.0,300.0,-99,50.0,125.0])
self.T = 100.0
self.s_np1 = self.stress
self.s_n = np.array([-25,150,250,-25,-100,25])
self.d_np1 = 0.5
self.d_n = 0.4
self.e_np1 = np.array([0.1,-0.01,0.15,-0.05,-0.1,0.15])
self.e_n = np.array([-0.05,0.025,-0.1,0.2,0.11,0.13])
self.T_np1 = self.T
self.T_n = 90.0
self.t_np1 = 1.0
self.t_n = 0.0
self.dt = self.t_np1 - self.t_n
self.u_n = 0.0
self.p_n = 0.0
# This is a rather boring baseline history state to probe, but I can't
# think of a better way to get a "generic" history from a generic model
self.hist_n = np.array([self.d_n] + list(self.bmodel.init_store()))
self.x_trial = np.array([50,-25,150,-150,190,100.0] + [0.41])
self.nsteps = 10
self.etarget = np.array([0.1,-0.025,0.02,0.015,-0.02,-0.05])
self.ttarget = 10.0
def setUp(self):
self.model1 = parse.parse_xml("test/examples.xml", "test_j2comb")
mu = 40000.0
K = 84000.0
ys = 100.0
r = 100.0
d = 1000.0
KH = 1000.0
elastic = elasticity.IsotropicLinearElasticModel(
mu, "shear", K, "bulk")
surface = surfaces.IsoKinJ2()
iso = hardening.VoceIsotropicHardeningRule(ys, r, d)
kin = hardening.LinearKinematicHardeningRule(KH)
hrule = hardening.CombinedHardeningRule(iso, kin)
flow = ri_flow.RateIndependentAssociativeFlow(surface, hrule)
self.model2 = models.SmallStrainRateIndependentPlasticity(
elastic, flow)
self.T = 300.0
self.tmax = 10.0
self.nsteps = 100.0
self.emax = np.array([0.1, 0, 0, 0, 0, 0])
def setUp(self):
self.hist0 = np.zeros((13, ))
self.E = 92000.0
self.nu = 0.3
self.mu = self.E / (2 * (1 + self.nu))
self.K = self.E / (3 * (1 - 2 * self.nu))
self.s0 = 180.0
self.Kp = 1000.0
self.H = 1000.0
self.elastic = elasticity.IsotropicLinearElasticModel(
self.mu, "shear", self.K, "bulk")
surface = surfaces.IsoKinJ2()
iso = hardening.LinearIsotropicHardeningRule(self.s0, self.Kp)
kin = hardening.LinearKinematicHardeningRule(self.H)
hrule = hardening.CombinedHardeningRule(iso, kin)
flow = ri_flow.RateIndependentAssociativeFlow(surface, hrule)
self.model = models.SmallStrainRateIndependentPlasticity(
self.elastic, flow, check_kt=False)
self.efinal = np.array([0.1, -0.05, 0.02, -0.03, 0.1, -0.15])
self.tfinal = 10.0
self.T = 300.0
self.nsteps = 10
def setUp(self):
n = 20.0
eta = 108.0
sY = 89.0
Q = 165.0
b = 12.0
self.m = 3
C1 = 80.0e3
C2 = 14.02e3
C3 = 3.333e3
y1 = 0.9e3
y2 = 1.5e3
y3 = 1.0
surface = surfaces.IsoKinJ2()
iso = hardening.VoceIsotropicHardeningRule(sY, Q, b)
cs = [C1, C2, C3]
gs = [y1, y2, y3]
As = [0.0, 0.0, 0.0]
ns = [1.0, 1.0, 1.0]
gmodels = [hardening.ConstantGamma(g) for g in gs]
hmodel = hardening.Chaboche(iso, cs, gmodels, As, ns)
fluidity = visco_flow.ConstantFluidity(eta)
self.hist0 = np.zeros((19, ))
self.T = 300.0
vmodel = visco_flow.ChabocheFlowRule(surface, hmodel, fluidity, n)
E = 92000.0
nu = 0.3
mu = E / (2 * (1 + nu))
K = E / (3 * (1 - 2 * nu))
self.elastic = elasticity.IsotropicLinearElasticModel(
mu, "shear", K, "bulk")
flow = general_flow.TVPFlowRule(self.elastic, vmodel)
self.model = models.GeneralIntegrator(self.elastic,
flow,
max_divide=3,
force_divide=True)
self.efinal = np.array([0.05, 0, 0, 0.02, 0, -0.01])
self.tfinal = 10.0
self.T = 300.0
self.nsteps = 100
def unload_ex():
E = 92000.0
nu = 0.3
s0 = 180.0
Kp = 1000.0
H = 1000.0
elastic = elasticity.IsotropicLinearElasticModel(E, "youngs", nu,
"poissons")
surface = surfaces.IsoKinJ2()
iso = hardening.LinearIsotropicHardeningRule(s0, Kp)
kin = hardening.LinearKinematicHardeningRule(H)
hrule = hardening.CombinedHardeningRule(iso, kin)
flow = ri_flow.RateIndependentAssociativeFlow(surface, hrule)
bmodel = models.SmallStrainRateIndependentPlasticity(elastic, flow)
A = 2e-5
a = 2.2
model = damage.NEMLPowerLawDamagedModel_sd(elastic, A, a, bmodel)
driver = drivers.Driver_sd(model)
nsteps = 25
sdir = np.array([1, 0, 0, 0, 0, 0])
erate = 1.0e-5
e_inc = 0.1 / nsteps
for i in range(nsteps):
einc, ainc = driver.erate_einc_step(sdir, erate, e_inc, 0.0)
estrain = model.elastic_strains(driver.stress_int[-1], driver.T_int[-1],
driver.stored[-1])
print("Calculated elastic strain: %f" % estrain[0])
nsteps = 20
dt = 0.1
rstress = driver.stress_int[-1]
rstrain = driver.strain_int[-1][0]
for m in np.linspace(0, 1.0, nsteps, endpoint=False)[::-1]:
driver.stress_step(rstress * m, driver.t_int[-1] + dt,
driver.T_int[-1])
fstrain = driver.strain_int[-1][0]
print("Actual elastic strain: %f" % (rstrain - fstrain))
print("Calculated final elastic strain: %f" % model.elastic_strains(
driver.stress_int[-1], driver.T_int[-1], driver.stored[-1])[0])
plt.plot(driver.strain[:, 0], driver.stress[:, 0])
plt.show()
def creep_ex():
E = 92000.0
nu = 0.3
s0 = 120.0
A = 1.0e-10
n = 3.0
Kp = E / 500
H = E / 500
smodel = creep.PowerLawCreep(A, n)
cmodel = creep.J2CreepModel(smodel)
elastic = elasticity.IsotropicLinearElasticModel(E, "youngs", nu,
"poissons")
surface = surfaces.IsoKinJ2()
iso = hardening.LinearIsotropicHardeningRule(s0, Kp)
kin = hardening.LinearKinematicHardeningRule(H)
hrule = hardening.CombinedHardeningRule(iso, kin)
flow = ri_flow.RateIndependentAssociativeFlow(surface, hrule)
pmodel = models.SmallStrainRateIndependentPlasticity(elastic, flow)
bmodel = models.SmallStrainCreepPlasticity(elastic, pmodel, cmodel)
A_damg = 1.0e-2
a_damg = 1.0
model = damage.NEMLPowerLawDamagedModel_sd(elastic,
A_damg,
a_damg,
bmodel,
verbose=False)
#res = drivers.uniaxial_test(model, 1.0e-2, emax = 0.25)
#plt.plot(res['strain'], res['stress'])
#plt.show()
res = drivers.creep(model, 120.0, 1.0, 393.0, verbose=False)
plt.plot(res['rtime'], res['rstrain'])
plt.show()
plt.loglog(res['rtime'], res['rrate'])
plt.show()
def setUp(self):
n = 20.0
eta = 108.0
sY = 89.0
Q = 165.0
b = 12.0
self.m = 3
C1 = 80.0e3
C2 = 14.02e3
C3 = 3.333e3
y1 = 0.9e3
y2 = 1.5e3
y3 = 1.0
surface = surfaces.IsoKinJ2()
iso = hardening.VoceIsotropicHardeningRule(sY, Q, b)
cs = [C1, C2, C3]
gs = [y1, y2, y3]
As = [0.0, 0.0, 0.0]
ns = [1.0, 1.0, 1.0]
gmodels = [hardening.ConstantGamma(g) for g in gs]
hmodel = hardening.Chaboche(iso, cs, gmodels, As, ns)
fluidity = visco_flow.ConstantFluidity(eta)
self.vmodel = visco_flow.ChabocheFlowRule(surface, hmodel, fluidity, n)
E = 92000.0
nu = 0.3
mu = E / (2 * (1 + nu))
K = E / (3 * (1 - 2 * nu))
self.emodel = elasticity.IsotropicLinearElasticModel(
mu, "shear", K, "bulk")
self.model = general_flow.TVPFlowRule(self.emodel, self.vmodel)
self.T_n = 300.0
self.e_n = np.zeros((6, ))
self.t_n = 0.0
self.h_n = np.zeros((1 + 6 * self.m, ))
def setUp(self):
self.n = 20.0
self.eta = 108.0
self.sY = 89.0
self.prefactor = np.asarray([2.])
self.prefactor = 2.
self.Q = 165.0
self.b = 12.0
self.m = 3
C1 = 80.0e3
C2 = 14.02e3
C3 = 3.333e3
y1 = 0.9e3
y2 = 1.5e3
y3 = 1.0
surface = surfaces.IsoKinJ2()
self.iso = hardening.VoceIsotropicHardeningRule(
self.sY, self.Q, self.b)
self.cs = [C1, C2, C3]
self.gs = [y1, y2, y3]
self.As = [0.0, 0.0, 0.0]
self.ns = [1.0, 1.0, 1.0]
self.gmodels = [hardening.ConstantGamma(g) for g in self.gs]
self.hmodel = hardening.Chaboche(self.iso, self.cs, self.gmodels,
self.As, self.ns)
self.fluidity = visco_flow.ConstantFluidity(self.eta)
self.hist0 = np.zeros((19, ))
self.T = 300.0
self.model = visco_flow.ChabocheFlowRule(surface,
self.hmodel,
self.fluidity,
self.n,
prefactor=self.prefactor)
def setUp(self):
self.s0 = 200.0
self.K = 15000.0
self.n = 4
self.cs = range(1,self.n+1)
self.rs = range(1, self.n+1)
self.iso = hardening.LinearIsotropicHardeningRule(self.s0, self.K)
self.gmodels = [hardening.ConstantGamma(g) for g in self.rs]
As = [0.0] * self.n
ns = [1.0] * self.n
self.hardening = hardening.Chaboche(self.iso, self.cs, self.gmodels, As,
ns)
self.surface = surfaces.IsoKinJ2()
self.model = ri_flow.RateIndependentNonAssociativeHardening(self.surface, self.hardening)
self.hist0 = np.zeros((1+6*self.n,))
self.T = 300.0
def setUp(self):
self.model1 = parse.parse_xml(localize("examples.xml"),
"test_rd_chaboche")
mu = 60384.61
K = 130833.3
elastic = elasticity.IsotropicLinearElasticModel(
mu, "shear", K, "bulk")
r = -80.0
d = 3.0
Cs = [135.0e3, 61.0e3, 11.0e3]
gs = [5.0e4, 1100.0, 1.0]
As = [0.0, 0.0, 0.0]
ns = [1.0, 1.0, 1.0]
gmodels = [hardening.ConstantGamma(g) for g in gs]
eta = 701.0
n = 10.5
surface = surfaces.IsoKinJ2()
iso = hardening.VoceIsotropicHardeningRule(0.0, r, d)
hmodel = hardening.Chaboche(iso, Cs, gmodels, As, ns)
fluidity = visco_flow.ConstantFluidity(eta)
vmodel = visco_flow.ChabocheFlowRule(surface, hmodel, fluidity, n)
flow = general_flow.TVPFlowRule(elastic, vmodel)
self.model2 = models.GeneralIntegrator(elastic, flow)
self.T = 550.0 + 273.15
self.tmax = 10.0
self.nsteps = 100
self.emax = np.array([0.1, 0, 0, 0, 0, 0])
def test_damage(self):
s0 = 180.0
Kp = 1000.0
H = 1000.0
surface = surfaces.IsoKinJ2()
iso = hardening.LinearIsotropicHardeningRule(s0, Kp)
kin = hardening.LinearKinematicHardeningRule(H)
hrule = hardening.CombinedHardeningRule(iso, kin)
flow = ri_flow.RateIndependentAssociativeFlow(surface, hrule)
bmodel = models.SmallStrainRateIndependentPlasticity(
self.elastic1, flow)
W0 = 10.0
k0 = 0.0001
a0 = 2.0
model1 = damage.NEMLExponentialWorkDamagedModel_sd(
self.elastic1, W0, k0, a0, bmodel)
W02 = 10.0
k02 = 0.001
a02 = 1.5
model2 = damage.NEMLExponentialWorkDamagedModel_sd(
self.elastic1, W02, k02, a02, bmodel)
model = damage.CombinedDamageModel_sd(self.elastic1, [model1, model2],
bmodel)
self.very_close(model, self.emodel1)
model.set_elastic_model(self.elastic2)
self.very_close(model, self.emodel2)
def setUp(self):
self.hist0 = np.zeros((13, ))
self.E = 92000.0
self.nu = 0.3
self.mu = self.E / (2 * (1 + self.nu))
self.K = self.E / (3 * (1 - 2 * self.nu))
self.s0 = 180.0
self.Kp = 1000.0
self.n = 2
self.cs = [10.0, 2.0]
self.rs = [5.0, 1.0]
self.gmodels = [hardening.ConstantGamma(g) for g in self.rs]
self.As = [0.0] * self.n
self.ns = [1.0] * self.n
self.elastic = elasticity.IsotropicLinearElasticModel(
self.mu, "shear", self.K, "bulk")
surface = surfaces.IsoKinJ2()
iso = hardening.LinearIsotropicHardeningRule(self.s0, self.Kp)
hmodel = hardening.Chaboche(iso, self.cs, self.gmodels, self.As,
self.ns)
flow = ri_flow.RateIndependentNonAssociativeHardening(surface, hmodel)
self.model = models.SmallStrainRateIndependentPlasticity(
self.elastic, flow, check_kt=False)
self.efinal = np.array([0.1, -0.05, 0.02, -0.03, 0.1, -0.15])
self.tfinal = 10.0
self.T = 300.0
self.nsteps = 30
def koo():
# Data from Koo & Kwon (2011)
E = 157.0e3
nu = 0.27
sY = 0.0
b = 3.0
Q = -80.0
C1 = 135.0e3
C2 = 123.0e3
C3 = 4.0e3
g1 = 100e3
g2 = 0.85e3
g3 = 1.0
eta = 701.0
n = 10.5
mu = E / (2 * (1.0 + nu))
K = E / (3 * (1 - 2 * nu))
elastic = elasticity.IsotropicLinearElasticModel(mu, "shear", K, "bulk")
surface = surfaces.IsoKinJ2()
iso = hardening.VoceIsotropicHardeningRule(sY, Q, b)
cs = [C1, C2, C3]
gs = [hardening.ConstantGamma(g1), hardening.ConstantGamma(g2),
hardening.ConstantGamma(g3)]
hmodel = hardening.Chaboche(iso, cs, gs, [0.0]*len(cs), [1.0]*len(cs))
fluidity = visco_flow.ConstantFluidity(eta)
vmodel = visco_flow.ChabocheFlowRule(
surface, hmodel, fluidity, n)
flow = general_flow.TVPFlowRule(elastic, vmodel)
model = models.GeneralIntegrator(elastic, flow)
e500 = np.array([0.0058793164, 0.0052876081, 0.004710156, 0.0042916722, 0.0038731605, 0.0032237573, 0.0027900399, 0.0024864991, 0.0017489338, 0.000635346, -0.0006668255, -0.0017811254, -0.0034891722, -0.0044012326, -0.0059358454, -0.005661599, -0.0051996206, -0.0048027165, -0.0044347716, -0.0039945684, -0.0034388636, -0.0032440594, -0.0026585856, -0.002036857, -0.001161945, -0.0003736313, 0.0008344368, 0.0022454705, 0.0035554683, 0.0052854997])
s500 = np.array([349.6965238343, 255.0932943767, 171.2928564634, 102.3697757811, 34.7967386021, -70.6166129529, -103.0909625627, -128.7931029969, -172.1191145041, -237.1093535238, -285.2558144812, -315.8199441656, -342.4341275638, -350.0133084444, -361.0726693423, -319.1748939033, -252.9445696747, -190.7753717856, -128.6110609317, -59.6843149729, 25.4625011672, 57.8965327357, 103.8969743143, 147.2034376803, 200.6779888803, 240.6374439409, 288.0930002819, 323.4323743399, 343.229143486, 357.0215788789])
res = drivers.strain_cyclic(model, 0.006, -1.0, 1.0e-4, 130,
verbose = False, nsteps = 50)
plt.plot(res['strain'][-100:], res['stress'][-100:], 'k-')
plt.plot(e500, s500, 'kx')
plt.xlabel("Strain (-/-)")
plt.ylabel("Stress (MPa)")
plt.show()
n500 = np.array([1.8000456006, 7.2646606231, 17.3775914892, 25.6289731945, 35.040864809, 43.9864865417, 54.6731673353, 69.3076477381, 83.9405590891, 98.1077889527, 112.0424068927, 126.7891398736])
ns500 = sn500 = np.array([437.8476941068, 428.2481618804, 413.6055992266, 403.8518586317, 394.8643791744, 388.2393032756, 382.3835530687, 376.4641827161, 372.5718311079, 370.2817510291, 368.4971998147, 367.5615301197])
plt.plot(res['cycles'], res['max'], 'k-')
plt.plot(n500, ns500, 'kx')
plt.xlabel("Cycle")
plt.ylabel("Stress (MPa)")
plt.show()
eta_m = visco_flow.ConstantFluidity(eta_interp)
flow_interp = interpolate.PiecewiseLinearInterpolate(
list(Ts_rate), flow_stress_values)
iso_rd = hardening.LinearIsotropicHardeningRule(0.0, -K / 10)
iso_ri = hardening.LinearIsotropicHardeningRule(
flow_interp, interpolate.ConstantInterpolate(-K / 10))
hmodel_rd = hardening.Chaboche(iso_rd, [K * 3.0 / 2.0],
[hardening.ConstantGamma(0.0)], [0.0],
[1.0])
hmodel_ri = hardening.Chaboche(iso_ri, [K * 3.0 / 2.0],
[hardening.ConstantGamma(0.0)], [0.0],
[1.0])
surface_m = surfaces.IsoKinJ2()
visco_flow_m = visco_flow.ChabocheFlowRule(surface_m, hmodel_rd, eta_m,
n_interp)
rd_flow = general_flow.TVPFlowRule(elastic_m, visco_flow_m)
rd_model = models.GeneralIntegrator(elastic_m, rd_flow)
ri_flow_m = ri_flow.RateIndependentNonAssociativeHardening(
surface_m, hmodel_ri)
ri_model = models.SmallStrainRateIndependentPlasticity(
elastic_m, ri_flow_m)
model = models.KMRegimeModel(elastic_m, [ri_model, rd_model], [g0], kboltz,
b, eps0)
smax = 400.0
def uniaxial():
# Data from "Numerical modeling of elasto-viscoplastic Chaboche constitutive..."
# by A. Ambroziak
E = 159000.0
nu = 0.3
k = 514.21
b = 60.0
R1 = -194.39
a = 170000.0
c = 500.0
n = 4.0
eta = 1023.5
# Translate
Q = R1
b = b
C1 = a
g1 = c
eta = eta
sY = k
mu = E / (2 * (1.0 + nu))
K = E / (3 * (1 - 2 * nu))
elastic = elasticity.IsotropicLinearElasticModel(mu, "shear", K, "bulk")
surface = surfaces.IsoKinJ2()
iso = hardening.VoceIsotropicHardeningRule(sY, Q, b)
cs = [C1]
gs = [hardening.ConstantGamma(g1)]
hmodel = hardening.Chaboche(iso, cs, gs, [0.0], [1.0])
fluidity = visco_flow.ConstantFluidity(eta)
vmodel = visco_flow.ChabocheFlowRule(
surface, hmodel, fluidity, n)
flow = general_flow.TVPFlowRule(elastic, vmodel)
model = models.GeneralIntegrator(elastic, flow)
erates = [1.0e-7, 1.0e-2, 1.0e-1]
e_7 = np.array([1.03E-007, 0.000977076, 0.0019927018, 0.0029695719, 0.0038278073, 0.0048024128, 0.0058155682, 0.0068186871, 0.0078116926, 0.0088238185, 0.0098260368, 0.0108280492, 0.0118396862, 0.0128318167, 0.0138433765, 0.0148451316, 0.0158469381, 0.0168487447, 0.017840798, 0.0188523063, 0.019844411])
s_7 = np.array([1.9738128815, 164.2845378653, 316.6592895303, 475.0018013938, 559.9786920852, 631.0205153016, 688.1581520788, 733.3950096246, 763.7549280987, 781.2104336727, 791.7254264156, 794.3039929179, 792.9104861704, 789.5405931218, 785.170926534, 777.8289602355, 772.4711004972, 767.1132407589, 760.7671878699, 754.413414722, 750.0514683933])
e_2 = np.array([-1.94E-005, 0.000976973, 0.0019830515, 0.0029890784, 0.0037900553, 0.0048443338, 0.0058197114, 0.0068040701, 0.0078172512, 0.0088300977, 0.0098231803, 0.0108257074, 0.0118377047, 0.0128397943, 0.0138612103, 0.0148630941, 0.0158551988, 0.0168667329, 0.017878267, 0.0188703202, 0.0198623735])
s_2 = np.array([-0.0025734197, 160.316324745, 319.6393095, 476.9781876949, 604.6365302068, 747.075308553, 847.8787301718, 919.9087465388, 978.0384365961, 1023.2714340124, 1056.6075123267, 1079.0271444306, 1091.5223836042, 1097.0771099468, 1097.66384963, 1095.2821497319, 1090.9202034031, 1085.5584835353, 1080.1967636674, 1073.8507107785, 1067.5046578896])
e_1 = np.array([-1.93E-005, 0.0009672712, 0.0019928047, 0.0029793251, 0.0037900295, 0.0047863804, 0.0058017489, 0.0068163453, 0.0078302727, 0.0088243075, 0.0098374371, 0.0108404531, 0.0118432376, 0.0128554407, 0.0138577362, 0.014850124, 0.01587154, 0.0168734495, 0.0178753075, 0.0188770883, 0.0198789206])
s_1 = np.array([2.9735864206, 161.3122381546, 320.6275026506, 475.9899945444, 603.6444769267, 762.9713218113, 905.4255406755, 1018.1181611373, 1105.0173963169, 1175.0594459942, 1231.2050294914, 1272.4736739169, 1304.8138388216, 1325.2455042359, 1338.7366568191, 1345.2872965712, 1345.8740362543, 1344.4843896363, 1341.1106364582, 1334.7607234397, 1330.3949169815])
plt.plot(e_7, s_7, 'kx')
plt.plot(e_2, s_2, 'rx')
plt.plot(e_1, s_1, 'bx')
res = drivers.uniaxial_test(model, erates[0], emax = 0.02)
plt.plot(res['strain'], res['stress'], 'k-')
res = drivers.uniaxial_test(model, erates[1], emax = 0.02)
plt.plot(res['strain'], res['stress'], 'r-')
res = drivers.uniaxial_test(model, erates[2], emax = 0.02)
plt.plot(res['strain'], res['stress'], 'b-')
plt.xlim([0,0.02])
plt.ylim([0,1500])
plt.show()
def setUp(self):
self.E = 92000.0
self.nu = 0.3
self.s0 = 180.0
self.Kp = 1000.0
self.H = 1000.0
self.elastic = elasticity.IsotropicLinearElasticModel(self.E, "youngs",
self.nu, "poissons")
surface = surfaces.IsoKinJ2()
iso = hardening.LinearIsotropicHardeningRule(self.s0, self.Kp)
kin = hardening.LinearKinematicHardeningRule(self.H)
hrule = hardening.CombinedHardeningRule(iso, kin)
flow = ri_flow.RateIndependentAssociativeFlow(surface, hrule)
self.bmodel = models.SmallStrainRateIndependentPlasticity(self.elastic,
flow)
self.fn = interpolate.PolynomialInterpolate([0.1,5.0, 1e-8])
self.n = 2.1
self.model = damage.NEMLWorkDamagedModel_sd(
self.elastic, self.fn, self.n, self.bmodel, verbose = False)
self.stress = np.array([100,-50.0,300.0,-99,50.0,125.0]) * 0.75
self.T = 100.0
self.s_np1 = self.stress
self.s_n = np.array([-25,150,250,-25,-100,25]) * 0.0
self.d_np1 = 0.2
self.d_n = 0.1
self.e_np1 = np.array([0.1,-0.01,0.15,-0.05,-0.1,0.15]) * 0.75
self.e_n = np.array([-0.05,0.025,-0.1,0.2,0.11,0.13]) * 0.0
self.T_np1 = self.T
self.T_n = 90.0
self.t_np1 = 5000.0
self.t_n = 0.9
self.u_n = 0.0
self.p_n = 0.0
# This is a rather boring baseline history state to probe, but I can't
# think of a better way to get a "generic" history from a generic model
self.hist_n = np.array([self.d_n] + list(self.bmodel.init_store()))
self.x_trial = np.array([50,-25,150,-150,190,100.0] + [0.41])
self.nsteps = 10
self.etarget = np.array([0.1,-0.025,0.02,0.015,-0.02,-0.05])
self.ttarget = 2.0
self.ee = np.dot(self.elastic.S(self.T_np1), self.s_np1*(1.0-self.d_np1) - self.s_n*(1.0-self.d_n))
self.de = self.e_np1 - self.e_n
self.dp = self.de - self.ee
self.dt = self.t_np1 - self.t_n
self.Wdot = np.dot(self.s_np1*(1.0-self.d_np1), self.dp) / self.dt
def setUp(self):
# Fully-defined perfectly plastic model
Epoly = [-78.2759, 236951.0]
nu = 0.3
A = -9.6187
B = -1.4819
C = -5.0486
g0 = 0.3708
b = 0.248 * 1.0e-6
kboltz = 1.38064e-23 * 1000.0
eps0 = 1.0e10
# Temperature range over which to consider (K)
Tmin = 550.0
Tmax = 950.0
Trange = np.linspace(Tmin, Tmax)
# Elastic
E_m = interpolate.PolynomialInterpolate(Epoly)
nu_m = interpolate.ConstantInterpolate(nu)
elastic_m = elasticity.IsotropicLinearElasticModel(
E_m, "youngs", nu_m, "poissons")
self.elastic = elastic_m
# Rate sensitivity interpolates values
mu_values = np.array([elastic_m.G(T) for T in Trange])
n_values = -mu_values * b**3.0 / (kboltz * Trange * A)
eta_values = np.exp(B) * eps0**(kboltz * Trange * A /
(mu_values * b**3.0)) * mu_values
# Rate independent interpolate values
flow_stress = mu_values * np.exp(C)
# Common objects
surface = surfaces.IsoKinJ2()
hmodulus = interpolate.PolynomialInterpolate([-10.0, 12000.0])
# Setup visco model
n_interp = interpolate.PiecewiseLinearInterpolate(
list(Trange), list(n_values))
eta_interp = interpolate.PiecewiseLinearInterpolate(
list(Trange), list(eta_values))
eta_m = visco_flow.ConstantFluidity(eta_interp)
iso_rd = hardening.LinearIsotropicHardeningRule(
interpolate.ConstantInterpolate(0.0), hmodulus)
hard_rd = hardening.Chaboche(
iso_rd, [interpolate.ConstantInterpolate(0.0)],
[hardening.ConstantGamma(interpolate.ConstantInterpolate(0.0))],
[interpolate.ConstantInterpolate(0.0)],
[interpolate.ConstantInterpolate(1.0)])
visco_rd = visco_flow.ChabocheFlowRule(surface, hard_rd, eta_m,
n_interp)
general_rd = general_flow.TVPFlowRule(elastic_m, visco_rd)
rate_dependent = models.GeneralIntegrator(elastic_m, general_rd)
# Setup rate independent
sy_interp = interpolate.PiecewiseLinearInterpolate(
list(Trange), list(flow_stress))
iso_ri = hardening.LinearIsotropicHardeningRule(sy_interp, hmodulus)
hard_ri = hardening.Chaboche(
iso_ri, [interpolate.ConstantInterpolate(0.0)],
[hardening.ConstantGamma(interpolate.ConstantInterpolate(0.0))],
[interpolate.ConstantInterpolate(0.0)],
[interpolate.ConstantInterpolate(1.0)])
flow_ri = ri_flow.RateIndependentNonAssociativeHardening(
surface, hard_ri)
rate_independent = models.SmallStrainRateIndependentPlasticity(
elastic_m, flow_ri)
# Combined model
self.model = models.KMRegimeModel(elastic_m,
[rate_independent, rate_dependent],
[g0], kboltz, b, eps0)
self.efinal = np.array([0.05, 0, 0, 0.02, 0, -0.01])
self.tfinal = 10.0
self.T = 700.0
self.nsteps = 100
n = 20.0
eta = 108.0
sY = 89.0
Q = 165.0
b = 12.0
C1 = 80.0e3
C2 = 14.02e3
C3 = 3.333e3
y1 = 0.9e3
y2 = 1.5e3
y3 = 1.0
surface = surfaces.IsoKinJ2()
iso = hardening.VoceIsotropicHardeningRule(sY, Q, b)
cs = [C1, C2, C3]
gs = np.array([y1, y2, y3])
gmodels = [hardening.ConstantGamma(g) for g in gs]
hmodel = hardening.Chaboche(iso, cs, gmodels, [0.0] * len(cs),
[1.0] * len(cs))
fluidity = visco_flow.ConstantFluidity(eta)
vmodel = visco_flow.ChabocheFlowRule(surface, hmodel, fluidity, n)
E = 92000.0
nu = 0.3
mu = E / (2 * (1 + nu))
