TZPGcalc.py

# -*- coding: utf-8 -*-
""" TZPG simple calculator for SCS.

    Interactive widget to calculate beam sizes and position at the sample and
    detector planes for the SCS instrument.

    Copyright (2019-2021) SCS Team.
"""

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.patches import PathPatch, Rectangle, Polygon
from matplotlib.colors import hsv_to_rgb
from matplotlib.path import Path

import ipywidgets as widgets
from ipywidgets import HBox, VBox
from IPython.display import display

from TZPGcalc.GeoBeams import GeoBeams


# number of membrane to show
SampleN = 7

# Database of existing zone plates parameters
TZPG_db = {
    'Custom': {
        'design_nrj': 860,
        'TZPGwH': 1,
        'TZPGwV': 1,
        'TZPGoffaxis': 0.75,
        'grating': 3.8,
        'F_x': 0.25,
        'F_y': 0.25,
        '3beams': True
    },
    'O': {
        'design_nrj': 530,
        'TZPGwH': 0.8,
        'TZPGwV': 0.8,
        'TZPGoffaxis': 0.55,
        'grating': 3.1,
        'F_x': 0.25,
        'F_y': 0.25,
        '3beams': True
    },
    'Fe': {
        'design_nrj': 715,
        'TZPGwH': 0.8,
        'TZPGwV': 0.8,
        'TZPGoffaxis': 0.55,
        'grating': 3.1,
        'F_x': 0.25,
        'F_y': 0.25,
        '3beams': True
    },
    'Co': {
        'design_nrj': 785,
        'TZPGwH': 0.8,
        'TZPGwV': 0.8,
        'TZPGoffaxis': 0.55,
        'grating': 3.1,
        'F_x': 0.25,
        'F_y': 0.25,
        '3beams': True
    },
    'Ni': {
        'design_nrj': 860,
        'TZPGwH': 0.8,
        'TZPGwV': 0.8,
        'TZPGoffaxis': 0.55,
        'grating': 3.1,
        'F_x': 0.25,
        'F_y': 0.25,
        '3beams': True
    },
    'Cu': {
        'design_nrj': 927,
        'TZPGwH': 0.8,
        'TZPGwV': 0.8,
        'TZPGoffaxis': 0.55,
        'grating': 3.1,
        'F_x': 0.25,
        'F_y': 0.25,
        '3beams': True
    },
    'Gd': {
        'design_nrj': 1210,
        'TZPGwH': 0.8,
        'TZPGwV': 0.8,
        'TZPGoffaxis': 0.55,
        'grating': 3.1,
        'F_x': 0.25,
        'F_y': 0.25,
        '3beams': True
    }
}


class TZPGcalc():
    def __init__(self):
        self.geo_beams = GeoBeams()
        self.initWidgets()
        self.initFig()
        self.init_beam_transport()

        # spot sizes of all beams
        self.SpotSizes = {}
        for d in ['det', 'sam']:
            self.SpotSizes[d] = {}
            for k in ['L', 'H']:
                self.SpotSizes[d][k] = np.zeros((6, 2))

        # spot center of all beams
        self.SpotCenters = {}
        for d in ['det', 'sam']:
            self.SpotCenters[d] = {}
            for k in ['L', 'H']:
                self.SpotCenters[d][k] = np.zeros((6, 2))

        self.UpdateFig()
        display(self.control)

    def init_beam_transport(self):
        temp = GeoBeams()
        # set default value for beam transport
        for v in ['fVFM', 'fHFM', 'EXw', 'IHFw']:
            if v in ['fVFM', 'fHFM']:
                scale = 1.0
            else:
                scale = 1e6
            self.widgets[v].value = scale*temp.elems[v]

    def initFig(self):
        "Creates a figure for the sample plane and detector plane images."

        plt.close('TZPGcalc')
        fig, (self.ax_sam, self.ax_det) = plt.subplots(
            1, 2, num='TZPGcalc', figsize=(6, 3))

        # display scale
        self.scale = 1e3  # displayed distances in [mm]

        self.ax_sam.set_title('Sample plane')
        self.ax_det.set_title('Detector plane')

        self.ax_sam.set_aspect('equal')
        self.ax_det.set_aspect('equal')
        self.ax_sam.set_xlim([-2, 2])
        self.ax_sam.set_ylim([-2, 2])
        self.ax_det.set_xlim([-35, 35])
        self.ax_det.set_ylim([-20, 50])

        # red and blue shifted color of the beams
        c_rr = hsv_to_rgb([10/360, 100/100, 70/100])
        c_rb = hsv_to_rgb([220/360, 100/100, 70/100])
        c_gr = hsv_to_rgb([10/360, 100/100, 100/100])
        c_gb = hsv_to_rgb([220/360, 100/100, 100/100])

        self.samBeamsL = {
            'F0G0': self.ax_sam.add_patch(
                Polygon([(0, 0)], facecolor="black", alpha=0.4, lw=None)),
            'F0G1': self.ax_sam.add_patch(
                Polygon([(0, 0)], facecolor="black", alpha=0.4, lw=None)),
            'F0G-1': self.ax_sam.add_patch(
                Polygon([(0, 0)], facecolor="black", alpha=0.4, lw=None)),
            'F1G0': self.ax_sam.add_patch(
                Polygon([(0, 0)], facecolor=c_rr, alpha=0.7, lw=None)),
            'F1G1': self.ax_sam.add_patch(
                Polygon([(0, 0)], facecolor=c_gr, alpha=0.7, lw=None)),
            'F1G-1': self.ax_sam.add_patch(
                Polygon([(0, 0)], facecolor=c_gr, alpha=0.7, lw=None))
            }

        self.detBeamsL = {
            'F0G0': self.ax_det.add_patch(
                Polygon([(0, 0)], facecolor="black", alpha=0.4, lw=None)),
            'F0G1': self.ax_det.add_patch(
                Polygon([(0, 0)], facecolor="black", alpha=0.4, lw=None)),
            'F0G-1': self.ax_det.add_patch(
                Polygon([(0, 0)], facecolor="black", alpha=0.4, lw=None)),
            'F1G0': self.ax_det.add_patch(
                Polygon([(0, 0)], facecolor=c_rr, alpha=0.7, lw=None)),
            'F1G1': self.ax_det.add_patch(
                Polygon([(0, 0)], facecolor=c_gr, alpha=0.7, lw=None)),
            'F1G-1': self.ax_det.add_patch(
                Polygon([(0, 0)], facecolor=c_gr, alpha=0.7, lw=None))
            }

        self.samBeamsH = {
            'F0G0': self.ax_sam.add_patch(
                Polygon([(0, 0)], facecolor="black", alpha=0.4, lw=None)),
            'F0G1': self.ax_sam.add_patch(
                Polygon([(0, 0)], facecolor="black", alpha=0.4, lw=None)),
            'F0G-1': self.ax_sam.add_patch(
                Polygon([(0, 0)], facecolor="black", alpha=0.4, lw=None)),
            'F1G0': self.ax_sam.add_patch(
                Polygon([(0, 0)], facecolor=c_rb, alpha=0.7, lw=None)),
            'F1G1': self.ax_sam.add_patch(
                Polygon([(0, 0)], facecolor=c_gb, alpha=0.7, lw=None)),
            'F1G-1': self.ax_sam.add_patch(
                Polygon([(0, 0)], facecolor=c_gb, alpha=0.7, lw=None))
            }

        self.detBeamsH = {
            'F0G0': self.ax_det.add_patch(
                Polygon([(0, 0)], facecolor="black", alpha=0.4, lw=None)),
            'F0G1': self.ax_det.add_patch(
                Polygon([(0, 0)], facecolor="black", alpha=0.4, lw=None)),
            'F0G-1': self.ax_det.add_patch(
                Polygon([(0, 0)], facecolor="black", alpha=0.4, lw=None)),
            'F1G0': self.ax_det.add_patch(
                Polygon([(0, 0)], facecolor=c_rb, alpha=0.7, lw=None)),
            'F1G1': self.ax_det.add_patch(
                Polygon([(0, 0)], facecolor=c_gb, alpha=0.7, lw=None)),
            'F1G-1': self.ax_det.add_patch(
                Polygon([(0, 0)], facecolor=c_gb, alpha=0.7, lw=None))
            }

        self.detLines = {
            'module': self.ax_det.add_patch(
                Rectangle((0, 0), 1, 1, fill=False, facecolor='k')),
            'Vfilter': self.ax_det.add_patch(
                Rectangle((0, 0), 1, 1, facecolor="green", alpha=0.4)),
            'Hfilter': self.ax_det.add_patch(
                Rectangle((0, 0), 1, 1, facecolor="green", alpha=0.4)),
            'diamond': self.ax_det.add_patch(
                Rectangle((-8, -8), 16, 16, facecolor="green", alpha=0.4,
                          angle=45))
               }

        # SampleNxSampleN membranes
        self.sampleLines = {}
        self.etchLines = {}
        for k in range(SampleN*SampleN):
            self.sampleLines[k] = self.ax_sam.add_patch(
                Rectangle((0, 0), 1, 1, fill=False, facecolor='k'))
            self.etchLines[k] = self.ax_sam.add_patch(
                Rectangle((0, 0), 1, 1, fill=False, facecolor='k',
                          alpha=0.4, ls='--'))

        # Flat Liquid Jet
        self.FLJ_lines = {}
        self.FlatLiquidJet()

    def FlatLiquidJet(self):
        """Draw a Flat Liquid jet.
        """
        sw = self.widgets
        HW = 0.5*sw['FLJ_W'].value  # [mm]
        L = sw['FLJ_L'].value  # [mm]
        mf = sw['FLJ_mf'].value  # [mm]
        incidence = np.deg2rad(sw['samIncidence'].value)  # [rad]
        ox = sw['samX'].value  # [mm]
        oy = -L/2 + sw['samY'].value  # [mm]

        # incidence angle squeezes sample
        ci = np.cos(incidence)

        verts = [
            [(0*ci, L + oy),   # P0
             (HW/2*ci, L + oy),  # P1
             (HW*ci, 0.5*(1+mf)*L + oy),  # P2
             (HW*ci, mf*L + oy)],  # P3
            [(HW*ci, mf*L + oy),  # P0
             (HW*ci, 0.5*mf*L + oy),  # P1
             (0, 0 + oy),  # P2
             (0, 0 + oy)]  # P3
        ]

        # second half image of liquid jet
        mirror = []
        for v in verts:
            mirror.append([(-p[0], p[1]) for p in v])

        verts += mirror

        # apply offsets
        fverts = []
        for v in verts:
            fverts.append([(p[0] + ox, p[1]) for p in v])

        codes = [
            Path.MOVETO,  # P0
            Path.CURVE4,  # P1
            Path.CURVE4,  # P2
            Path.CURVE4  # P3
        ]

        for k, v in enumerate(fverts):
            path = Path(v, codes)
            if k in self.FLJ_lines:
                self.FLJ_lines[k].remove()

            self.FLJ_lines[k] = self.ax_sam.add_patch(
                PathPatch(path, alpha=0.4, facecolor='none', lw=2)
                )

    def RectUpdate(self, rect, xLeft, yBottom, xRight, yTop):
        """Updates the position and size of the given Rectangle.

        Inputs
        ------
            rect: Rectangle to update
            xLeft: x position of the left corner
            yBottom: y position of the bottom corner
            xRight: x position of the right corner
            yTop: y position of the top corner
        """

        xw = np.abs(xLeft - xRight)
        yw = np.abs(yTop - yBottom)

        rect.set_xy((self.scale*xLeft, self.scale*yBottom))
        rect.set_height(self.scale*yw)
        rect.set_width(self.scale*xw)

    def PolyUpdate(self, poly, xLeft, yBottom, xRight, yTop):
        """Updates the corner position of a Polygon.

        Inputs
        ------
            poly: regular Polygon to update
            xLeft: x position of the left corner
            yBottom: y position of the bottom corner
            xRight: x position of the right corner
            yTop: y position of the top corner
        """

        xy = self.scale*np.array([
            [xLeft, yBottom],
            [xLeft, yTop],
            [xRight, yTop],
            [xRight, yBottom]])

        poly.set_xy(xy)

    def UpdateBeams(self, Beams, img, conf):
        """Updates the position and size of the beams.

        Inputs
        ------
            Beams: dictionary of f'F{f}G{g}' Polygon for f = 0 and 1 zone
                plate order and g = +1, 0 and -1 grating order
            img: dictionary of parameters for the imaging plane
            conf: dictionary of parameters for optics
        """
        # shortcut
        sge = self.geo_beams.elems

        sge['fBOZ_x'] = conf['F_x']
        sge['fBOZ_y'] = conf['F_y']
        sge['theta_grating'] = conf['theta_grating']

        # imaging plane
        n = np.array([np.sin(img['incidence']),
                      0,
                      np.cos(img['incidence'])])
        p0 = np.array([0, 0, img['z']])

        res = {}
        for z, (f, g) in enumerate([(0, -1), (0, 0), (0, 1),
                                    (1, -1), (1, 0), (1, 1)]):
            beam = f'F{f}G{g}'
            res[beam] = (self.geo_beams.plane_image(p0, n, f, g)
                         - np.array([0, sge['offaxis']]))  # 0th order offset

            corners = self.scale*res[beam]

            Beams[beam].set_xy(corners)
            for k in [0, 1]:
                vs = corners[:, k]
                self.SpotSizes[img['type']][conf['Energy']][z, k] = (
                    1e3*(np.max(vs) - np.min(vs)))
                self.SpotCenters[img['type']][conf['Energy']][z, k] = (
                    1e3*0.5*(np.max(vs) + np.min(vs)))

        # 3 beams configuration
        b = self.widgets['3beams'].value
        Beams['F0G0'].set_visible(b)
        Beams['F1G0'].set_visible(b)

    def DetectorUpdate(self, Xoff, Yoff):
        """Draws DSSC detector module with filter mask.

        Inputs
        ------
            Xoff: x offset
            Yoff: y offset
        """
        # x module axis is vertical, y module axis is horizontal
        # the module 15 is +0.91 mm vertical from the beam and
        # 4.233 mm horizontal from the beam
        offset_h = 4.233e-3  # [m]
        offset_v = 0.91e-3  # [m]

        moduleHw = 256*0.236e-3  # [m]
        moduleVw = 128*0.204e-3  # [m]

        filterW = 7e-3  # [m]
        filterL = 160e-3  # [m]
        diamondW = 16e-3  # [m]

        self.RectUpdate(self.detLines['module'],
                        -moduleHw - offset_h + Xoff, offset_v + Yoff,
                        -offset_h + Xoff, moduleVw + offset_v + Yoff)
        self.RectUpdate(self.detLines['Vfilter'],
                        -filterW/2 + Xoff, -filterL/2 + Yoff,
                        filterW/2 + Xoff, filterL/2 + Yoff)
        self.RectUpdate(self.detLines['Hfilter'],
                        -filterL/2 + Xoff, -filterW/2 + Yoff,
                        filterL/2 + Xoff, filterW/2 + Yoff)

        # moving rotated rectangles is a pain in matplotlib
        self.detLines['diamond'].set_xy((
            self.scale*Xoff, self.scale*(Yoff - diamondW/2*np.sqrt(2))))

    def SampleUpdate(self):
        if self.widgets['SampleType'].value == 'Membranes Array':
            b = True
        elif self.widgets['SampleType'].value == 'Flat Liquid Jet':
            b = False
        else:
            raise ValueError('Sample type must be either "Membranes Array" or'
                             '"Flat Liquid Jet"')

        for k in range(SampleN*SampleN):
            self.sampleLines[k].set_visible(b)
            self.etchLines[k].set_visible(b)

        for k in range(4):
            self.FLJ_lines[k].set_visible(not(b))

        if b:
            self.MembraneSampleUpdate()
        else:
            self.FlatLiquidJet()

    def MembraneSampleUpdate(self):
        """Draws the sample.

        Inputs
        ------
            w: membrane width
            p: membrane pitch
            Xoff: sample x offset
            Yoff: sample y offset
            thickness: sample thickness used to calculate the etched facets
            incidence: incidence angle in rad
            etch_angle: etching angle from surface in rad
        """
        sw = self.widgets
        w = sw['samw'].value*1e-3  # [m]
        p = sw['samp'].value*1e-3  # [m]
        Xoff = sw['samX'].value*1e-3  # [m]
        Yoff = sw['samY'].value*1e-3  # [m]
        thickness = sw['samthickness'].value*1e-6  # [m]
        etch_angle = np.deg2rad(sw['samEtchAngle'].value)  # [rad]
        incidence = np.deg2rad(sw['samIncidence'].value)  # [rad]

        # Si etching angle
        wp = w + 2*thickness/np.tan(etch_angle)

        # incidence angle squeezes sample and etch lines
        # and induces an apparent shift off the etch lines
        ci = np.cos(incidence)
        thsi = thickness*np.sin(incidence)

        j = 0
        for r in range(-(SampleN-1)//2, (SampleN-1)//2+1):
            for c in range(-(SampleN-1)//2, (SampleN-1)//2+1):
                self.RectUpdate(
                    self.sampleLines[j],
                    ci*(r*p - w/2 + Xoff), c*p - w/2 - Yoff,
                    ci*(r*p + w/2 + Xoff), c*p + w/2 - Yoff)
                self.RectUpdate(
                    self.etchLines[j],
                    ci*(r*p - wp/2 + Xoff)+thsi, c*p - wp/2 - Yoff,
                    ci*(r*p + wp/2 + Xoff)+thsi, c*p + wp/2 - Yoff)
                j += 1

    def UpdateFig(self):
        """Updates the figure with the current slider values.

        """
        # shortcuts
        sw = self.widgets
        sge = self.geo_beams.elems

        # we calculate the optics for the central wavelength
        nrjL = sw['nrjL'].value  # [eV]
        nrjH = sw['nrjH'].value  # [eV]
        nrjD = sw['nrjD'].value  # [eV]
        wlL = 1240/nrjL*1e-9
        wlH = 1240/nrjH*1e-9
        wlD = 1240/nrjD*1e-9

        F_x = sw['F_x'].value  # [m] Nominal horiz. BOZ focal length
        F_y = sw['F_y'].value  # [m] Nominal vert. BOZ focal length
        theta_grating = sw['grating'].value*1e-3  # [rad]
        sampleZ = sw['SAMZ'].value*1e-3  # [m]
        samIncidence = np.deg2rad(sw['samIncidence'].value)  # [rad]
        detectorZ = sw['detZ'].value*1e-3  # [m]

        sge['WH'] = sw['TZPGwH'].value*1e-3  # [m]
        sge['WV'] = sw['TZPGwV'].value*1e-3  # [m]
        sge['offaxis'] = -sw['TZPGoffaxis'].value*1e-3  # [m]
        sge['EXw'] = sw['EXw'].value*1e-6  # [m]
        sge['IHFw'] = sw['IHFw'].value*1e-6  # [m]
        sge['fVFM'] = sw['fVFM'].value  # [m]
        sge['fHFM'] = sw['fHFM'].value  # [m]

        d_nominal = wlD/np.sin(theta_grating)
        sw['d_label'].value = (
            f'Grating Pitch:{int(np.round(d_nominal*1e9))} nm')

        # zone plate radius at the point further away from the optical axis
        rn = np.sqrt((sge['WH']/2.0)**2 +
                     (sge['WV']/2.0 + np.abs(sge['offaxis']))**2)
        dr_nominal_x = wlD * F_x / (2*rn)
        dr_nominal_y = wlD * F_y / (2*rn)
        sw['dr_label_x'].value = (
            f'Outer Zone Plate width dr for Horiz. '
            f'focus:{int(np.round(dr_nominal_x*1e9))} nm')
        sw['dr_label_y'].value = (
            f'for Vert. focus:{int(np.round(dr_nominal_y*1e9))} nm')

        # Optics properties (focal length and grating angle) for the
        # low energy and high energy photon
        F_L_x = 2*rn*dr_nominal_x/wlL
        F_L_y = 2*rn*dr_nominal_y/wlL
        G_L = np.arcsin(wlL/d_nominal)
        confL = {'Energy': 'L',
                 'F_x': F_L_x,
                 'F_y': F_L_y,
                 'theta_grating': G_L}

        F_H_x = 2*rn*dr_nominal_x/wlH
        F_H_y = 2*rn*dr_nominal_y/wlH
        G_H = np.arcsin(wlH/d_nominal)
        confH = {'Energy': 'H',
                 'F_x': F_H_x,
                 'F_y': F_H_y,
                 'theta_grating': G_H}

        # Configuration for imaging plane
        sam = {'type': 'sam', 'z': sampleZ, 'incidence': samIncidence}
        det = {'type': 'det', 'z': detectorZ, 'incidence': 0}

        # update the beams
        self.UpdateBeams(self.samBeamsL, sam, confL)
        self.UpdateBeams(self.detBeamsL, det, confL)
        self.UpdateBeams(self.samBeamsH, sam, confH)
        self.UpdateBeams(self.detBeamsH, det, confH)

        # update Spot Size Tables
        for v in ['L', 'H']:
            df = pd.DataFrame(self.SpotSizes['sam'][v],
                              index=['F0G-1', 'F0G0', 'F0G1',
                                     'F1G-1', 'F1G0', 'F1G1'],
                              columns=['H (um)', 'V (um)'])
            self.widgets[f'SpotSize{v}'].value = df.to_html(
                float_format='{:.2f}'.format)
            df = pd.DataFrame(self.SpotCenters['sam'][v],
                              index=['F0G-1', 'F0G0', 'F0G1',
                                     'F1G-1', 'F1G0', 'F1G1'],
                              columns=['H (um)', 'V (um)'])
            self.widgets[f'SpotCenter{v}'].value = df.to_html(
                float_format='{:.2f}'.format)

        # update the detector
        detXoff = self.widgets['detX'].value*1e-3  # [m]
        detYoff = self.widgets['detY'].value*1e-3  # [m]
        self.DetectorUpdate(detXoff, detYoff)

        # update the sample
        self.SampleUpdate()

    def initWidgets(self):
        """ Creates the necessary interactive widget controls.
        """

        style = {'description_width': 'initial'}
        layout = {}  # max_width': '300px'}

        self.Update = widgets.Button(
            description='Update',
        )

        @self.Update.on_click
        def plot_on_click(b):
            self.UpdateFig()

        self.widgets = {}

        # Spot sizes
        self.widgets['SpotSizeL'] = widgets.HTML()
        self.widgets['SpotSizeH'] = widgets.HTML()
        SpotSize = HBox([VBox([widgets.Label(value='Low energy'),
                               self.widgets['SpotSizeL']]),
                         VBox([
                             widgets.Label(value='High energy'),
                             self.widgets['SpotSizeH']])
                         ])
        # Spot centers
        self.widgets['SpotCenterL'] = widgets.HTML()
        self.widgets['SpotCenterH'] = widgets.HTML()
        SpotCenter = HBox([VBox([widgets.Label(value='Low energy'),
                                 self.widgets['SpotCenterL']]),
                           VBox([
                               widgets.Label(value='High energy'),
                               self.widgets['SpotCenterH']])
                         ])
        SpotSizeAndCenter = HBox([
            VBox([widgets.Label(value='Spot Size'), SpotSize]),
            VBox([widgets.Label(value='Spot center'), SpotCenter])
            ])

        # Source
        self.Reset = widgets.Button(
            description='Reset',
        )

        @self.Reset.on_click
        def reset_on_click(b):
            self.init_beam_transport()

        self.widgets['EXw'] = widgets.BoundedIntText(
            value=100,
            min=0,
            max=2000,
            step=1,
            description='Exit Slit (um):',
            style=style,
            layout=layout
        )
        self.widgets['IHFw'] = widgets.BoundedIntText(
            value=200,
            min=0,
            max=2000,
            step=1,
            description='IHF width (um):',
            style=style,
            layout=layout
        )
        self.widgets['fVFM'] = widgets.BoundedFloatText(
            value=0,
            min=0,
            max=10,
            step=0.01,
            description='VFM focal length (m):',
            style=style,
            layout=layout
        )
        self.widgets['fHFM'] = widgets.BoundedFloatText(
            value=0,
            min=0,
            max=10,
            step=0.01,
            description='HFM focal length (m):',
            style=style,
            layout=layout
        )
        SourceTab = VBox([
            self.Reset,
            self.widgets['EXw'],
            self.widgets['IHFw'],
            self.widgets['fVFM'],
            self.widgets['fHFM']])

        # TZPG part
        self.widgets['Type'] = widgets.Dropdown(
            options=list(TZPG_db),
            value='Custom',
            description='Type:',
            style=style,
            disabled=False
            )

        def TZPGtype(change):
            v = TZPG_db[change.new]
            self.widgets['nrjD'].value = v['design_nrj']
            self.widgets['TZPGwH'].value = v['TZPGwH']
            self.widgets['TZPGwV'].value = v['TZPGwV']
            self.widgets['TZPGoffaxis'].value = v['TZPGoffaxis']
            self.widgets['grating'].value = v['grating']
            self.widgets['F_x'].value = v['F_x']
            self.widgets['F_y'].value = v['F_y']
            self.widgets['3beams'].value = v['3beams']

            # necessary to recompute grating pitch and outer zone plate width
            self.UpdateFig()

        self.widgets['Type'].observe(TZPGtype, names='value')

        # hidden nominal zone plate focus
        self.widgets['F_x'] = widgets.BoundedFloatText(
            value=0.25,
            min=0,
            max=1,
            step=0.01,
            description='Focal length (m) Horiz.:',
            style=style,
            layout=layout
        )
        self.widgets['F_y'] = widgets.BoundedFloatText(
            value=0.25,
            min=0,
            max=1,
            step=0.01,
            description='Vert.:',
            style=style,
            layout=layout
        )

        self.widgets['nrjL'] = widgets.BoundedIntText(
            value=840,
            min=450,
            max=3200,
            step=1,
            description='Low:',
            style=style,
            layout=layout
        )
        self.widgets['nrjH'] = widgets.BoundedIntText(
            value=880,
            min=450,
            max=3200,
            step=1,
            description='High:',
            style=style,
            layout=layout
        )
        self.widgets['nrjD'] = widgets.BoundedIntText(
            value=860,
            min=450,
            max=3200,
            step=1,
            width=4,
            description='Design energy (eV):',
            style=style,
            layout=layout
        )
        self.widgets['TZPGwV'] = widgets.BoundedFloatText(
            value=1.0,
            min=.1,
            max=3.0,
            step=0.05,
            description='Height:',
            style=style,
            layout=layout
        )
        self.widgets['TZPGwH'] = widgets.BoundedFloatText(
            value=1.0,
            min=.1,
            max=3.0,
            step=0.05,
            description='Width:',
            style=style,
            layout=layout
        )
        self.widgets['TZPGoffaxis'] = widgets.BoundedFloatText(
            value=0.75,
            min=.0,
            max=2.0,
            step=0.05,
            description='Off axis (mm):',
            style=style,
            layout=layout
        )
        self.widgets['grating'] = widgets.BoundedFloatText(
            value=3.8,
            min=1.,
            max=10.0,
            step=0.05,
            description='Grating angle (mrad):',
            style=style,
            layout=layout
        )
        self.widgets['3beams'] = widgets.Checkbox(
            value=True,
            description='3 beams:',
            style=style,
            layout=layout
        )
        self.widgets['dr_label_x'] = widgets.Label(value='dr_x')
        self.widgets['dr_label_y'] = widgets.Label(value='dr_y')
        self.widgets['d_label'] = widgets.Label(value='dr')
        TZPGTab = VBox([
            self.widgets['Type'],
            HBox([self.widgets['nrjD'],
                  self.widgets['F_x'],
                  self.widgets['F_y']
                  ]),
            HBox([self.widgets['grating'],
                  self.widgets['TZPGoffaxis'],
                  self.widgets['3beams']]),
            HBox([self.widgets['dr_label_x'],
                  self.widgets['dr_label_y']]),
            HBox([widgets.Label(value='Optics (mm):'),
                  self.widgets['TZPGwH'],
                  self.widgets['TZPGwV']]),
            HBox([widgets.Label(value='Energy range (eV):'),
                  self.widgets['nrjL'], self.widgets['nrjH']])
            ])

        # sample part
        self.widgets['SampleType'] = widgets.Dropdown(
            options=['Membranes Array', 'Flat Liquid Jet'],
            value='Membranes Array',
            decription='Sample type:',
            style=style,
            layout=layout
        )
        self.widgets['SAMZ'] = widgets.BoundedFloatText(
            value=30.,
            min=-10.,
            max=180.0,
            step=.1,
            description='Sample Z (mm):',
            style=style,
            layout=layout
        )

        # membranes
        self.widgets['samw'] = widgets.BoundedFloatText(
            value=.5,
            min=0.01,
            max=2.0,
            step=.01,
            description='width (mm):',
            style=style,
            layout=layout
        )
        self.widgets['samp'] = widgets.BoundedFloatText(
            value=1.0,
            min=0.01,
            max=2.0,
            step=.01,
            description='pitch (mm):',
            style=style,
            layout=layout
        )
        self.widgets['samthickness'] = widgets.BoundedFloatText(
            value=381,
            min=1,
            max=1000,
            step=1,
            description='Substrate thickness (um):',
            style=style,
            layout=layout
        )
        self.widgets['samEtchAngle'] = widgets.BoundedFloatText(
            value=54.74,
            min=0,
            max=90,
            step=0.01,
            description='etch angle (deg):',
            style=style,
            layout=layout
        )

        # Flat Liquid Jet
        self.widgets['FLJ_W'] = widgets.BoundedFloatText(
            value=1.0,
            min=0,
            max=5,
            step=0.1,
            description='Flat Liquid Jet width (mm):',
            style=style,
            layout=layout
        )
        self.widgets['FLJ_L'] = widgets.BoundedFloatText(
            value=4.6,
            min=0,
            max=15,
            step=0.1,
            description='of length (mm):',
            style=style,
            layout=layout
        )
        self.widgets['FLJ_mf'] = widgets.BoundedFloatText(
            value=0.75,
            min=0,
            max=1,
            step=0.01,
            description='at:',
            style=style,
            layout=layout
        )

        self.widgets['samX'] = widgets.BoundedFloatText(
            value=0.,
            min=-10,
            max=10,
            step=0.01,
            description='X:',
            style=style,
            layout=layout
        )
        self.widgets['samY'] = widgets.BoundedFloatText(
            value=0.,
            min=-10,
            max=10,
            step=0.01,
            description='Y:',
            style=style,
            layout=layout
        )
        self.widgets['samIncidence'] = widgets.BoundedFloatText(
            value=0,
            min=0,
            max=90,
            step=1,
            description='Sample normal (deg):',
            style=style,
            layout=layout
        )
        samTab = VBox([
            self.widgets['SAMZ'],
            self.widgets['SampleType'],
            HBox([widgets.Label(value='Membranes array, '),
                  self.widgets['samw'],
                  self.widgets['samp']]),
            HBox([self.widgets['samthickness'],
                  self.widgets['samEtchAngle']]),
            HBox([self.widgets['FLJ_W'],
                  self.widgets['FLJ_mf'],
                  self.widgets['FLJ_L']]),
            HBox([widgets.Label(value='Sample Offset (mm), '),
                  self.widgets['samX'],
                  self.widgets['samY']]),
            HBox([self.widgets['samIncidence'],
                  ])
        ])

        # Detector tab
        self.widgets['detZ'] = widgets.BoundedFloatText(
            value=2000.,
            min=1000,
            max=5800,
            step=1,
            description='Z:',
            style=style,
            layout=layout
        )
        self.widgets['detX'] = widgets.BoundedFloatText(
            value=34.5,
            min=-50,
            max=50,
            step=0.5,
            description='X:',
            style=style,
            layout=layout
        )
        self.widgets['detY'] = widgets.BoundedFloatText(
            value=-2.,
            min=-50,
            max=50,
            step=0.5,
            description='Y:',
            style=style,
            layout=layout
        )
        detTab = VBox([HBox([widgets.Label(value='Detector (m), '),
                             self.widgets['detZ'],
                             self.widgets['detX'],
                             self.widgets['detY']
                             ])])

        # combined tabs
        tab0 = widgets.Accordion([SourceTab])
        tab0.set_title(0, 'Source and KBS')
        tab0.selected_index = 0

        tab1 = widgets.Accordion([TZPGTab])
        tab1.set_title(0, 'Beam splitting Off axis Zone plate')
        tab1.selected_index = 0

        tab2 = widgets.Accordion([samTab])
        tab2.set_title(0, 'Sample')
        tab2.selected_index = 0

        tab3 = widgets.Accordion([detTab])
        tab3.set_title(0, 'Detector')
        tab3.selected_index = 0

        tab4 = widgets.Accordion([SpotSizeAndCenter])
        tab4.set_title(0, 'Spot sizes and centers')
        tab4.selected_index = 0

        self.control = VBox([self.Update, tab0, tab1, tab2, tab3, tab4])