python_material_stochastic_plasticity_test.py
acf23313876emaster

python_material_stochastic_plasticity_test.py
View Options

			#!/usr/bin/env python3
			# -- coding:utf-8 --
			"""
			@file python_material_stochastic_plasticity.py

			@author Richard Leute <richard.leute@imtek.uni-freiburg.de>

			@date 25 Jan 2019

			@brief tests material_stochastic_plasticity for a single pixel.

			@section LICENSE

			Copyright © 2019 Till Junge

			µSpectre is free software; you can redistribute it and/or
			modify it under the terms of the GNU General Public License as
			published by the Free Software Foundation, either version 3, or (at
			your option) any later version.

			µSpectre is distributed in the hope that it will be useful, but
			WITHOUT ANY WARRANTY; without even the implied warranty of
			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
			General Public License for more details.

			You should have received a copy of the GNU General Public License
			along with µSpectre; see the file COPYING. If not, write to the
			Free Software Foundation, Inc., 59 Temple Place - Suite 330,
			Boston, MA 02111-1307, USA.

			Additional permission under GNU GPL version 3 section 7

			If you modify this Program, or any covered work, by linking or combining it
			with proprietary FFT implementations or numerical libraries, containing parts
			covered by the terms of those libraries' licenses, the licensors of this
			Program grant you additional permission to convey the resulting work.
			"""


			import unittest
			import numpy as np
			from muSpectre import material
			from muSpectre import Formulation
			from python_test_imports import µ

			class MaterialStochasticPlasticity_Check(unittest.TestCase):
			def setUp(self):
			self.young, self.poisson = 210e9, .33
			self.plastic_increment = 0.1
			self.yield_stress = 1.6e9
			self.eigen_strain = np.array([[.01, .002], [.002, 0.]])

			#compute first (lam) and second (mu) Lame constants
			#self.lam = (self.young * self.poisson) / \
			# ((1+self.poisson)(1-2self.poisson))
			#self.mu = self.young / (2*(1+self.poisson))

			self.dim = 2 #spatial dimension
			self.rank_2_unit = np.eye(self.dim)

			def test_plastic_deformation(self):
			#Set up a material evaluator (first test for material_linear_elastic2,
			#later replace by material_stochastic_plasticity)

			LinMat2 = material.MaterialLinearElastic2_2d
			StochPlastMat = material.MaterialStochasticPlasticity_2d

			#the factory returns a material and it's corresponding evaluator
			material2, evaluator2 = LinMat2.make_evaluator(self.young, self.poisson)

			materialSP, evaluatorSP = StochPlastMat.make_evaluator()

			#the material is empty(i.e., does not have any pixel / voxel), so a pixel
			#needs to be added.The coordinates are irrelevant, there just needs to
			#be one pixel.
			# when adding the pixel, we now need to specify also the per-pixel data:
			material2.add_pixel([0,0], self.eigen_strain)
			materialSP.add_pixel([0,0], self.young, self.poisson,
			self.plastic_increment, self.yield_stress,
			self.eigen_strain)

			# the stress and tangent can be evaluated for finite strain
			F = np.array([[1., .01],[0, 1.0]])
			P_L2, K_L2 = \
			evaluator2.evaluate_stress_tangent(F, Formulation.finite_strain)
			print("\nPiola Kirchhoff 1 or 2 ?? linear elasticity 2 python output:\n"
			, P_L2)
			P_SP, K_SP = \
			evaluatorSP.evaluate_stress_tangent(F, Formulation.finite_strain)
			print("Piola Kirchhoff 1 or 2 ?? stochastic plasticity python output:\n"
			, P_SP)

			#Compute the criteria for a plastic deformation,
			#compute the Couchy stress (sigma=1/J*P.F^T) ,J=det(F)
			sigma = 1/np.linalg.det(F) * np.dot(P_SP, F.T)
			#deviatoric stress (sigma_dev=sigma-1/DTr(sigma)I)
			sigma_dev = sigma - 1/self.dim * np.trace(sigma) * self.rank_2_unit
			#the equivalent stress (sigma_eq=sqrt(3/2*sigma_dev:sigma_dev))
			sigma_eq = np.sqrt(3/2 * np.tensordot(sigma_dev, sigma_dev))

			print("equivalent stress: ", sigma_eq,
			"\nyield stress: ", self.yield_stress)


			# Check member function "identify_overloaded_pixels"
			# I first have to handle the conversion of numpy.ndarray -> muSpectre::
			# TensorField<muSpectre::GlobalFieldCollection<2>, double, 2, 2>
			#convert to accepted shape (m,1)
			#function needs a cell
			#overloaded_pixels = \
			# materialSP.identify_overloaded_pixels(P_SP.reshape(-1,1))
			#print("overloaded_pixels: ", overloaded_pixels)

			### initialise material with a cell
			res = [1,1]
			lens = [1,1]
			formulation = µ.Formulation.finite_strain
			cell = µ.Cell(res, lens, formulation)
			mat = µ.material.MaterialStochasticPlasticity_2d.make(
			cell, "materialstochplast")
			#mat.add_pixel([0,0], self.young, self.poisson,
			# self.plastic_increment, self.yield_stress,
			# self.eigen_strain)

			#solver
			#newton_tol = 1e-6 #tolerance for newton algo
			#cg_tol = 1e-6 #tolerance for cg algo
			#equil_tol = 1e-6 #tolerance for equilibrium
			#maxiter = 100
			#verbose = 0
			#solver_newton = µ.solvers.SolverCG(cell, cg_tol, maxiter, verbose)
			#result = µ.solvers.newton_cg(cell, F, solver_newton,
			# newton_tol, equil_tol, verbose)

			overloaded_pixels = \
			materialSP.identify_overloaded_pixels(cell, P_SP.reshape(-1,1))
			print("overloaded_pixels: ", overloaded_pixels)

muSpectre/tests/python_material_stochastic_plasticity_test.pyacf23313876emaster

python_material_stochastic_plasticity_test.pyView Options

muSpectre/tests/python_material_stochastic_plasticity_test.py
acf23313876emaster

python_material_stochastic_plasticity_test.py
View Options