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