def trace(self, rph, iters = 10000, minE = 1e-9, render = False):
"""Commences raytracing using (rph) number of rays per heliostat, for a maximum of
(iters) iterations, discarding rays with energy less than (minE). If render is
True, a 3D scene will be displayed which would need to be closed to proceed."""
# Get the solar vector using azimuth and elevation
sun_vec = solar_vector(self.sun_az*degree, self.sun_elev*degree)
# Calculate number of rays used. Rays per heliostat * number of heliostats.
num_rays = rph*len(self.field.get_heliostats())
self.no_of_rays += num_rays
# Generates the ray bundle
rot_sun = rotation_to_z(-sun_vec)
direct = N.dot(rot_sun, pillbox_sunshape_directions(num_rays, 0.00465))
xy = N.random.uniform(low=-0.25, high=0.25, size=(2, num_rays))
base_pos = N.tile(self.pos, (rph, 1)).T #Check if its is rph or num_rays
base_pos += N.dot(rot_sun[:,:2], xy)
base_pos -= direct
rays = RayBundle(base_pos, direct, energy=N.ones(num_rays))
# Perform the raytracing
e = TracerEngine(self.plant)
e.ray_tracer(rays, iters, minE, tree=True)
e.minener = minE
rays_in = sum(e.tree._bunds[0].get_energy())
self.helio_hits = sum(e.tree._bunds[1].get_energy())
# Optional rendering
if render == True:
trace_scene = Renderer(e)
trace_scene.show_rays()
def trace(self):
"""Generate a flux map using much more rays than drawn"""
# Generate a large ray bundle using a radial stagger much denser
# than the field.
sun_vec = solar_vector(self.sun_az * degree, self.sun_elev * degree)
hstat_rays = 20
num_rays = hstat_rays * len(self.field.get_heliostats())
rot_sun = rotation_to_z(-sun_vec)
direct = N.dot(rot_sun, pillbox_sunshape_directions(num_rays, 0.00465))
xy = N.random.uniform(low=-0.25, high=0.25, size=(2, num_rays))
base_pos = N.tile(self.pos, (hstat_rays, 1)).T
base_pos += N.dot(rot_sun[:, :2], xy)
base_pos -= direct
rays = RayBundle(base_pos, direct, energy=N.ones(num_rays))
# Perform the trace:
e = TracerEngine(self.plant)
e.ray_tracer(rays, 100, 0.05, tree=True)
e.minener = 1e-5
# Render:
trace_scene = Renderer(e)
trace_scene.show_rays()
def trace(self):
"""Generate a flux map using much more rays than drawn"""
# Generate a large ray bundle using a radial stagger much denser
# than the field.
sun_vec = solar_vector(self.sun_az*degree, self.sun_elev*degree)
hstat_rays = 20
num_rays = hstat_rays*len(self.field.get_heliostats())
rot_sun = rotation_to_z(-sun_vec)
direct = N.dot(rot_sun, pillbox_sunshape_directions(num_rays, 0.00465))
xy = N.random.uniform(low=-0.25, high=0.25, size=(2, num_rays))
base_pos = N.tile(self.pos, (hstat_rays, 1)).T
base_pos += N.dot(rot_sun[:,:2], xy)
base_pos -= direct
rays = RayBundle(base_pos, direct, energy=N.ones(num_rays))
# Perform the trace:
e = TracerEngine(self.plant)
e.ray_tracer(rays, 100, 0.05, tree=True)
e.minener = 1e-5
# Render:
trace_scene = Renderer(e)
trace_scene.show_rays()
def trace(self):
"""Generate a flux map using much more rays than drawn"""
# Generate a large ray bundle using a radial stagger much denser
# than the field.
sun_vec = solar_vector(self.sun_az*degree, self.sun_elev*degree)
#hstat_rays
hstat_rays = 1000
num_rays = hstat_rays*len(self.field.get_heliostats())
rot_sun = rotation_to_z(-sun_vec)
direct = N.dot(rot_sun, pillbox_sunshape_directions(num_rays, 0.00465))
xy = N.random.uniform(low=-0.25, high=0.25, size=(2, num_rays))
base_pos = N.tile(self.pos, (hstat_rays, 1)).T
base_pos += N.dot(rot_sun[:,:2], xy)
base_pos -= direct
rays = RayBundle(base_pos, direct, energy=N.ones(num_rays))
# Perform the trace:
e = TracerEngine(self.plant)
e.ray_tracer(rays, 100, 0.05, tree=True)
e.minener = 1e-6 # default 1e-5
# Render:
#trace_scene = Renderer(e)
#trace_scene.show_rays()
# Initialise a histogram of hits:
energy, pts = self.reclist.get_optics_manager().get_all_hits()
x, y = self.reclist.global_to_local(pts)[:2]
rngx = 0.55 #0.5
rngy = 0.55 #0.5
bins = 100 #50
H, xbins, ybins = N.histogram2d(x, y, bins, \
range=([-rngx,rngx], [-rngy,rngy]), weights=energy)
#print(H, xbins, ybins)
total=N.sum(H)
print(total)
extent = [ybins[0], ybins[-1], xbins[-1], xbins[0]]
plt.imshow(H, extent=extent, interpolation='nearest')
plt.colorbar()
plt.title("front")
plt.show()
engine=TracerEngine(scene._asm) engine.ray_tracer(scene._source, 10, 1e-9, True ) #engine.ray_tracer(scene._source, 10, 1e-9, True ) print(engine.tree._bunds[0].get_energy(),'tree',len(engine.tree._bunds[0].get_energy())) print(engine.tree._bunds[1].get_energy(),'tree',len(engine.tree._bunds[1].get_energy()))#print(engine.tree._bunds[2].get_energy(),'tree',len(engine.tree._bunds[2].get_energy())) print(engine.tree._bunds[3].get_energy(),'tree',len(engine.tree._bunds[3].get_energy())) print(engine.tree._bunds[4].get_energy(),'tree',len(engine.tree._bunds[4].get_energy())) print(engine.tree._bunds[5].get_energy(),'tree',len(engine.tree._bunds[5].get_energy())) print(engine.tree._bunds[6].get_energy(),'tree',len(engine.tree._bunds[6].get_energy())) eff=(N.sum(engine.tree._bunds[2].get_energy())+N.sum(engine.tree._bunds[4].get_energy()))*9/(len(engine.tree._bunds[1].get_energy())*engine.tree._bunds[1].get_energy()[0]) print(eff,'eff') # the demoninator includes the sum rays on the back. i.e. the blocking is accounted for engine.minener = 1e-20 recv=scene._asm.get_local_objects()[0] #here the scene._asm is an assembly and _object[1] returns an object Now it's really the receiver #print(scene._asm.get_local_objects(),'scene_recv') count = 0 totalenergy = 0 ''' for face in recv.get_surfaces(): # definitely has gone through only one iteration. check .surface for definitioin #energy, pts = face._optics.get_all_hits() #that's when everything gets doubled #print(recv.get_surfaces()) energy, pts =face.get_optics_manager().get_all_hits() # an instance of a reflective receiver print(energy,len(energy),'energy') subtotalenergy = energy.sum() # for each surface #print(subtotalenergy,'subtotalenergy') totalenergy += subtotalenergy
def trace(self, iters=10000, minE=1e-9, render=False, bins=20):
"""Commences raytracing using (rph) number of rays per heliostat, for a maximum of
(iters) iterations, discarding rays with energy less than (minE). If render is
True, a 3D scene will be displayed which would need to be closed to proceed."""
# Get the solar vector using azimuth and elevation
raytime0 = timeit.default_timer()
# Perform the raytracing
e = TracerEngine(self.plant)
e.ray_tracer(self.raybundle, iters, minE, tree=True)
e.minener = minE
raytime1 = timeit.default_timer()
print("RayTime", raytime1 - raytime0)
#power_per_ray = self.power_per_ray
self.power_per_ray = self.DNI / self.rays
power_per_ray = self.power_per_ray
# Optional rendering
if render == True:
trace_scene = Renderer(e)
trace_scene.show_rays()
#pe0 is the array of energies of rays in bundle 0 that have children
i_list = e.tree._bunds[1].get_parents()
e_list = e.tree._bunds[0].get_energy()
pe0 = N.array([])
for i in i_list:
pe0 = N.append(pe0, e_list[i])
#pe1 is the array of energies of rays in bundle 1 that have children
i_list = e.tree._bunds[2].get_parents()
e_list = e.tree._bunds[1].get_energy()
pe1 = N.array([])
for i in i_list:
pe1 = N.append(pe1, e_list[i])
#pz0 is the array of z-vertices of rays in bundle 0 that have children
i_list = e.tree._bunds[1].get_parents()
z_list = e.tree._bunds[0].get_vertices()[2]
pz0 = N.array([])
for i in i_list:
pz0 = N.append(pz0, z_list[i])
#az1 is the array of z-vertices of rays in bundle 1 that have children
i_list = e.tree._bunds[2].get_parents()
z_list = e.tree._bunds[1].get_vertices()[2]
pz1 = N.array([])
for i in i_list:
pz1 = N.append(pz1, z_list[i])
#Helio_0 initial rays incident on heliostat
##############ASSUMING PERFECT REFLECTORS, HELIO1 IS ALSO RAYS COMING OUT OF THE HELIOSTAT INITIALLY#######(NOT CORRECTED FOR BLOCK)
#azh1 = array of z-values less than half of recv height
azh1 = e.tree._bunds[1].get_vertices()[2] < self.dz / 2.0
#array of parent energies of those rays is pe0
self.helio_0 = float(sum(azh1 * pe0)) #*power_per_ray
#Helio_1 is all rays coming out of a heliostat
#ape1 is array of all energies in bundle 1
ape1 = e.tree._bunds[1].get_energy()
self.helio_1 = float(sum(ape1 * azh1)) #*power_per_ray
#Recv_0 initial rays incident on receiver
#azr1 = array of z-values greater than half of recv height
azr1 = e.tree._bunds[1].get_vertices()[2] > self.dz / 2.0
self.recv_0 = float(sum(azr1 * pe0)) #*power_per_ray
#Helio_b rays out of heliostat that are blocked by other mirrors
#azh2 = array of z-values less than half of recv height of bundle 2
azh2 = e.tree._bunds[2].get_vertices()[2] < self.dz / 2.0
#pz1 = array of z-values of bundle 1 that have children
pzh1 = pz1 < self.dz / 2.0
#pe1 = array of energies of bundle 1 that have children
self.helio_b = float(sum(azh2 * pzh1 * pe1)) #*power_per_ray
#Helio_2 is effectively what comes out of the heliostats
self.helio_2 = self.helio_1 - self.helio_b #This is effective power out of heliostat in kW
#Recv_2 is rays hitting receiver from heliostat
azr2 = e.tree._bunds[2].get_vertices()[2] > self.dz / 2.0
pzh1 = pz1 < self.dz / 2.0
self.recv_1 = float(sum(azr2 * pzh1 * pe1)) #*power_per_ray
totalabs = 0
#energy locations
front = 0
back = 0
for surface in (self.plant.get_local_objects()[0]).get_surfaces():
energy, pts = surface.get_optics_manager().get_all_hits()
totalabs += sum(energy)
#if surface.iden == "front":
#front += sum(energy)
#if surface.iden == "back":
#back += sum(energy)
#Cosine efficiency calculations
sun_vec = solar_vector(self.azimuth, self.zenith)
tower_vec = -1.0 * self.pos
tower_vec += self.recv_centre
tower_vec /= N.sqrt(N.sum(tower_vec**2, axis=1)[:, None])
hstat = sun_vec + tower_vec
hstat /= N.sqrt(N.sum(hstat**2, axis=1)[:, None])
self.cos_efficiency = sum(N.dot(sun_vec,
(hstat).T)) / float(len(hstat))
#Intermediate Calculation
self.cosshadeeff = (self.helio_0) / (self.DNI * self.helio_area)
#Results
self.p_recvabs = totalabs #Total power absrorbed by receiver
self.coseff = self.cos_efficiency
self.shadeeff = self.cosshadeeff / self.coseff
self.refleff = (self.helio_1) / (self.helio_0)
self.blockeff = (self.helio_1 - self.helio_b) / (self.helio_1)
self.spilleff = (self.recv_1) / (self.helio_2)
self.abseff = (self.p_recvabs - self.recv_0) / (self.recv_1)
self.opteff = (self.p_recvabs - self.recv_0) / (
self.DNI * self.helio_area) #OpticalEfficiency
self.hist_out = self.hist_flux(bins)
self.Square_spilleff = (self.SquareEnergy - self.recv_0) / (
self.helio_2) #provided absorptivity of recv is 1.0
self.Square_opteff = (self.SquareEnergy - self.recv_0) / (
self.DNI * self.helio_area) #ditto
