def __init__(Lambda):
theta_I = ThetaI(Lambda)
Waist0 = Waist0E(Lambda)
source_k = Optics.SourceGaussian(Lambda, Waist0)
source_pd = Fundation.PositioningDirectives(
ReferTo = 'absolute',
XYCentre = [0,0],
Angle = 0)
source = Fundation.OpticalElement(source_k,
Name = 'Fel1 source',
IsSource = True,
PositioningDirectives = source_pd)
plt.xlabel('mm')
plt.title('|E| (' + oe.Name + ')')
print(__name__)
if __name__ == '__main__':
tl.Debug.On = True
N = 7000
UseCustomSampling = True
# SOURCE
#==========================================================================
Lambda = 32e-9
Waist0 = Fermi.Waist0E(Lambda)
s_k = Optics.SourceGaussian(Lambda, Waist0) # Kernel delle ottiche
s_pd = Fundation.PositioningDirectives( # Direttive di posizionamento
ReferTo = Fundation.PositioningDirectives.ReferTo.AbsoluteReference,
XYCentre = [0.0, 0.0],
Angle = 0.0)
s = OpticalElement(s_k,
PositioningDirectives = s_pd,
Name = 'source',
IsSource = True)
# PM1A (h)
#==========================================================================
pm1a_k = Optics.MirrorPlane(L=0.4, AngleGrazing = deg2rad(2.5) )
pm1a_pd = Fundation.PositioningDirectives(
ReferTo = 'upstream',
PlaceWhat = 'centre',
PlaceWhere = 'centre',
Distance = 48.0901)
pm1a = OpticalElement(pm1a_k,
def __init__(self):
super(WisePropagationElements, self).__init__()
self.__wise_propagation_elements = Fundation.BeamlineElements()
from wiselib2.must import *
from wiselib2.Fundation import OpticalElement
print(__name__)
if __name__ == '__main__':
tl.Debug.On = True
# SOURCE
#------------------------------------------------------------
Lambda = 5e-9
Waist0 =Fermi.Waist0E(Lambda)
s_k = Optics.SourceGaussian(Lambda, Waist0)
s_pd = Fundation.PositioningDirectives(
ReferTo = 'absolute',
XYCentre = [0,0],
Angle = np.deg2rad(0))
s = OpticalElement(
s_k,
PositioningDirectives = s_pd,
Name = 'source', IsSource = True)
# KB(h)
#------------------------------------------------------------
f1 = Fermi.Dpi.Kbv.f1
f2 = Fermi.Dpi.Kbv.f2
GrazingAngle = Fermi.Dpi.Kbv.GrazingAngle
kb_k = Optics.MirrorElliptic(f1 = f1, f2 = f2 , L= 0.4, Alpha = GrazingAngle)
kb_k.ComputationSettings.UseIdeal = False
print(__name__)
if __name__ == '__main__':
PropagationManager.Instance().add_propagator(WisePropagator())
tl.Debug.On = True
N = 7000
UseCustomSampling = True
# SOURCE
#==========================================================================
Lambda = 32e-9
Waist0 = Fermi.Waist0E(Lambda)
s_k = Optics.SourceGaussian(Lambda, Waist0) # Kernel delle ottiche
s_pd = Fundation.PositioningDirectives( # Direttive di posizionamento
ReferTo=Fundation.PositioningDirectives.ReferTo.AbsoluteReference,
XYCentre=[0, 0],
Angle=deg2rad(0))
s = WiseGaussianSource(name='source',
source_gaussian=s_k,
position_directives=s_pd)
# PM1A (h)
#==========================================================================
pm1a_k = Optics.MirrorPlane(L=0.4, AngleGrazing=deg2rad(2.5))
pm1a_pd = Fundation.PositioningDirectives(ReferTo='upstream',
PlaceWhat='centre',
PlaceWhere='centre',
Distance=48090.1)
pm1a = WisePlaneMirror(name='pm1a',
def do_best_focus_calculation(self):
try:
if self.input_data is None:
raise Exception("No Input Data!")
if not self.output_data_best_focus:
raise Exception("Run computation first!")
sys.stdout = EmittingStream(textWritten=self.writeStdOut)
# TODO: TO BE CHECKED THE EQUiVALENT OF THE OLD QUANTITY!!!!
self.oe_f2 = self.output_data_best_focus.wise_beamline.get_wise_propagation_element(
-1).PositioningDirectives.Distance
self.check_fields()
if self.defocus_start >= self.defocus_stop:
raise Exception(
"Defocus sweep start must be < Defocus sweep stop")
self.defocus_step = congruence.checkStrictlyPositiveNumber(
self.defocus_step, "Defocus sweep step")
if self.defocus_step >= self.defocus_stop - self.defocus_start:
raise Exception("Defocus step is too big")
if self.best_focus_slider is None:
self.best_focus_slider = QSlider(self.tab[1])
self.best_focus_slider.setGeometry(QRect(0, 0, 320, 50))
self.best_focus_slider.setMinimumHeight(30)
self.best_focus_slider.setOrientation(Qt.Horizontal)
self.best_focus_slider.setInvertedAppearance(False)
self.best_focus_slider.setInvertedControls(False)
self.tab[2].layout().addWidget(self.best_focus_slider)
else:
self.best_focus_slider.valueChanged.disconnect()
self.setStatusMessage("")
self.progressBarInit()
self.defocus_list = numpy.arange(
self.defocus_start * self.workspace_units_to_m,
self.defocus_stop * self.workspace_units_to_m,
self.defocus_step * self.workspace_units_to_m)
n_defocus = len(self.defocus_list)
if self.defocus_list[
-1] != self.defocus_stop * self.workspace_units_to_m:
n_defocus += 1
self.defocus_list.resize(n_defocus)
self.defocus_list[
-1] = self.defocus_stop * self.workspace_units_to_m
self.best_focus_slider.setTickInterval(1)
self.best_focus_slider.setSingleStep(1)
self.best_focus_slider.setMinimum(0)
self.best_focus_slider.setMaximum(n_defocus - 1)
self.best_focus_slider.setValue(0)
progress_bar_increment = 100 / n_defocus
n_pools = self.n_pools if self.use_multipool == 1 else 1
hew_min = numpy.inf
index_min_list = []
self.best_focus_index = -1
self.electric_fields_list = []
self.positions_list = []
self.hews_list = []
import copy
last_element = self.get_last_element()
last_element = copy.deepcopy(last_element)
self.setStatusMessage("Calculating Best Focus Position")
self.run_calculation = True
self.defocus_list[numpy.where(
numpy.abs(self.defocus_list) < 1e-15)] = 0.0
if self.show_animation == 1:
for i, defocus in enumerate(self.defocus_list):
if not self.run_calculation:
if not self.best_focus_slider is None:
self.best_focus_slider.valueChanged.connect(
self.plot_detail)
return
ResultList, HewList, SigmaList, More = Fundation.FocusSweep(
last_element, [self.defocus_list[i]],
DetectorSize=self.length * self.workspace_units_to_m,
NPools=n_pools)
S = ResultList[0].S
E = ResultList[0].Field
I = abs(E)**2
norm = max(I)
norm = 1.0 if norm == 0.0 else norm
I = I / norm
HEW = HewList[0]
# E1
self.electric_fields_list.append(E)
self.positions_list.append(S)
self.hews_list.append(HEW)
self.best_focus_slider.setValue(i)
self.plot_histo(S * 1e6,
I,
i * progress_bar_increment,
tabs_canvas_index=2,
plot_canvas_index=2,
title="Defocus Sweep: " +
str(self._defocus_sign * defocus /
self.workspace_units_to_m) + " (" +
str(i + 1) + "/" + str(n_defocus) +
"), HEW: " + str(round(HEW * 1e6, 4)) +
" [$\mu$m]",
xtitle="Y [$\mu$m]",
ytitle="Intensity",
log_x=False,
log_y=False)
self.tabs.setCurrentIndex(2)
hew = round(
HEW * 1e6, 11
) # problems with double precision numbers: inconsistent comparisons
if hew < hew_min:
hew_min = hew
index_min_list = [i]
elif hew == hew_min:
index_min_list.append(i)
else: # NOT INTERACTIVE
ResultList, HewList, SigmaList, More = Fundation.FocusSweep(
last_element,
self.defocus_list,
DetectorSize=self.length * self.workspace_units_to_m,
NPools=n_pools)
i = 0
for Result, HEW in zip(ResultList, HewList):
self.electric_fields_list.append(Result.Field)
self.positions_list.append(Result.S)
self.hews_list.append(HEW)
hew = round(
HEW * 1e6, 11
) # problems with double precision numbers: inconsistent comparisons
if hew < hew_min:
hew_min = hew
index_min_list = [i]
elif hew == hew_min:
index_min_list.append(i)
i += 1
index_min = index_min_list[int(
len(index_min_list) /
2)] # choosing the central value, when hew reach a pletau
self.best_focus_index = index_min
best_focus_electric_fields = self.electric_fields_list[index_min]
best_focus_I = abs(best_focus_electric_fields)**2
norm = max(best_focus_I)
norm = 1.0 if norm == 0.0 else norm
best_focus_I = best_focus_I / norm
best_focus_positions = self.positions_list[index_min]
QMessageBox.information(
self, "Best Focus Calculation",
"Best Focus Found!\n\nPosition: " +
str(self.oe_f2 +
(self._defocus_sign * self.defocus_list[index_min] /
self.workspace_units_to_m)) + "\nHEW: " +
str(round(self.hews_list[index_min] * 1e6, 4)) + " [" +
u"\u03BC" + "m]", QMessageBox.Ok)
self.plot_histo(
best_focus_positions * 1e6,
best_focus_I,
100,
tabs_canvas_index=2,
plot_canvas_index=2,
title="(BEST FOCUS) Defocus Sweep: " +
str(self._defocus_sign * self.defocus_list[index_min] /
self.workspace_units_to_m) + " (" + str(index_min + 1) +
"/" + str(n_defocus) + "), Position: " +
str(self.oe_f2 +
(self._defocus_sign * self.defocus_list[index_min] /
self.workspace_units_to_m)) + ", HEW: " +
str(round(self.hews_list[index_min] * 1e6, 4)) + " [$\mu$m]",
xtitle="Y [$\mu$m]",
ytitle="Intensity",
log_x=False,
log_y=False)
self.plot_histo(self._defocus_sign * self.defocus_list,
numpy.multiply(self.hews_list, 1e6),
100,
tabs_canvas_index=3,
plot_canvas_index=3,
title="HEW vs Defocus Sweep",
xtitle="",
ytitle="",
log_x=False,
log_y=False)
self.plot_canvas[3].setDefaultPlotLines(True)
self.plot_canvas[3].setDefaultPlotPoints(True)
self.plot_canvas[3].setGraphXLabel("Defocus [" +
self.workspace_units_label +
"]")
self.plot_canvas[3].setGraphYLabel("HEW [$\mu$m]")
self.best_focus_slider.setValue(index_min)
self.tabs.setCurrentIndex(3 if self.show_animation == 1 else 2)
self.setStatusMessage("")
self.save_button.setEnabled(True)
except Exception as exception:
QMessageBox.critical(self, "Error", str(exception), QMessageBox.Ok)
self.setStatusMessage("Error!")
#raise exception
if not self.best_focus_slider is None:
self.best_focus_slider.valueChanged.connect(self.plot_detail)
self.progressBarFinished()
#----------------------------------------------------
tl.Debug.On = False
Lambda = 5e-9
# Gaussian Source (if used)
FermiFactor = {'fel1': 1.25, 'fel2': 1.5}['fel2']
FermiSigma = FermiFactor * Lambda * 1e9
FermiWaist = FermiSigma * np.sqrt(2)
FermiDivergence = Lambda / np.pi / FermiWaist
s = OpticalElement(
Optics.SourceGaussian(Lambda,
FermiWaist,
PropagationAngle=0 * 0.0008257924757473173),
PositioningDirectives=Fundation.PositioningDirectives(ReferTo='absolute',
XYCentre=[0, 1],
Angle=np.deg2rad(0)),
Name='source',
IsSource=True)
#----------------------------------------------------
# kb1
#----------------------------------------------------
kb1 = OpticalElement(Optics.MirrorElliptic(f1=98.5,
f2=1.180,
L=0.4,
Alpha=np.deg2rad(2)),
PositioningDirectives=Fundation.PositioningDirectives(
ReferTo='upstream',
PlaceWhat='upstream focus',
PlaceWhere='centre',