def _modelMemoryUse(self):
"""
Model allocated memory.
"""
Material._modelMemoryUse(self)
self.perfLogger.logFields('Materials', self.initialFields())
return
def saveMaterials(self):
for m in self.parser.object.materials:
self.saveTextures(m)
material = Material(m.name)
if m.textureMap1:
material.texture = self.textureMng.get(m.textureMap1.name)
self.materialMng.add(material)
def generate_flatpin_bandstructure(mat, Lp,Aname,Na, Li, Ln,Dname,Nd, Va):
# The Material class will find the bulk energy levels
mp=Material(mat,{Aname:Na})
mn=Material(mat,{Dname:Nd})
# Band edges far on the p and n side
Ecp=mp.Ec-mp.EBulk-Va/2
Evp=mp.Ev-mp.EBulk-Va/2
Ecn=mn.Ec-mn.EBulk+Va/2
Evn=mn.Ev-mn.EBulk+Va/2
# x-grid for the calculation
x=np.linspace(-Lp-Li/2,Ln+Li/2,50000)
return {"x":x,\
# np.piecewise linear functions for the conduction band and valence band
"Ec": np.piecewise(x,
[x<-Li/2, (x>=-Li/2)&(x<Li/2), (x>=Li/2)],
[lambda x: Ecp, lambda x: Ecp+(Ecn-Ecp)*(x+Li/2)/Li, lambda x: Ecn]),\
"Ev": np.piecewise(x,
[x<-Li/2, (x>=-Li/2)&(x<Li/2), (x>=Li/2)],
[lambda x: Evp, lambda x: Evp+(Evn-Evp)*(x+Li/2)/Li, lambda x: Evn]),\
# The Fermi levels, only given in the p and n regions
"EB": np.piecewise(x,
[x<-Li/2, (x>=-Li/2)&(x<Li/2), (x>=Li/2)],
[lambda x: -Va/2, lambda x: np.NaN, lambda x: Va/2]),\
# The reverse bias
"Vr": -Va,
# The material
"material": mp}
def buildScene():
"""creates all the Objects in the Scene"""
cam = Camera.Camera(Vector((0, 1.8, 10)), Vector((0, 3, 0)),
Vector((0, 1, 0)), 45, 300, 400)
lightlist = []
lightlist.append(Vector((30, 30, 50)))
objectlist = []
plane = Plane(Vector((0, 0, 0)), Vector((0, 1, 0)),
CheckerboardMaterial(0.5, 0.8, 1))
sphere1 = Sphere(Vector((-1.5, 3, 0)), 1,
Material(0.3, 0.4, 0.1, Vector((255, 0, 0))))
sphere2 = Sphere(Vector((1.5, 3, 0)), 1,
Material(0.3, 0.4, 0.1, Vector((0, 255, 0))))
sphere3 = Sphere(Vector((0, 5.5, 0)), 1,
Material(0.3, 0.4, 0.1, Vector((0, 0, 255))))
triangle = Triangle(Vector((-1.5, 3, 0)), Vector((1.5, 3, 0.1)),
Vector((0, 5.5, 0)),
Material(0.2, 0.4, 1, Vector((255, 255, 0))))
objectlist.append(plane)
objectlist.append(sphere1)
objectlist.append(sphere2)
objectlist.append(sphere3)
objectlist.append(triangle)
renderScene(cam, objectlist, lightlist)
def __init__(self):
self.width = 400
self.height = 400
self.e = np.array([0, 1.8, 10])
self.c = np.array([0, 3, 0])
self.up = np.array([0, 1, 0])
self.fov = 45
self.image = np.zeros((self.height, self.width, 3))
self.background = np.array([0, 0, 0])
self.camera = Camera(self.e, self.c, self.up, self.fov, 1, self.height,
self.width)
self.light = Light(np.array([30, 30, 10]), np.array([255, 255, 255]))
reflecting = True
checkerboard = True
self.objectlist = [
Sphere(np.array([0, 3, 1]), 1,
Material(np.array([255, 0, 0]), reflecting)),
Sphere(np.array([-1.5, 0.5, 1]), 1,
Material(np.array([0, 255, 0]), reflecting)),
Sphere(np.array([1.5, 0.5, 1]), 1,
Material(np.array([0, 0, 255]), reflecting)),
Triangle(np.array([1.5, 0.5, 0.5]), np.array([0, 3, 0.5]),
np.array([-1.5, 0.5, 0.5]),
Material(np.array([255, 255, 0]), False))
]
if checkerboard:
plane = Plane(np.array([0, -1, 0]), np.array([0, 1, 0]),
CheckerBoardMaterial(False))
else:
plane = Plane(np.array([0, -1, 0]), np.array([0, 1, 0]),
Material(np.array([128, 128, 128]), False))
self.objectlist.append(plane)
def _modelMemoryUse(self):
"""
Model allocated memory.
"""
Material._modelMemoryUse(self)
self.perfLogger.logFields('Materials', self.initialFields())
return
def __init__(self, x, y):
self.x = x
self.y = y
self.base_object = {}
self.food_on_map = Food()
self.material_on_map = Material()
self.symbol = "X"
def main():
print 'Testing Tube'
a = Tube(np.array([5., 6.]),
np.array([0.10, 0.10]),
np.array([10., 10]),
mat=Material(matname='heavySteel'))
print 'Area and PSEUDOMass of tube a', a.Area, a.pseudomass
b = Tube(3., 0.10, 10., mat=Material(matname='heavySteel'))
print 'Area and PSEUDOMass of tube b', b.Area, b.pseudomass
def __init__(self, obj, system):
Material.__init__(self, obj, system)
obj.addProperty("App::PropertyFloat", "Young", "Solid",
"Young's modulus").Young = 0.0
obj.addProperty("App::PropertyFloat", "Shear", "Solid",
"Shear modulus").Shear = 0.0
obj.addProperty("App::PropertyFloat", "Poisson", "Solid",
"Poisson's ratio").Poisson = 0.0
def onChanged(self, obj, prop):
Material.onChanged(self, obj, prop)
if prop == 'Young':
obj.Proxy.young = obj.Young
elif prop == 'Shear':
obj.Proxy.shear = obj.Shear
elif prop == 'Poisson':
obj.Proxy.poisson = obj.Poisson
def onChanged(self, obj, prop):
Material.onChanged(self, obj, prop)
if prop == 'Young':
obj.Proxy.young = obj.Young
elif prop == 'Shear':
obj.Proxy.shear = obj.Shear
elif prop == 'Poisson':
obj.Proxy.poisson = obj.Poisson
def fill_material_list(index, list):
for i in range(len(list)):
material_list[index].append(
Material(list[i].get(), workstation_buffer_list[index],
material_type_list[index]))
workstation_buffer_list[index].products.append(
Material(list[i].get(), workstation_buffer_list[index],
material_type_list[index]))
display_material()
def _configure(self):
"""
Setup members using inventory.
"""
Material._configure(self)
self.output = self.inventory.output
from pylith.utils.NullComponent import NullComponent
if not isinstance(self.inventory.dbInitialStress, NullComponent):
self.dbInitialStress(self.inventory.dbInitialStress)
if not isinstance(self.inventory.dbInitialStrain, NullComponent):
self.dbInitialStrain(self.inventory.dbInitialStrain)
return
def _configure(self):
"""
Setup members using inventory.
"""
Material._configure(self)
self.output = self.inventory.output
from pylith.utils.NullComponent import NullComponent
if not isinstance(self.inventory.dbInitialStress, NullComponent):
self.dbInitialStress(self.inventory.dbInitialStress)
if not isinstance(self.inventory.dbInitialStrain, NullComponent):
self.dbInitialStrain(self.inventory.dbInitialStrain)
return
def __init__(self):
self.__material = Material(None)
self.__previousMaterial = Material(None)
glEnable(GL_DEPTH_TEST)
glEnable(GL_TEXTURE_2D)
glEnable(GL_LIGHTING)
glEnable(GL_LIGHT0)
glEnable(GL_AUTO_NORMAL)
glEnable(GL_NORMALIZE)
glEnable(GL_CULL_FACE)
glClearDepth(1.0)
def _check_default_material(self, name):
test_material = Material()
print("\nExpected:")
print(test_material)
print("\nGot:")
print(getattr(world, name))
assert getattr(world, name) == test_material
def __init__(self,
fanout,
depth,
spread=default_spread,
rootColor=default_rootColor,
edgeColor=default_edgeColor,
scale=default_scale,
actor=None):
Component.__init__(self, actor)
self.fanout = fanout
self.depth = depth
self.spread = spread
self.rootColor = rootColor
self.edgeColor = edgeColor
self.scale = scale
self.rootScale = self.scale # NOTE this will also apply to children
#self.childScale = np.float32([1.0, 1.0, 1.0]) # NOTE this will get compounded if the radial tree is a true hierarchy, better to use scale = 1 (default)
# Recursively generate radial tree
treeRoot = self.createRadialTree(
self.fanout, self.depth, self.spread,
isRoot=True) # creates full hierarchy and returns root actor
treeRoot.components['Transform'] = Transform(
rotation=np.random.uniform(-pi / 2, pi / 2, size=3),
scale=self.rootScale,
actor=treeRoot
) # NOTE random rotation ensures child vectors are not always generated close to the same canonical vectors
treeRoot.components['Material'] = Material(color=self.rootColor,
actor=treeRoot)
treeRoot.components['Mesh'] = Mesh.getMesh(src=self.treeRootModelFile,
actor=treeRoot)
# Attach this hierarchy to current actor
self.actor.children.append(treeRoot)
class Ground():
def __init__(self, x, y):
self.x = x
self.y = y
self.base_object = {}
self.food_on_map = Food()
self.material_on_map = Material()
self.symbol = "X"
def build_construction(self, building_class, fraction): #budowanie
"""Buduje budynek, dodaje jego symbol i wartość do słownika i zwraca ten słownik."""
self.building = building_class
self.building.build(fraction) #zbudowanie budynku
self.building_dict = {}
self.building = self.building.add_building(
fraction) #dodanie do słownika danych budynku
return self.building
def update_object_new(
self): #zaktualizowanie słownika na obszarze przy rysowaniu mapy
"""Metoda aktualizująca słownik pola o losowe wartości jedzenia i materiałów."""
self.base_object.update(self.food_on_map.generate())
self.base_object.update(self.material_on_map.generate())
def update_object(
self, obj): #aktualizowanie oobszaru na mapie np. przy budowaniu
"""Metoda aktualizująca słownik o zadaną wartość."""
self.base_object.update(obj)
def __init__(self, primitive, vertices, indices):
'''
@param vertices: Arreglo numpy unidimensional con los datos de vertices, en el formato (X, Y, Z, NX, NY, NZ, TU, TV), todos
de tipo numpy.float32.
@param indices: Arreglo numpy unidimencional con la informacion de indexacion de la geometria.
'''
self.__material = Material(None)
self.__vertices = vertices
self.__indices = indices
self.__primitive = primitive
# inicializa el buffer de vertices
size = vertices.size * 4
bufferId = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, bufferId)
glBufferData(GL_ARRAY_BUFFER, vertices.size * 4, vertices,
GL_STATIC_DRAW)
# inicializa el buffer de indices
if indices is None:
ibufferId = 0
else:
ibufferId = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibufferId)
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size * 4, indices,
GL_STATIC_DRAW)
self.__bufferId = bufferId
self.__ibufferId = ibufferId
def saveMaterials(self):
for m in self.parser.object.materials:
self.saveTextures(m)
material = Material(m.name)
material.ambient = m.ambientColor + [0]
material.diffuse = m.diffuseColor + [0]
material.specular = m.specularColor + [0]
if m.textureMap1:
material.texture = self.textureMng.get(m.textureMap1.name)
if m.bumpMap:
material.bump = self.textureMng.get(m.bumpMap.name)
material.init()
self.materialMng.add(material)
def output_bgf(name, atoms):
from Material import Material
from vimmLib import save_file
mat = Material(name)
for atom in atoms:
mat.add_atom(atom)
mat.bonds_from_distance()
save_file(name + '.bgf', mat)
return
def AddMaterial(self, PK, name, quantity, vendor, unitCost):
"""
This will add a material to this Product's list of materials. If the material already exists,
then its quantity will be added to the first material object.
@param PK The primary key (string) for the material in the database.
@param name A string representing the name of the material.
@param quantity An integer representing the amount of <some material> needed for a single one of this product.
The material's quantity will be static and won't be changed along with the Product's quantity!
@param vendor A string representing the name of the vendor that supplies this material.
@param unitCost The cost for a single one of this material. A float or integer is assumed.
"""
material = self.GetMaterial(PK)
if (material == None):
self.materials.append(Material(PK, name, quantity, vendor, unitCost))
else:
material.quantity += quantity
def __init__(self,
D,
t,
Lgth=np.NaN,
Kbuck=1.,
mat=Material(name='ASTM992 steel')):
self.D = D
self.t = t
self.L = Lgth * np.ones(
np.size(D)) #this makes sure we exapnd Lght if D,t, arrays
self.Kbuck = Kbuck * np.ones(
np.size(D)) #this makes sure we exapnd Kbuck if D,t, arrays
self.mat = mat
if np.size(D) > 1 and type(
mat
) != np.ndarray: #in this case I need to make sure we have a list of materials
import copy
self.mat = np.array([copy.copy(mat) for i in xrange(np.size(D))])
def simple_loader(geo):
from Material import Material
from Atom import Atom
from Utilities import path_split, cleansym
from Element import sym2no, symbol
from NumWrap import array
material = Material("vimm")
for sym, xyz in geo:
sym = sym
atno = sym2no[sym]
xyz = array(xyz)
material.add_atom(Atom(atno, xyz, sym, sym))
material.bonds_from_distance()
return material
def import_bd(filename, xmin=-1e10, xmax=1e10, center=0):
with open(filename) as f:
data = []
for l in f:
mo=re.match("\s*([\d\.e+-]+)\s+([\d\.e+-]+)\s+([\d\.e+-]+)\s+([\d\.e+-]+)\s+"\
"([\d\.e+-]+)\s+([\d\.e+-]+)\s+([\d\.e+-]+)\s+([\d\.e+-]+)\s+", l)
if mo:
x = float(mo.groups()[0])
if (x >= xmin and x <= xmax):
data += [[float(a) for a in mo.groups()]]
data[-1][0] = (x - center) / 1e8
data = np.array(data)
#print data
bd = {}
bd["x"] = data[:, 0]
bd["Ec"] = data[:, 1]
bd["Ev"] = data[:, 2]
bd["F"] = data[:, 3]
bd["Ef"] = data[:, 4]
bd["n"] = data[:, 5]
bd["p"] = data[:, 6]
bd["material"] = Material("GaN")
return bd
def execute(self, obj):
Material.execute(self, obj)
####class MaterialSolid(Material):
####"""
####Solid material class
####"""
##### Elastic moduli
####_young = None
####_bulk = None
####_shear = None
####_poisson = None
####_isotropic = True # Whether the material is isotropic or not.
#####_tensile_strength_break = None
#####_tensile_strength_yield = None
#####_tensile_strength_ultimate = None
#####_tensile_elongation_break = None
#####_tensile_elongation_yield = None
#####_tensile_elongation_ultimate = None
####def _get_isotropic(self):
####"""
####Return whether the solid is isotropic or not.
####"""
#####if self._isotropic is not None:
####return self._isotropic
####def _set_isotropic(self, x):
####"""
####Set whether the solid is isotropic or not.
####:param x: is a boolean
####"""
####if type(x) is bool: # Perhaps use a try here?
####self._isotropic = x
####isotropic = property(fget=_get_isotropic, fset=_set_isotropic)
####"""
####Isotropic material or not.
####"""
####def elastic_moduli_given(self):
####"""
####Returns the amount of elastic module that were specified.
####"""
####return (bool(self._young) + bool(self._bulk) + bool(self._shear) + bool(self._poisson))
####def _del_elastic_moduli(attr):
####def del_attr(self):
####setattr(self, attr, None) # Check first whether it can actually be deleted? E.g. when it has not been set at all.
####return del_attr
####def _set_elastic_moduli(attr):
####def set_attr(self, x):
####if self.elastic_moduli_given() < 2: #and isinstance(x, float):
####setattr(self, attr, x)
####else:
####warnings.warn('Two elastic moduli have already been set. Please delete one before adding a new one.')
####return set_attr
####def _get_elastic_moduli(attr):
####"""Retrieve the value of the elastic modulus. Check first whether the value is stored. If not, calculate it from two given moduli."""
####def get_attr(self):
####if getattr(self, attr) is not None:
####return getattr(self, attr) # then we should return it instead of trying to calculate it.
####elif self.isotropic and self.elastic_moduli_given() >= 2: # But only when isotropic!!!
##### Calculate Bulk
####if bool(attr =='_bulk' and self._young and self._shear):
####return (self.young * self.shear) / (9.0 * self.shear - 3.0 * self.young)
####elif bool(attr =='_bulk' and self._young and self._poisson):
####return (self.young) / (3.0 - 6.0 * self.poisson)
####elif bool(attr =='_bulk' and self._shear and self._poisson):
####return 2.0 * self.shear * (1.0 + self.poisson) / (3.0 - 6.0 * self.poisson)
##### Calculate Young
####elif bool(attr =='_young' and self._bulk and self._shear):
####return 9.0 * self.bulk * self.shear / (3.0 * self.bulk + self.shear)
####elif bool(attr =='_young' and self._bulk and self._poisson):
####return 3.0 * self.bulk * (1.0 - 2.0 * self.poisson)
####elif bool(attr =='_young' and self._shear and self._poisson):
####return 2.0 * self.shear * (1.0 + self.poisson)
##### Calculate Shear
####elif bool(attr =='_shear' and self._bulk and self._young):
####return 3.0 * self.bulk * self.young / (9 * self.bulk - self.young)
####elif bool(attr =='_shear' and self._bulk and self._poisson):
####return 3.0 * self.bulk * (1.0 - 2.0 * self.poisson) / (2.0 + 2.0 * self.poisson)
####elif bool(attr =='_shear' and self._young and self._poisson):
####return self.young / (2.0 + 2.0 * self.poisson)
##### Calculate Poisson
####elif bool(attr =='_poisson' and self._bulk and self._young):
####return ( 3.0 * self.bulk - self.young) / (6.0 * self.bulk)
####elif bool(attr =='_poisson' and self._bulk and self._shear):
####return (3.0 * self.bulk - 2.0 * self.shear) / (6.0 * self.bulk + 2.0 * self.shear)
####elif bool(attr =='_poisson' and self._young and self._shear):
####return (self.young) / (2.0*self.shear) - 1.0
####else:
####ValueError
####else:
####warnings.warn('The modulus was not given for this material and could not be calculated either.')
####return get_attr
####young = property(fget=_get_elastic_moduli('_young'), fset=_set_elastic_moduli('_young'), fdel=_del_elastic_moduli('_young')) # Young's modulus, or Tensile modulus
####"""
####Young's modulus :math:`E`.
####The value can be set or calculated when the material is isotropic and elastic_moduli_given equals two.
####"""
####bulk = property(fget=_get_elastic_moduli('_bulk'), fset=_set_elastic_moduli('_bulk'), fdel=_del_elastic_moduli('_bulk')) # Bulk modulus
####"""
####Bulk modulus :math:`K`
####The value can be set or calculated when the material is isotropic and elastic_moduli_given equals two.
####"""
####shear = property(fget=_get_elastic_moduli('_shear'), fset=_set_elastic_moduli('_shear'), fdel=_del_elastic_moduli('_shear')) # Shear modulus
####"""
####Shear modulus :math:`G`
####The value can be set or calculated when the material is isotropic and elastic_moduli_given equals two.
####"""
####poisson = property(fget=_get_elastic_moduli('_poisson'), fset=_set_elastic_moduli('_poisson'), fdel=_del_elastic_moduli('_poisson')) # Poisson modulus
####"""
####Poisson ratio :math:`\\nu`
####The value can be set or calculated when the material is isotropic and elastic_moduli_given equals two.
####"""
def __init__(self, name="elasticmaterial"):
"""
Constructor.
"""
Material.__init__(self, name)
return
# -*- coding: utf-8 -*-
"""
Created on Thu Jun 22 06:06:01 2017
@author: Loukit
"""
from Material import Material, ElasticMaterial
import numpy as np
m1 = ElasticMaterial('threed', 10e6, 0.2, 1e7)
elastic = np.zeros((6, 6))
m2.ElasticityMatrix(elastic)
print(elastic)
m1 = ElasticMaterial('threed', 10e6, 0.2, 1e7)
print(m1.sigY)
m2 = Material.newMaterial('elastic', 'threed')
m2.setElasticProperties(10e6, 0.2, 1e7)
def workbench(name,
loading_cycles=None,
copy=True,
film_coefficient=0.0,
sink_temperature=0.0,
temperature_list=[],
thermal_strain_list=[0.0, -0.0],
heat_flux=0.0,
film_coefficient_outer=0.0,
film_coefficient_inner=0.0,
emissivity=0.95,
sink_temperature_inner=293.15,
sink_temperature_outer=293.15,
outer_temperature=293.15):
"""
某试件对应的边界条件下的数值模拟。
"""
experiment_log = ExperimentLog(ExperimentLogFile)
experiment_log.output(name)
regular = r'.*'
load_type = experiment_log.obtainItem(name, 'load_type', regular)[0]
regular = r'\d+\.?\d*'
temperature_mode = experiment_log.obtainItem(name, 'temperature_mode',
regular)
if temperature_list == []:
if len(temperature_mode) == 1:
temperature_list = [
float(temperature_mode[0]),
float(temperature_mode[0])
]
if len(temperature_mode) == 2:
temperature_list = [
float(temperature_mode[0]),
float(temperature_mode[1])
]
d_out = float(experiment_log.obtainItem(name, 'd_out', regular)[0])
gauge_length = float(
experiment_log.obtainItem(name, 'gauge_length', regular)[0])
axial_strain = float(
experiment_log.obtainItem(name, 'axial_strain', regular)[0])
angel_strain = float(
experiment_log.obtainItem(name, 'angel_strain', regular)[0])
equivalent_strain = float(
experiment_log.obtainItem(name, 'equivalent_strain', regular)[0])
period = float(experiment_log.obtainItem(name, 'period', regular)[0])
axial_temperature_phase = float(
experiment_log.obtainItem(name, 'axial_temperature_phase', regular)[0])
life = float(experiment_log.obtainItem(name, 'comments', regular)[0])
#==============================================================================
# material
#==============================================================================
material = Material()
material.setName(name='IN718')
material.setTemperature(temperature=650.0)
material.setMonotonic(youngs_modulus=167100.0,
poisson_ratio=0.2886,
yield_stress=1064.0)
material.setCyclicAxial(sigma_f=1034.0,
b=-0.04486,
epsilon_f=0.11499,
c=-0.52436)
material.setCyclicTorsion(tau_f=1034.0 / np.sqrt(3),
b0=-0.04486,
gamma_f=0.11499 * np.sqrt(3),
c0=-0.52436)
predicted_life = material.calculateMansonCoffinLife(equivalent_strain /
100.0)
#==============================================================================
# experiment
#==============================================================================
exp_full_name = ExperimentDirectory + name + '.csv'
if os.path.exists(exp_full_name):
exp = ExperimentData(exp_full_name)
experimental_life = exp.total_axial_count
else:
print('%s is not existed' % exp_full_name)
#==============================================================================
# load
#==============================================================================
temperature_mean = (temperature_list[0] + temperature_list[1]) / 2.0
temperature_min = min(temperature_list)
temperature_max = max(temperature_list)
load = Load(runing_time=[0],
temperature=[temperature_mean],
axial_strain=[0],
shear_strain=[0],
first_cycle_shift=1)
axial_strain = axial_strain / 100.0
shear_strain = np.deg2rad(angel_strain) * d_out / 2.0 / gauge_length
if loading_cycles == None:
loading_cycles = min(int(predicted_life / 4.0), 5000)
use_exp_data = True
thermal_strain_min = min(thermal_strain_list) / 100.0
thermal_strain_max = max(thermal_strain_list) / 100.0
#==============================================================================
# Diamond path TMF IP
#==============================================================================
if load_type == 'cyclic diamond path' and axial_temperature_phase == 0.0:
use_exp_data = False
load.setLoadBiaxial(
int(loading_cycles),
[0, period / 4.0, period / 2.0, period / 4.0 * 3.0, period], [
temperature_mean, temperature_max, temperature_mean,
temperature_min, temperature_mean
], [0, axial_strain, 0, -1 * axial_strain, 0],
[-1 * shear_strain, 0, shear_strain, 0, -1 * shear_strain])
#==============================================================================
# Proportional path TMF IP
#==============================================================================
if load_type == 'cyclic proportional path' and axial_temperature_phase == 0.0:
use_exp_data = False
load.setLoadBiaxial(
int(loading_cycles),
[0, period / 4.0, period / 2.0, period / 4.0 * 3.0, period], [
temperature_mean, temperature_max, temperature_mean,
temperature_min, temperature_mean
], [0, axial_strain, 0, -1 * axial_strain, 0],
[0, shear_strain, 0, -1 * shear_strain, 0])
#==============================================================================
# Uniaxial TMF IP
#==============================================================================
if load_type == 'cyclic tension compression' and axial_temperature_phase == 0.0:
use_exp_data = False
load.setLoadBiaxial(
int(loading_cycles),
[0, period / 4.0, period / 2.0, period / 4.0 * 3.0, period], [
temperature_mean, temperature_max, temperature_mean,
temperature_min, temperature_mean
], [0, axial_strain * 1, 0, -1 * axial_strain * 1, 0],
[0, shear_strain, 0, -1 * shear_strain, 0])
#==============================================================================
# Uniaxial TMF OP
#==============================================================================
if load_type == 'cyclic tension compression' and axial_temperature_phase == 180.0:
use_exp_data = False
load.setLoadBiaxial(
int(loading_cycles),
[0, period / 4.0, period / 2.0, period / 4.0 * 3.0, period], [
temperature_mean, temperature_min, temperature_mean,
temperature_max, temperature_mean
], [0, axial_strain, 0, -1 * axial_strain, 0],
[0, shear_strain, 0, -1 * shear_strain, 0])
#==============================================================================
# Uniaxial TMF 90
#==============================================================================
if load_type == 'cyclic tension compression' and axial_temperature_phase == 90.0:
use_exp_data = False
load.setLoadBiaxial(
int(loading_cycles),
[0, period / 4.0, period / 2.0, period / 4.0 * 3.0, period], [
temperature_min, temperature_mean, temperature_max,
temperature_mean, temperature_min
], [0, axial_strain, 0, -1 * axial_strain, 0],
[0, shear_strain, 0, -1 * shear_strain, 0])
#==============================================================================
# load from experiment data
#==============================================================================
if use_exp_data:
if loading_cycles == None:
load.setLoadFromExperiment(exp, runing_time=None)
else:
load.setLoadFromExperiment(exp,
runing_time=period * loading_cycles)
#==============================================================================
# load of convection
#==============================================================================
load.setConvection(film_coefficient, sink_temperature)
#==============================================================================
# load of thermal
#==============================================================================
load.setThermal(heat_flux, film_coefficient_outer, film_coefficient_inner,
emissivity, sink_temperature_inner, sink_temperature_outer,
outer_temperature)
#==============================================================================
# Step
#==============================================================================
# step = Step(predefined_temperature = int(exp.initial_temperature),
# time_period = int(load.total_runing_time), initial_inc = 0.005,
# min_inc = 0.0001, max_inc = 5, nonlinear = 'ON')
step = Step(predefined_temperature=temperature_mean,
time_period=int(load.total_runing_time),
initial_inc=0.00001,
min_inc=0.00000001,
max_inc=period / 40.0,
nonlinear='OFF')
#==============================================================================
# UMAT
#==============================================================================
# umat = UMAT(UMATDirectory = 'F:\\GitHub\\umat\\',
# UMATMainFile = 'MAIN_IN718.for',
# ParameterFortranFile = 'PARAMETERS_IN718_TMF.for',
# OutputFortranFile = 'OUTPUT.for',
# OutputTextFile = name + '_output.txt')
umat = UMAT(UMATDirectory='F:\\GitHub\\umat\\',
UMATMainFile='MAIN_IN718.for',
ParameterFortranFile='PARAMETERS_SS304.for',
OutputFortranFile='OUTPUT.for',
OutputTextFile=name + '_output.txt')
# umat = UMAT(UMATDirectory = 'F:\\UMAT\\Fangjie\\',
# UMATMainFile = 'AO304Tanakav6VariDamageMyisokin3.for',
# ParameterFortranFile = 'PARAMETERS_SS304.for',
# OutputFortranFile = 'OUTPUT.for',
# OutputTextFile = name + '_output.txt')
# umat = UMAT(UMATDirectory = 'F:\\UMAT\\SS304\\',
# UMATMainFile = 'MAIN_SS304.for',
# ParameterFortranFile = 'PARAMETERS_SS304.for',
# OutputFortranFile = 'OUTPUT.for',
# OutputTextFile = name + '_output.txt')
#==============================================================================
# Job
#==============================================================================
job = Job(JobName=name, UMAT=umat, Step=step, Load=load, copy=copy)
# job.allProc()
job.createDirectory()
job.copyFiles()
job.creatBatchFile()
job.createAbaqusCAE()
job.createAbaqusInput()
job.run()
job.autoPostProc()
spacegroup = 'all'
machinelearning = 'FOREST'
groups = {'triclinic':[1,2], 'monoclinic':[3,15], 'orthorhombic':[16,74], 'tetragonal':[75,142],\
'trigonal':[143,167], 'hexagonal':[168,194], 'cubic':[195,230], 'all':[0,230]}
limits = groups[spacegroup]
File = open(dataFile, "r")
data = json.load(File)
materials = []
data = shuffle(data)
# adding materials that are in the spacegroup to a list
for elem in range(len(data)):
curr = data[elem]
material = Material(curr['formula'])
material.getSpacegroup(curr)
if limits[0]<material.spacegroup and limits[1]>material.spacegroup:
material.separateElements()
material.setData(curr)
material.setValence()
material.setAverages()
materials.append(material)
# shuffle, split, and scale the data
size_70p = int(np.floor(len(materials)*0.7)) # gets index at 70% of material vector length
size_90p = int(np.floor(len(materials)*0.9)) # gets index at 90% of material vector length
# split material vector into train, test, and validate vectors
train = Set(materials[0:size_70p])
test = Set(materials[size_70p+1:size_90p])
def obj(fp):
node = Node()
node.mesh = Mesh()
with open(fp) as f:
material = None
for line in f:
line = line.strip().split(' ', 1)
if len(line) == 1: continue
key, line = line[0], line[1].lstrip()
if '#' in key: continue
if 'vn' in key:
line = line.split(' ')
node.mesh.addNormal(line[0], line[1], line[2])
elif 'vt' in key:
line = line.split(' ')
node.mesh.addTexCoord(line[0], line[1])
elif 'usemtl' in key:
material = None
for mat in node.materials:
if line == mat.name:
material = mat
if material is None:
material = Material()
material.name = line
node.materials[material] = set()
elif 'f' in key:
line = line.split(' ')
face = Face()
if material is not None: node.materials[material].add(face)
# f v//vn
if '//' in line[0]:
line = [int(i) for l in line for i in l.split('//')]
face.vA = line[0]
face.vB = line[2]
face.vC = line[4]
face.vnA = line[1]
face.vnB = line[3]
face.vnC = line[5]
# f v/vt
elif line[0].count('/') == 1:
line = [int(i) for l in line for i in l.split('/')]
face.vA = line[0]
face.vB = line[2]
face.vC = line[4]
face.vtA = line[1]
face.vtB = line[3]
face.vtC = line[5]
# f v/vt/vn
elif line[0].count('/') == 2:
line = [int(i) for l in line for i in l.split('/')]
face.vA = line[0]
face.vB = line[3]
face.vC = line[6]
face.vtA = line[1]
face.vtB = line[4]
face.vtC = line[7]
face.vnA = line[2]
face.vnB = line[5]
face.vnC = line[8]
# f v
else:
face.vA = int(line[0])
face.vB = int(line[1])
face.vC = int(line[2])
node.mesh.faces.append(face)
elif 'v' in key:
line = line.split(' ')
node.mesh.addVertex(line[0], line[1], line[2])
if os.path.isfile(fp.replace('.obj', '.mtl')):
with open(fp.replace('.obj', '.mtl')) as f:
material = None
for line in f:
line = line.strip().split(' ', 1)
if len(line) == 1: continue
key, line = line[0], line[1].lstrip()
if '#' in key: continue
if 'newmtl' in key:
for mat in node.materials:
if mat.name == line: material = mat
if 'map_Kd' in key:
material.diffuseMap = line
elif 'map_Ka' in key:
material.ambientMap = line
elif 'Ka' in key:
line = line.split(' ')
material.ambient = Color(line[0], line[1], line[2])
elif 'Kd' in key:
line = line.split(' ')
material.diffuse = Color(line[0], line[1], line[2])
return node
lightDirection = Vector(0, -1, 0)
lightColor = Vector(255, 255, 255)
light = DirectionalLight(lightColor, 1, lightDirection)
light2 = DirectionalLight(Vector(0, 0, 255), 1, Vector(1, 0, 0))
light3 = PointLight(Vector(255, 247, 222), .3, Point3D(.2, .2, .5))
sphereCenter = Point3D(0,0,-.2)
sphereRadius = .5
sphereMaterialColor = Vector(255, 255, 255)
sphere2MaterialColor = Vector(0,255,255)
sphereMaterialSpecularColor = Vector(0, 255, 255)
sphereMaterialSpecularStrength = .5
sphereMaterial = Material(
sphere2MaterialColor, sphereMaterialSpecularColor, sphereMaterialSpecularStrength,.0)
sphereMaterial2 = Material(
Vector(64, 64, 64), sphereMaterialSpecularColor, sphereMaterialSpecularStrength, .5)
#sphereMaterial3 = Material(
#Vector(0, 255, 0), sphereMaterialSpecularColor, sphereMaterialSpecularStrength, 0)
sphere = Sphere(sphereMaterial2, sphereCenter, sphereRadius)
#sphere2 = Sphere(sphereMaterial, Point3D(.2, .2, .5), .1)
#sphere3 = Sphere(sphereMaterial2, Point3D(-.2, -.1, .5), .1)
#sphere4 = Sphere(sphereMaterial3, Point3D(0, -.1, .5), .1)
lights = [light, light3]
objects = [sphere]
#objects = [sphere, sphere2, sphere3, sphere4]
def __init__(self, mat_name,
acceptor_name, Na, p_len,
i_len, sigma,
donor_name, Nd, n_len,
Va, sigma_name="Si"):
# The Material class will find the bulk energy levels
mp=Material(mat_name,{acceptor_name: Na})
mn=Material(mat_name,{donor_name: Nd})
# Band edges far on the p and n side
Ecp=mp.Ec-mp.mu_bulk-Va/2
Evp=mp.Ev-mp.mu_bulk-Va/2
Ecn=mn.Ec-mn.mu_bulk+Va/2
Evn=mn.Ev-mn.mu_bulk+Va/2
Vr=-Va
Edsigma=materialparameters[mat_name]["dopants"][sigma_name]["E"]
#minfield=000 #V/cm
def Fp(dEFIp):
intrhodEFI=-mp.intrho(EFn=mn.mu_bulk-(Ecp-Ecn)-dEFIp,EFp=mp.mu_bulk-dEFIp)
# print (intrhodEFI,mn.mu_bulk-(Ecp-Ecn)-dEFIp,mp.mu_bulk-dEFIp)
intrhodEFI=intrhodEFI*(intrhodEFI>0)
#if np.all(np.abs(np.sqrt((2/mn.eps)*intrhodEFI))<minfield): return 0*dEFIp
#return np.sign(mp.rho(mp.mu_bulk-dEFIp))*np.sqrt((2/mp.eps)*intrhodEFI)
return np.sign(dEFIp)*np.sqrt((2/mp.eps)*intrhodEFI)
def Fn(dEFIn,x=0):
intrhodEFI=-mn.intrho(EFn=mn.mu_bulk-dEFIn,EFp=mp.mu_bulk+(Ecp-Ecn)-dEFIn)
intrhodEFI=intrhodEFI*(intrhodEFI>0)
#if np.all(np.abs(np.sqrt((2/mn.eps)*intrhodEFI))<minfield): return 0*dEFIn
#return -np.sign(mn.rho(mn.mu_bulk-dEFIn))*np.sqrt((2/mn.eps)*intrhodEFI)
#print(x," ",dEFIn," ",-np.sign(dEFIn)*np.sqrt((2/mn.eps)*intrhodEFI))
return -np.sign(dEFIn)*np.sqrt((2/mn.eps)*intrhodEFI)
def FDiff(dEFIp):
fp=Fp(dEFIp)
dEFIn=dEFIp+fp*i_len+Ecp-Ecn
fn=Fn(dEFIn)
# sigma_eff=sigma*(1/(1+2*np.exp((mn.mu_bulk-dEFIn-mn.Ec+Edsigma)/kT)))
# print ("srat",1/(1+2*np.exp((mn.mu_bulk-dEFIn-mn.Ec+Edsigma)/kT)))
dF=q*sigma/mn.eps
# dF=q*sigma_eff/mn.eps
# print("dF: ",dF/1e6)
return np.abs(fn-fp-dF)
dEFIp_bracket=[-(Ecp-Ecn),-Nd/(Nd+Na)*(Ecp-Ecn)]
res=sciopt.minimize_scalar(FDiff,bracket=dEFIp_bracket)
dEFIp=res.x
fp=Fp(dEFIp)
dEFIn=dEFIp+fp*i_len+Ecp-Ecn
fn=Fn(dEFIn)
print("dEFIp: ",dEFIp)
print("dEFIn: ",dEFIn)
print ("Fn: ",fn/1e6," MV/cm")
print ("Fp: ",fp/1e6," MV/cm")
from scipy.integrate import odeint
# x-grid for calculation
nr=1000
ni=500
nl=1000
xr=np.concatenate([[0],np.logspace(-10,np.log10(n_len),nr)])
xi=np.linspace(0,-i_len,ni) if i_len else np.array([0])
xl=np.concatenate([xi,-np.logspace(-10,np.log10(p_len),nl)-i_len])
x=np.concatenate([xl[::-1],xr[1:]])
Ecr=Ecn+np.ravel(odeint(\
lambda E,x: Fn(E,x),\
dEFIn,xr,rtol=1e-10,atol=1e-8))
print('int\'d r')
# something,fo=odeint(\
# lambda E,x: Fn(E,x),\
# dEFIn,xr,rtol=1e-10,atol=1e-8,hmax=1e-7,full_output=1)#,printmessg=1)
# Ecr=Ecn+np.ravel(something)
# print('int r')
# print(fo)
FpdEFIp=Fp(dEFIp)
Ecl=Ecp+np.ravel(odeint(\
lambda E,x: np.choose(x<-i_len,[FpdEFIp+0*x,Fp(E)]),\
dEFIp+i_len*fp,xl,rtol=1e-10,atol=1e-8,hmax=1e-7))
print('int\'d l')
rhor=mn.rho(EFn=-(Ecr-Ecn-mn.mu_bulk),EFp=-(Ecr-Ecn-mp.mu_bulk-(Ecp-Ecn))) ; print("cheating rhor EFp near junction")
rhol=np.choose(xl<-i_len,[[0]*len(xl),mp.rho(EFn=-(Ecl-Ecp-mn.mu_bulk+(Ecp-Ecn)),EFp=-(Ecl-Ecp-mp.mu_bulk))]); print("cheating rhol EFn far from junction")
#rhol=np.choose(xl<-i_len,[[0]*len(xl),mp.rho(EFn=-(Ecl-Ecp-mp.mu_bulk),EFp=-(Ecl-Ecp-mp.mu_bulk))]); print("cheating BAD rhol EFn")
Fr=Fn(Ecr-Ecn)
Fl=np.choose(xl<-i_len,[(Fp(dEFIp))+0*xl,Fp(Ecl-Ecp)])
Ec=np.concatenate([Ecl[:0:-1],Ecr])
mu=(x<0)*(Vr/2)+(x>0)*(-Vr/2)+np.choose(x==0,[0,np.nan])
rho=np.concatenate([rhol[:0:-1],[np.nan],rhor[1:]])
with warnings.catch_warnings():
warnings.simplefilter("ignore",RuntimeWarning)
rho=rho*(abs(rho)/q>1e11)
F=np.concatenate([Fl[:0:-1],[(Fl[0]+Fr[0])/2],Fr[1:]])
Ev=Ec-mn.Eg
self.x=x+i_len/2
self.Ec=np.ravel(Ec)
self.Ev=np.ravel(Ev)
self.mu=mu
self.F=F
self.rho=rho
self.Vr=Vr
self.mp=mp
self.mn=mn
def __init__(self, obj, system):
Material.__init__(self, obj, system)
def main():
e = Point(-3, 5.75, 3)
c = Point(-2.25, 6, 1)
up = Vector(0, 1, 0)
fov = 45
aspectRatio = WIDTH / HEIGHT
light = Light(Point(30, 30, 10), Color((1, 0.85, 0.85)))
white = Color((1, 1, 1))
dark = Color((0.2, 0.2, 0.2))
black = Color((0.1, 0.1, 0.1))
dark_black = Color((0, 0, 0))
gold = Color((0.831372, 0.686274, 0.215686))
red = Color((1, 0, 0))
green = Color((0, 1, 0))
blue = Color((0, 0, 1))
yellow = Color((1, 1, 0))
gray = Color((0.5, 0.5, 0.5))
checkerBoard = CheckerBoardMaterial()
backgroundColor = dark_black
environmentColor = Color((0.5, 0.5, 0.5))
sphere1 = Spehre(
Point(3, 2, -10), 2,
Material(white, gloss=0.05, specularComp=0.25, diffusComp=0.75))
sphere2 = Spehre(Point(0, 5, -10), 2, Material(black, gloss=0.3))
sphere3 = Spehre(
Point(-3, 8, -10), 2,
Material(white, gloss=0.05, specularComp=0.25, diffusComp=0.75))
sphere4 = Spehre(
Point(-3, 2, -10), 2,
Material(white, gloss=0.05, specularComp=0.25, diffusComp=0.75))
sphere5 = Spehre(
Point(3, 8, -10), 2,
Material(white, gloss=0.05, specularComp=0.25, diffusComp=0.75))
triangle01 = Triangle(
Point(0, 7, -10), Point(5, 7, -10), Point(2.5, 13.5, -15),
Material(gold, gloss=0.15, specularComp=0.25, diffusComp=0.75))
triangle02 = Triangle(
Point(0, 7, -20), Point(0, 7, -10), Point(2.5, 13.5, -15),
Material(gold, gloss=0.15, specularComp=0.25, diffusComp=0.75))
triangle03 = Triangle(
Point(5, 7, -10), Point(5, 7, -20), Point(2.5, 13.5, -15),
Material(gold, gloss=0.15, specularComp=0.25, diffusComp=0.75))
triangle04 = Triangle(
Point(0, 7, -20), Point(5, 7, -20), Point(2.5, 13.5, -15),
Material(gold, gloss=0.15, specularComp=0.25, diffusComp=0.75))
triangle11 = Triangle(
Point(0, 7, -10), Point(5, 7, -10), Point(2.5, 0.5, -15),
Material(gold, gloss=0.15, specularComp=0.25, diffusComp=0.75))
triangle12 = Triangle(
Point(0, 7, -20), Point(0, 7, -10), Point(2.5, 0.5, -15),
Material(gold, gloss=0.15, specularComp=0.25, diffusComp=0.75))
triangle13 = Triangle(
Point(5, 7, -10), Point(5, 7, -20), Point(2.5, 0.5, -15),
Material(gold, gloss=0.15, specularComp=0.25, diffusComp=0.75))
triangle14 = Triangle(
Point(0, 7, -20), Point(5, 7, -20), Point(2.5, 0.5, -15),
Material(gold, gloss=0.15, specularComp=0.25, diffusComp=0.75))
plane = Plane(Point(0, 0, 0), Vector(0, 1, 0),
Material(checkerBoard, gloss=0.15))
objectList = [
triangle01, triangle02, triangle03, triangle04, triangle11, triangle12,
triangle13, triangle14, plane
]
cams = []
cam = Camera(e, c, up, WIDTH, HEIGHT, aspectRatio, backgroundColor,
objectList, image, light, fov, environmentColor)
cams.append(cam)
pool = mp.Pool(processes=4)
results = pool.map(render, cams)
results[0].show()
results[0].save('temp.png', 'png')
self.far = 50
self.transform.position = V3(0., 0, -1.)
self.speed = V3.zero()
self.LookAt = V3.zero()
presenter = Presenter(400, 300)
presenter.bind(scene)
scene.loadtexture(0, 't4puc-rio.jpeg')
scene.createLight(V4(5., 5., 0., 1.), V4(0.7, 0.7, 0.5, 1.0),
V4(0.5, 0.5, 0.5, 1.0))
plane = scene.createPlane()
plane.transform.position = V3(0, 0, 0)
#plane.material = Material(1,1,1)
plane.textures = [0, 0]
plane.material = Material(1, 0.0, 0.0)
plane.i = 0.2
def updatep(self, dt):
self.faces[0][2] = [0, math.sin(self.i), 0]
self.i += 0.2
plane.update = types.MethodType(updatep, plane)
scene.camera.start = types.MethodType(startCam, scene.camera)
presenter.show()
def __init__(self, obj, system):
Material.__init__(self, obj, system)
obj.addProperty("App::PropertyFloat", "Young", "Solid", "Young's modulus").Young=0.0
obj.addProperty("App::PropertyFloat", "Shear", "Solid", "Shear modulus").Shear=0.0
obj.addProperty("App::PropertyFloat", "Poisson", "Solid", "Poisson's ratio").Poisson=0.0
def __init__(self, name="elasticmaterial"): """ Constructor. """ Material.__init__(self, name) return
def show_material(self):
material = Material(self)
material.show()
screen_center = self.geometry().center()
widget_center = material.rect().center()
material.move(screen_center-widget_center)
def Vn_vs_VA_curve(NA, ND, sigma, Va):
pside = Material("GaN", {"Mg": NA})
Nv = pside.Nv
EA = pside.dopants.values()[0]['E']
EVp = pside.Ev - pside.mu_bulk
NAp = NA * np.log(1 + 4 * np.exp((EVp + EA) / kT))
Gp = G12(EVp / kT)
nside = Material("GaN", {"Si": ND})
Nc = nside.Nc
ED = nside.dopants.values()[0]['E']
ECn = nside.Ec - nside.mu_bulk
NDp = ND * np.log(1 + .5 * np.exp((ECn - ED) / kT))
Gn = G12(-ECn / kT)
eps = nside.eps
Vbi = nside.mu_bulk - pside.mu_bulk
Sigma = np.sqrt(q * sigma**2 / (2 * eps * kT * NA))
Vsigma = Vbi - Sigma**2 * kT + (Nc / NA * kT * Gn - NAp / NA * kT -
Nv / NA * Gp * kT)
print "Vsigma: ", Vsigma
def Fn_of_Vn(Vn):
return np.sqrt(2*q*kT*Nc/eps)*\
np.sqrt(G12((Vn-ECn)/kT)-Gn-NDp/Nc)
def Fp_of_Vn(Vn, Va):
Vp = Vn + Vbi - Va
return -np.sqrt(2*q*kT*Nc/eps)*\
np.sqrt(NA/Nc*Vp/kT+G12((Vn-ECn)/kT)-NAp/Nc-Nc/Nc*Gp)
def Vn_of_Va(Vai):
print ""
print "VA: ", Vai
g = SpikedPINJunction("GaN", "Mg", NA, .1e-4, 0 * .005e-4, sigma, "Si",
ND, .2e-4, Vai)
# g.plot_all()
Vni = g.Ec[-1] - np.min(g.Ec)
print "Predicted Fn: " + str(Fn_of_Vn(Vni) / 1e6)
print "Predicted Fp: " + str(Fp_of_Vn(Vni, Vai) / 1e6)
if Vni < .3 * kT:
return np.nan
return Vni
Vn = np.vectorize(Vn_of_Va, otypes=['float64'])(Va)
ind = np.argmin(np.abs(Va))
alpha_exp, Vn0 = linregress(Va[ind - 2:ind + 3], Vn[ind - 2:ind + 3])[0:2]
alpha = 1 / ((2 / (np.pi)**.25 * Sigma * np.sqrt(Nc / NA) *
((Vn0 - ECn) / kT)**.25) - 1)
mpl.figure()
mpl.plot(Va, Vn, '.')
LHS = 4 * Nc / NA * Sigma**2 * (G12((Vn - ECn) / kT) - Gn - NDp / Nc)
RHS = ((Vn + Vsigma - Va) / kT + NDp / NA)**2
#print "LHS ", LHS
#print "RHS ", RHS
print "LHS RHS Error: ", (LHS - RHS) / RHS
S = (32 / (15 * np.sqrt(np.pi)) * (Nc / NA) * Sigma**2)**.4
DV = Va - Vsigma - NDp / NA * kT
Vnpre = kT * ((1 / S) * (DV / kT)**.8 + ECn / kT) / (1 + (4 / (5 * S) *
(kT / DV)**.2))
return Vn, Vnpre, Vsigma
def postar_material(self, nome, conteudo, disciplina):
um_material = Material(nome, conteudo, self.nome)
disciplina.incluir_material(um_material)
return disciplina
