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