def __init__(self, anr, ax, ay):
super(baseprocessclass, self).__init__(anr, ax, ay)
self.actualvolumeflow = controlvar.controlvar() #controlvar; /m3/s non-standard conditions.
self.standardvolumeflow = controlvar.controlvar() # controlvar //m3/s standard conditions (later to be descriminated between gases and liquids)
self.molarflow = controlvar.controlvar() #controlvar //molar flow per second
self.massflow = controlvar.controlvar() #controlvar //kg/second
self.hasmaterial = True #Bool. //True if the stream/unitop/baseclass has material inside that can flow/pump or be processed.
#//mat = new material(global.baseprocessclassInitVolume);
#//public material(string componentname, double aTemp, double aV, double aP, double af) //second constructor
self.mat = material.material()
self.mat.materialconstructor2(globe.fluidpackage, globe.baseprocessclassInitTemperature, \
globe.baseprocessclassInitVolume, \
globe.baseprocessclassInitPressure, 0) #material object
self.massflow.v = globe.baseprocessclassInitMassFlow
self.calcactualvolumeflowfrommassflow()
self.calcmolarflowfrommassflow()
self.calcstandardflowfrommoleflow()
#//pressuresimvector = new double[global.SimIterations];
self.controlpropthisclass = []
self.controlpropthisclass = ["pressure", \
"volume", \
"density", \
"temperature", \
"mass", \
"n", \
"actualvolumeflow", \
"standardvolumeflow", \
"massflow", \
"molarflow"]
self.controlproperties = self.controlproperties + self.controlpropthisclass
def getblockkey(s_keyname, s_block):
if s_keyname == 'SURFACE':
c_surface = surface.surface()
c_surface.readRMC(s_block)
return c_surface
if s_keyname == 'UNIVERSE':
c_universe = universe.universe()
c_universe.readRMC(s_block)
return c_universe
if s_keyname == 'MATERIAL':
c_material = material.material()
c_material.readRMC(s_block)
return c_material
# if s_keyname == 'CRITICALITY':
# c_criticality = criticality.criticality()
# c_criticality.readRMC(s_block)
# return c_criticality
# if s_keyname == 'PLOT':
# c_plot = plot.plot()
# c_plot.readRMC(s_block)
# return c_plot
else:
return -1
def __init__(self, length, force, compressiveMult):
self.force = force
if self.force < 0:
self.length = length * compressiveMult
else:
self.length = length
self.dowel = 0.2
if self.force < 0:
self.material = material.material(0.02, 0.00325 * compressiveMult)
else:
self.material = material.material(0.02, 0.00325)
self.crit = self.Crit()
self.failed = self.failure()
def __init__(self, transform_within=None, set_material=None):
if transform_within == None:
self.transform_within = identity_matrix
else:
self.transform_within = transform_within
if set_material == None:
self.set_material = material()
else:
self.set_material = set_material
def __init__(self, field, mode='TMz', ports=[], boundary=None):
# save arguments
self.field = field
self.mode = mode
self.ports = ports
# create free space material
self.material = material(field.xSize, field.ySize, field.deltaX, field.deltaY, mode=self.mode)
# create standart boundary
self.boundary = pml(field.xSize, field.ySize, field.deltaX, field.deltaY, thickness=20.0)
def __init__(self, transform_within=identity_matrix, set_material=None):
"""
these values are set to none for now but will be changed in due time
- transform_within has been set to the identity matrix
A SPHERE IS ALWAYS SET TO THE DEFAULT MATERIAL
"""
self.transform_within = transform_within
if set_material == None:
self.material = material()
else:
self.material = set_material
def run():
x_size = 512
y_size = 512
scene1 = scene(x_size, y_size)
scene1.set_camera(0, 0, 10, 0, 0, 0)
scene1.set_window(0.0, -7.25, -7.25, 7.25, 7.25)
scene1.add_light([10, 0, 0])
cam_loc = scene1.get_cam_loc()
mat = material([1, 1, 1], [1, 1, 1], 4)
scene1.add_sphere(3.5, 0, -1, .5, mat)
mat2 = material([1, 0, 0], [.5, 1, .5], 32)
scene1.add_sphere(2, 0, -1, .75, mat2)
mat3 = material([0, 1, 0], [.5, 1, .5], 32)
scene1.add_sphere(-6, 0, 0, 3, mat3)
p_t = [[3, -3, -4], [0, 3, -1], [-3, -3, 2]]
mat4 = material([0, 0, 1], [1, 1, 1], 32)
scene1.add_poly(p_t, mat4)
p_2t = [[-2, -1, 1], [-2, -5, 2], [-2, 1, -3]]
mat5 = material([1, 1, 0], [1, 1, 1], 4)
scene1.add_poly(p_2t, mat5)
ray_trace(scene1, x_size, y_size)
def __init__(self):
# Inicializamos todo:
# Variables de la clase
self.width = 800
self.height = 800
self.aspect = self.width / self.height
self.angulo = 0
self.window = 0
self.Sol = model.Modelo()
self.camara = camara.camara()
self.material = material.material()
self.foco = foco.foco()
self.planeta = planeta.planeta()
self.focos_configurados = False
self.mostrar_ejes = False
self.mostrar_orbitas = True
# Tamaño de los ejes y del alejamiento de Z.
self.tamanio = 40
self.z0 = 0
# Factor para el tamaño del modelo.
self.escalaGeneral = 0.001
# Rotacion de los modelos.
self.alpha = 0
self.beta = 0
# Variables para la gestion del ratón.
self.xold = 0
self.yold = 0
self.zoom = 1.0
# Vistas del Sistema Planetario.
# modelo.tipoVista iForma
self.iDibujo = 3
self.iFondo = 0
self.iForma = 6
def newRec(self, code = 0, name = "", priceforgramm = 0):
self.appendList(material(code, name, priceforgramm))
def update_glass(self):
if hasattr(self, 'manufacturer'):
self.glass = material(self.material, self.wavelengths,
self.manufacturer)
else:
self.glass = material(self.material, self.wavelengths)
def initcoolingtower(self):
#public double U; // W/(m^2*K) ; Overall heat exchanger coefficient for heat exchanger. Not sure if this is going to be used now.
#public double A; // m^2 ; The contact area for the fluids with each other in the heat exchanger. Not sure if this is going to be used now.
#//public double K; //constants used in calculating the new output temperatures of the HX.
self.objecttype = globe.objecttypes.CoolingTower
self.name = 'Cooling tower ' + str(self.nr)
self.controlpropthisclass = []
self.controlpropthisclass += ["on", "fanspeed", "fanpower", "ctwatervolumefraction", "masstransfercoefair", \
"heattransfercoefwater", "heattransfercoefair"]
self.nrcontrolpropinherited = len(self.controlproperties)
self.controlproperties += self.controlpropthisclass
self.nrstages = globe.CTDefaultNrStages
self.h = globe.SampleT #step size for integration
self.on = controlvar(1, True) #0 for off, 1 for on.
self.linkedsprayvalve = None #This is not used at the moment. Every coolingtower will now have feeding spray valve that is linked to it.
self.fanspeed = controlvar(
globe.CTFanSpeedT0) #revolusions per second.
self.fanpower = controlvar(0.0) #W
self.newfanpower = 0.0
#//W; The future steady state fan power.
self.fanpowerstatespacex1 = 0.0
self.fanpowerstatespacex2 = 0.0
self.ddtfanpowerstatespacex1 = 0.0
self.ddtfanpowerstatespacex2 = 0.0
self.deltapressure = globe.CTDefaultFanDP #Pa. The pressure drop over the fan.
self.watervolumefraction = controlvar(
globe.CTWaterVolumeFraction
) #//fraction of total volume in tower occupied by water. This is from Marques article -> 0.01.
self.CTAirVolumeFraction = 1.0 - self.watervolumefraction.v - globe.CTPackingVolumeFraction
self.CTTotalWaterVolume = globe.CTTotalVolume * self.watervolumefraction.v
self.CTNrDroplets = self.CTTotalWaterVolume / globe.CTDropletVolume
self.CTDefaultSegmentContactArea = self.CTNrDroplets * globe.CTDropletSurfaceArea / self.nrstages #//m^2 interfacial contact area total per segment.
self.a = self.CTNrDroplets * globe.CTDropletSurfaceArea / (
globe.CTTotalVolume)
#//m^2/m^3 interfacial contact area of water droplets per unit volume of the tower.
self.tuningfactor = globe.CTTuningFactor #dimensionless. This factor will be used to tune the simultion
#in terms chilling in the cooling tower.
self.outflow0temperatureoutnew = 0.0 #Kelvin
self.doutflow0temperatureoutnewdt = 0.0 #Kelvin/sec
#//U = global.HeatExchangerSimpleDefaultU;
#//A = global.HeatExchangerSimpleDefaultA;
#//K = 0;
self.masstransfercoefair = controlvar(
globe.CTDefaultMassTransferCoefficientAir) #kg/(s*m^2)
self.masstransfercoefair.simvector = [0.0] * globe.SimVectorLength
self.heattransfercoefwater = controlvar(
globe.CTDefaultHeatTransferCoefficientWater) #W/(m^2*K)
self.heattransfercoefwater.simvector = [0.0] * globe.SimVectorLength
self.heattransfercoefair = controlvar(
globe.CTDefaultHeatTransferCoefficientAir) #W/(m^2*K)
self.heattransfercoefair.simvector = [0.0] * globe.SimVectorLength
self.wetbulbtemperature = 0.0 #Kelvin
self.calcwetbulbtemp() #//Kelvin
self.massfluxwater = 0.0 #//m3/s : Mass flux flow of water in the CT.
self.massfluxair = 0.0 #//m3/s : Mass flux flow of air in the CT.
self.segmentvolume = list(
) #m^3 total volume per water segment : includes packing, water,
# and air in each segment.
for i in range(self.nrstages):
self.segmentvolume.append(globe.CTWidth * globe.CTLength *
globe.CTHeight / self.nrstages)
self.segmentvolumewater = list() #m^3 volume per water segment
for i in range(self.nrstages):
self.segmentvolumewater.append(globe.CTWidth*globe.CTLength*globe.CTHeight*self.watervolumefraction.v \
/ self.nrstages) #//times 0.5 since half the volume is for water, and half for air.
self.segmentvolumeair = list() #m^3 volume per air segment
for i in range(self.nrstages):
self.segmentvolumeair.append(globe.CTWidth * globe.CTLength * globe.CTHeight * \
self.CTAirVolumeFraction/self.nrstages) #//times 0.5 since half the volume is for air,
#// and half for air.
self.watersegment = list()
for i in range(self.nrstages):
watermaterial = material()
watermaterial.materialconstructor2(globe.fluidpackage, globe.CTTStrm0Inlet, globe.baseprocessclassInitVolume, \
globe.CTPStrm0Inlet, 0)
self.watersegment.append(
watermaterial
) #//should maybe again be initialised with water only.
self.airsegment = list()
for i in range(self.nrstages):
airmaterial = material()
airmaterial.materialconstructor2(globe.fluidpackage, globe.CTTStrm1Inlet, self.segmentvolumeair[i], \
globe.CTPStrm1Inlet, 1)
self.airsegment.append(
airmaterial
) #//Should maybe again be initialised with Air only.
for j in range(len(self.airsegment[i].composition)):
if self.airsegment[i].composition[
j].m.name == "Air": #if j == int(globe.components.Air):
self.airsegment[i].composition[j].molefraction = 1.0
else:
self.airsegment[i].composition[j].molefraction = 0.0
self.airsegment[i].PTfVflash(self.airsegment[i].T.v, self.airsegment[i].V.v, self.airsegment[i].P.v, \
self.airsegment[i].f.v)
self.watersegmentflowout = list(
) #//kg/s. The mass flow out of the particular water segment.
for i in range(self.nrstages):
self.watersegmentflowout.append(0.0)
self.airsegmentdryairflowout = list(
) #//The mass flow out of the particular air segment.
for i in range(self.nrstages):
self.airsegmentdryairflowout.append(0.0)
self.interfacetemperature = list(
) #Kelvin. Temperature at the interface for the segment.
self.interfacetemperaturesimvector = list()
for i in range(self.nrstages):
self.interfacetemperature.append(globe.CTTInterfaceT0)
self.interfacetemperaturesimvector.append([0.0] *
globe.SimVectorLength)
self.interfaceabshumidity = list() #kg mass water / kg dry air
self.interfaceabshumiditysimvector = list()
for i in range(self.nrstages):
self.interfaceabshumidity.append(\
self.calcabshumidity(self.calcwatervapourpressuresaturation(self.interfacetemperature[i])))
self.interfaceabshumiditysimvector.append([0.0] *
globe.SimVectorLength)
self.airabshumidity = list() #kg mass water / kg dry air
self.airabshumiditysimvector = list()
for i in range(self.nrstages):
self.airabshumidity.append(
self.calcabshumidity(
self.calcwatervapourpressure(self.airsegment[i].T.v)))
self.airabshumiditysimvector.append([0.0] * globe.SimVectorLength)
self.massevap = list(
) #kg/s. Mass evaporated per second, per segment.
for i in range(self.nrstages):
self.massevap.append(0.0)
self.segmenttransferarea = list(
) #m2. The surface area used to calculate the vapour mass transfer flow.
for i in range(self.nrstages):
self.segmenttransferarea.append(globe.CTTotalInterfaceArea)
self.segmentcontactarea = list(
) #m^2 interfacial contact area of water droplets for each segment of the tower.
for i in range(self.nrstages):
self.segmentcontactarea.append(self.CTDefaultSegmentContactArea)
self.dTwaterdt = list(
) #K/s Let the first column be the normal derivative, and then column 1
#and on will be the different k values in RK4.
for i in range(self.nrstages):
self.dTwaterdt.append([0.0] * globe.CTRK4ArraySize)
self.dTairdt = list() #//K/s
for i in range(self.nrstages):
self.dTairdt.append([0.0] * globe.CTRK4ArraySize)
self.dhumidityairdt = list()
for i in range(self.nrstages):
self.dhumidityairdt.append([0.0] * globe.CTRK4ArraySize)
#Properties for stream 0
self.strm0valveop = globe.CTStrm0ValveOpeningDefault #Fraction. Spray nozzle modelled as a valve.
self.strm0cv = globe.CTStrm0Cv #The upstream pressure will be calculated by modelling the spray nozzle as a valve.
self.strm0temptau = globe.CTStrm0TempTau
self.strm0flowtau = globe.CTStrm0FlowTau
#Properties for stream 1
self.strm1flowcoefficient = globe.CTStrm1FlowCoefficient
self.strm1temptau = globe.CTStrm1TempTau
self.strm1flowtau = globe.CTStrm1FlowTau
#//Variables for stream 0 equations . In the case of the cooling tower, this will be the hot water stream.
self.strm0massflownew = globe.CTMassFlowStrm0T0 #//kg/s
self.dstrm0massflowdt = 0.0 #kg/s/s
self.strm0pressureinnew = globe.CTPStrm0Inlet #//Pa
self.dstrm0pressureindt = 0.0 #//Pa/s
self.strm0temperatureoutnew = globe.CTTStrm0Outlet #//Kelvin
self.dstrm0temperatureoutnewdt = 0.0
#//Variables for stream 1 equations
self.strm1massflownew = globe.CTMassFlowStrm1T0 #//kg/s
self.dstrm1massflowdt = 0.0 #kg/s/s
self.strm1pressureoutnew = globe.CTPStrm1Outlet #//Pa
self.dstrm1pressureoutdt = 0.0 #//Pa/s
self.strm1temperatureoutnew = globe.CTTStrm1Outlet #//Kelvin
self.dstrm1temperatureoutnewdt = 0.0
floor.material.specular = 0
w.objects.append(floor)
# left_wall = sphere()
# left_wall.transform = translation(0, 0, 5) * rotation_y(-pi/4) * rotation_x(pi/2) * scaling(10, 0.01, 10)
# left_wall.material = floor.material
# w.objects.append(left_wall)
# right_wall = sphere()
# right_wall.transform = translation(0, 0, 5) * rotation_y(pi/4) * rotation_x(pi/2) * scaling(10, 0.01, 10)
# right_wall.material = floor.material
# w.objects.append(right_wall)
middle = sphere()
middle.transform = translation(-0.5, 1, 0.5)
middle.material = material()
middle.material.color = color(0.1, 1, 0.5)
middle.material.diffuse = 0.7
middle.material.specular = 0.3
w.objects.append(middle)
right = sphere()
right.transform = translation(1.5, 0.5, -0.5) * scaling(0.5, 0.5, 0.5)
right.material = material()
right.material.color = color(0.5, 1, 0.1)
right.material.diffuse = 0.7
right.material.specular = 0.3
w.objects.append(right)
left = sphere()
left.transform = translation(-1.5, 0.33, -0.75) * scaling(0.33, 0.33, 0.33)
pass
def plotR(coating, incident_mat, sub_mat, AOI, wavemin, wavemax, pol=None):
pass
if __name__ == '__main__':
from material import material
x = coating()
name = 'SF6'
wavelengths = [450,550,650]
g = material(name,wavelengths)
x.add_layer(g,137.5)
incident_mat = material('BAC4',wavelengths)
sub_mat = material('N-BK7',wavelengths)
r = x.R(incident_mat,sub_mat,0,wavelengths[1])
print(r)
furniture17 = [
"carpet17", "dinner_table17", "first_chair17", "second_chair17",
"third_chair17", "fourth_chair17", "gimble17", "painting1_17",
"painting2_17", "frame1_17", "frame2_17", "painting3_17", "frame3_17",
"book1_17", "cover1_17", "candle1_17", "candle2_17", "Walls17"
]
cursor = database.cursor()
# if the database is empty, create five tables for each object
cursor.execute(
"SELECT COUNT(DISTINCT `table_name`) FROM `information_schema`.`columns` WHERE `table_schema` = "
"'blender'")
data = cursor.fetchone()
if data[0] == 0:
for obj in bpy.data.collections['Furniture13'].objects:
material.material(obj, database, True)
for obj in bpy.data.collections['Furniture17'].objects:
material.material(obj, database, True)
for obj in bpy.data.collections['Furniture13'].objects:
edges_vertices_faces.edges_vertices_faces(obj, database, True)
for obj in bpy.data.collections['Furniture17'].objects:
edges_vertices_faces.edges_vertices_faces(obj, database, True)
for obj in bpy.data.collections['Furniture13'].objects:
coordinates.coordinates(obj, database, True)
for obj in bpy.data.collections['Furniture17'].objects:
coordinates.coordinates(obj, database, True)
print("All tables inserted")
register()
database.close()
def step_impl(context):
context.m = material()
#!/usr/bin/python
import mocup
import material
mat=material.material()
mat.import_ocf('moi.11100.eq.pch')
mat.mcf(1, mcf_loc = 'moi.11100.eq.mcnpformat')
from shape import hit, normal_at
from sphere import intersect, sphere
from tuple import color, normalize, point, point_light
from world import lighting
if __name__ == "__main__":
ray_origin = point(0, 0, -5)
wall_z = 10
wall_size = 7
canvas_pixels = 400
pixel_size = wall_size / canvas_pixels
half = wall_size / 2
canvas = canvas(canvas_pixels, canvas_pixels)
shape = sphere()
shape.material = material()
shape.material.color = color(0.2, 1, 1)
light_position = point(-10, 10, -10)
light_color = color(1, 1, 1)
light = point_light(light_position, light_color)
# transformations
# shape.transform = scaling(1, 0.5, 1)
# shape.transform = scaling(0.5, 1, 1)
# shape.transform = rotation_z(pi / 4) * scaling(0.5, 1, 1)
# shape.transform = shearing(1, 0, 0, 0, 0, 0) * scaling(0.5, 1, 1)
start = time.time()
print("Starting render...")
def step_impl(context):
assert context.m == material()
def __init__(self):
self.id = str.format("%032x" % random.getrandbits(128))
self.parent = None
self.transform = identity_matrix()
self.material = material()
import pygame
from vector3 import *
import shapes, voxel, scene, render, material
#create some materials
red_mat = material.material( vector3(), #emissive
vector3(96.0, 66.0, 66.0), #ambient
vector3(96.0, 66.0, 66.0), #diffuse
vector3(), #specular
20.0, #shininess
0.0 ) #reflectivity
grey_mat = material.material( vector3(),
vector3(96.0, 96.0, 96.0),
vector3(96.0, 96.0, 96.0),
vector3(),
20.0,
0.0 )
bluegrey_mat = material.material( vector3(),
vector3(66.0, 66.0, 96.0),
vector3(66.0, 66.0, 96.0),
vector3(),
20.0,
0.0 )
orange_mat = material.material( vector3(),
vector3(238.0, 154.0, 73.0),
vector3(238.0, 154.0, 73.0),
vector3(255.0, 255.0, 255.0),
