def trace(self): # define the tracer engine e = TracerEngine(self.system) e.minerer=1e-10 #define the rays rays=self.gen_rays() # ray-tracing e.ray_tracer(rays, reps=100, min_energy=1e-10) if self.rendering: trace_scene=Renderer(e) trace_scene.show_rays(resolution=10)
def trace(self): ''' Raytrace method. Raytraces successive bundles and stores the results of the fluxmap on the receiver. ''' #============================== # Initialise the simulation #============================== # record processing time timer_rays=0. timer_mcrt=0. timer_postprocess=0. timer_total=time.time() # define bins for fluxmap bins, bin_area, fluxmap = bin_element(self.m, self.n, self.rec_w, self.rec_h) rbins, rb_area, r_flux = bin_radius(self.rec_w, self.rec_h, self.p) dx=self.rec_w/float(self.m) dy=self.rec_h/float(self.n) xf=N.linspace(-self.rec_w/2.+dx/2.,self.rec_w/2.-dx/2.,self.m) yf=N.linspace(-self.rec_h/2.+dy/2.,self.rec_h/2.-dy/2.,self.n) # initialise energy and Confident Interval (CI) Q_rec_00=0. Q_shade=0. Q_hst_abs=0. Q_block=0 Q_in=0. Q_refl=0. Q_spil=0. Q_abs=0. abs_front=0. abs_back=0. ci_flux=10000 ci_in=10000 ci_shade=10000 ci_field=10000 ci_block=10000 X_flux=0 X_in=0 X_shade=0 X_block=0 X_field=0 Q_pk=N.array(()) Q_in_all=N.array(()) Q_shade_all=N.array(()) Q_field_all=N.array(()) Q_block_all=N.array(()) CI_flux=N.array(([])) CI_in=N.array(([])) CI_shade=N.array(([])) CI_field=N.array(([])) CI_block=N.array(([])) i=0 eff_rays=0. peak=300. Q_in=5000. if self.convergent=='energy': a=ci_shade b=self.cvg_value*Q_shade elif self.convergent=='flux': a=ci_flux b=self.cvg_value*peak elif self.convergent=='iters': a=self.cvg_value b=i elif self.convergent=='rays': a=self.cvg_value b=eff_rays #==================== # Ray Tracing #==================== # define the tracer engine sys=time.time() e = TracerEngine(self.system) e.minerer=1e-10 timer_sys=time.time()-sys # iterations on ray-tracing while (a>b or i<=10): print '' print '' print 'ITERATION ', i+1 # generate rays ray_time=time.time() rays=self.gen_rays() timer_rays+=time.time()-ray_time # MC ray-tracing mcrt=time.time() e.ray_tracer(rays, reps=100, min_energy=1e-10) timer_mcrt+=time.time()-mcrt if self.rendering: trace_scene=Renderer(e) trace_scene.show_rays(resolution=10) # Get results # flux for each surface from Absorption Account postprocess=time.time() front =self.system._objects[0].get_surfaces()[0] back = self.system._objects[0].get_surfaces()[1] # the absorbed energy from absorption account en, pts = front.get_optics_manager().get_all_hits() en2, pts2 = back.get_optics_manager().get_all_hits() abs_front=(abs_front*float(i)+N.sum(en)/1000.)/float(i+1) abs_back =(abs_back*float(i)+N.sum(en2)/1000.)/float(i+1) # flux distribution on the front surface x, y = front.global_to_local(pts)[:2] H, xbins, ybins = N.histogram2d(x, y, bins, weights=en) fluxmap_i=H/(1000.*bin_area) fluxmap = (fluxmap*float(i)+fluxmap_i)/float(i+1) peak=N.max(fluxmap) average=N.sum(fluxmap)/float(self.m)/float(self.n) r=N.sqrt(x**2+y**2) rh,redge=N.histogram(r,rbins,weights=en) r_flux=(r_flux*float(i)+rh/(1000.*rb_area))/float(i+1) radius=redge[1:]-(redge[1]-redge[0])/2. # get the field-wide energy Q_total_inc,Q_rec00_i, Q_shade_i,Q_hst_abs_i, Q_block_i, Q_in_i,Q_spil_i,Q_refl_i,Q_abs_i,eff_rays_i,success=get_energy(e, self.loc_z-self.rec_h*3., self.hst_w, self.hst_h, self.num_hst, self.DNI, self.reflectivity) if success: Q_rec_00=(Q_rec_00*float(i)+Q_rec00_i)/float(i+1) Q_shade=(Q_shade*float(i)+Q_shade_i)/float(i+1) Q_hst_abs=(Q_hst_abs*float(i)+Q_hst_abs_i)/float(i+1) Q_block=(Q_block*float(i)+Q_block_i)/float(i+1) Q_in=(Q_in*float(i)+Q_in_i)/float(i+1) Q_spil=(Q_spil*float(i)+Q_spil_i)/float(i+1) Q_refl=(Q_refl*float(i)+Q_refl_i)/float(i+1) Q_abs=(Q_abs*float(i)+Q_abs_i)/float(i+1) eff_rays+=eff_rays_i Q_abs_acc=abs_front+abs_back ci_flux, X_flux=confidence_interval(fluxmap_i,i, X_flux,fluxmap) Ci_flux=N.max(ci_flux) ci_in, X_in=confidence_interval(Q_in_i, i, X_in, Q_in) ci_shade, X_shade=confidence_interval(Q_shade_i, i, X_shade, Q_shade) ci_block, X_block=confidence_interval(Q_block_i, i, X_block, Q_block) ci_field, X_field=confidence_interval(Q_hst_abs_i, i, X_field,Q_hst_abs) if (i%10==0 and i!=0): CI_in=N.append(CI_in, ci_in) CI_shade=N.append(CI_shade, ci_shade) CI_field=N.append(CI_field, ci_field) CI_block=N.append(CI_block, ci_block) Q_in_all=N.append(Q_in_all, Q_in) Q_shade_all=N.append(Q_shade_all, Q_shade) Q_field_all=N.append(Q_field_all, Q_hst_abs) Q_block_all=N.append(Q_block_all, Q_block) Q_pk=N.append(Q_pk, peak) CI_flux=N.append(CI_flux, Ci_flux) # save results if (i%200==0 and i!=0): results=N.array(( ['Q_total_field_area (kW)',Q_total_inc], ['Q_shade_and_cosine (kW)',Q_shade], ['Q_block (kW)',Q_block], ['Q_field_abs (kW)',Q_hst_abs], ['', ''], ['Q_spil (kW)',Q_spil], ['Q_refl (kW)',Q_refl], ['Q_abs (kW)',Q_abs], ['', ''], ['receiver efficiency ',Q_abs/Q_in], ['F_spil 100%',Q_spil/Q_in], ['F_refl 100%',Q_refl/Q_in], ['', ''], ['Peak Flux (kW/m2)',peak], ['Average Flux (kW/m2)',average], ['', ''], ['CI_flux',Ci_flux], ['CI_en',ci_in], ['CI_shade',ci_shade], ['CI_field',ci_field], ['CI_block',ci_block], ['', ''], ['effecitve rays (million)',eff_rays/1.e6], ['Time gen system (min)',timer_sys/60.], ['Time gen rays (min)',timer_rays/60.], ['Time MCRT (min)', timer_mcrt/60.], ['Time postprocessing (min)',timer_postprocess/60.], ['Total time (min)',total_time/60.])) N.savetxt(self.savefolder+'/results.csv', results, fmt='%s', delimiter=',') title=N.array(['x(m)', 'y(m)', 'flux (kW/m2)']) flux=fluxmap.T # view the flux distribution at the position faces to the tower if self.hemisphere=='North': flux=N.fliplr(flux) flux=N.flipud(flux) flux=flux.flatten() X,Y=N.meshgrid(xf, yf) X=X.flatten() Y=Y.flatten() fluxfile=N.hstack((X,Y)) fluxfile=N.hstack((fluxfile, flux)) fluxfile=fluxfile.reshape(3,len(fluxfile)/3) fluxfile=fluxfile.T title=N.array(['x (m)','y (m)', 'flux (kW/m2)']) fluxfile=N.vstack((title, fluxfile)) N.savetxt(self.savefolder+'/fluxmap.csv', fluxfile, fmt='%s', delimiter=',') timer_postprocess+=time.time()-postprocess total_time=time.time()-timer_total print ' Case', self.case print ' time_sys ', timer_sys/60., 'min' print ' time rays', timer_rays/60., 'min' print ' time_mcrt', timer_mcrt/60., 'min' print ' time processing ', timer_postprocess/60., 'min' print ' total time', total_time/60., 'min' print ' ' print ' Q_sun:', Q_total_inc print ' Q_shade:', Q_shade, '+/-', ci_shade print ' Q_abs_field:',Q_hst_abs, '+/-', ci_field print ' Q_block:', Q_block, '+/-', ci_block print ' Q_in:',Q_in, '+/-', ci_in print ' Q_abs:', Q_abs print ' Q_spil:', Q_spil print ' Q_ref:',Q_refl print ' close1??:', Q_total_inc-Q_shade-Q_block-Q_hst_abs-Q_in print ' close2??:', Q_in-Q_abs-Q_spil-Q_refl print ' ' print ' Peak flux (kW/m2):',peak, '+/-', Ci_flux print ' AVG flux(kW/m2): ', N.max(average) print ' ' print ' efficiency=Q_abs/Q_in:', Q_abs/Q_in print ' spil%= Q_spil/Q_in:', Q_spil/Q_in print ' ref%= Q_ref/Q_in:', Q_refl/Q_in print '' print ' Q_acc',Q_abs_acc print ' Q_tree',Q_abs print '' print ' effective rays',eff_rays #============================================================== e.tree._bunds = [] for clear in xrange(len(e._asm.get_surfaces())): e._asm.get_surfaces()[clear].get_optics_manager().reset() #============================================================== i+=1 if self.convergent=='energy': a=ci_shade b=self.cvg_value*Q_shade elif self.convergent=='flux': a=Ci_flux b=self.cvg_value*peak elif self.convergent=='iters': b=i elif self.convergent=='rays': b=eff_rays