Skip to content

Offline calculator

TFS_Calculator

Bases: object

Source code in tfs/offline_calculator.py 
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
class TFS_Calculator(object):
    def __init__(self, tfs_lenses, prefocus_lenses=None):
        self.tfs_lenses = tfs_lenses
        self.prefocus_lenses = prefocus_lenses
        self.combos = self.combinations()
        return

    def combinations(self):
        """
        All possible combinations of the given lenses

        Parameters
        ----------

        Returns
        -------
        combos: list
            List of LensConnect objects
        """

        tfs_combos = list()
        for i in range(1, len(self.tfs_lenses)+1):
            list_combos = list(itertools.combinations(self.tfs_lenses, i))
            # Create LensConnect objects from all of our possible combinations
            tfs_combos.extend([LensConnect(*combo) for combo in list_combos])
        logger.debug("Found %s combinations of Transfocator lenses",
                     len(tfs_combos))
        return tfs_combos

    def _update_combos(self):
        self.combos = self.combinations()

    def get_pre_focus_lens(self, energy):
        for e_range, lens in MFX_prefocus_energy_range.items():
            if energy >= e_range[0] and energy < e_range[1]:
                pre_focus_lens_idx = lens[0]
                break
        if pre_focus_lens_idx is None:
            pre_focus_lens = None
            print(f"No pre-focussing lens at {energy} eV")
        else:
            pre_focus_lens = self.prefocus_lenses[pre_focus_lens_idx]
            print(f"Pre-focussing lens for {energy} eV:\n{pre_focus_lens}")
            print(f'Radius: {pre_focus_lens.radius} um\n')
        return pre_focus_lens

    @staticmethod
    def get_combo_image(combo, z_obj=0.0):
        return combo.image(z_obj)

    def find_solution(self, target, energy, n=4, z_obj=0.0):
        """
        Find a combination to reach a specific focus

        Parameters
        ----------
        target: float
            The desired position of the focal plane in accelerator coordinates

        n : int, optional
            The maximum number of lenses in a valid combination. This saves
            time by avoiding calculating the focal plane of combinations with a
            large number of lenses

        z_obj : float, optional
            The source point of the beam

        Returns
        -------
        array: LensConnect
            An array of lens combinations with the closest possible image to
            the target_image

        Steps:
        1) find the right pre-focussing lens. These are pre-defined based on
        the photon energy (see prefocus_energy_range) and add it to the combos.
        2) Calculate the focus and the difference to the target for each TFS
        lens combination.
        3) Pick the combo with the smallest difference
        """

        # Step 1
        pre_focus_lens = self.get_pre_focus_lens(energy)
        if pre_focus_lens is None:
            combos = self.combos
        else:
            pre_focus_lens = self.get_pre_focus_lens(energy)
            combos = []
            for combo in self.combos:
                c = LensConnect(pre_focus_lens)
                lens_combo = LensConnect.connect(c, combo)
                combos.append(lens_combo)

        # Step 2
        diff = []
        for ii, combo in enumerate(self.combos):
            if combo.nlens > n:
                continue
            image = combo.image(z_obj, energy)
            diff.append(np.abs(image - target))

        # Step 3
        solution = combos[np.argmin(diff)]
        return solution, np.min(diff)

combinations()

All possible combinations of the given lenses

Parameters:

Name Type Description Default
Returns
required
combos

List of LensConnect objects

 required
Source code in tfs/offline_calculator.py 
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
def combinations(self):
    """
    All possible combinations of the given lenses

    Parameters
    ----------

    Returns
    -------
    combos: list
        List of LensConnect objects
    """

    tfs_combos = list()
    for i in range(1, len(self.tfs_lenses)+1):
        list_combos = list(itertools.combinations(self.tfs_lenses, i))
        # Create LensConnect objects from all of our possible combinations
        tfs_combos.extend([LensConnect(*combo) for combo in list_combos])
    logger.debug("Found %s combinations of Transfocator lenses",
                 len(tfs_combos))
    return tfs_combos

find_solution(target, energy, n=4, z_obj=0.0)

Find a combination to reach a specific focus

Parameters:

Name Type Description Default
target

The desired position of the focal plane in accelerator coordinates

 required
n int

The maximum number of lenses in a valid combination. This saves time by avoiding calculating the focal plane of combinations with a large number of lenses

 4
z_obj float

The source point of the beam

 0.0

Returns:

Name Type Description
array LensConnect

An array of lens combinations with the closest possible image to the target_image
Steps
1) find the right pre-focussing lens. These are pre-defined based on
the photon energy (see prefocus_energy_range) and add it to the combos.
2) Calculate the focus and the difference to the target for each TFS
lens combination.
3) Pick the combo with the smallest difference
Source code in tfs/offline_calculator.py 
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
def find_solution(self, target, energy, n=4, z_obj=0.0):
    """
    Find a combination to reach a specific focus

    Parameters
    ----------
    target: float
        The desired position of the focal plane in accelerator coordinates

    n : int, optional
        The maximum number of lenses in a valid combination. This saves
        time by avoiding calculating the focal plane of combinations with a
        large number of lenses

    z_obj : float, optional
        The source point of the beam

    Returns
    -------
    array: LensConnect
        An array of lens combinations with the closest possible image to
        the target_image

    Steps:
    1) find the right pre-focussing lens. These are pre-defined based on
    the photon energy (see prefocus_energy_range) and add it to the combos.
    2) Calculate the focus and the difference to the target for each TFS
    lens combination.
    3) Pick the combo with the smallest difference
    """

    # Step 1
    pre_focus_lens = self.get_pre_focus_lens(energy)
    if pre_focus_lens is None:
        combos = self.combos
    else:
        pre_focus_lens = self.get_pre_focus_lens(energy)
        combos = []
        for combo in self.combos:
            c = LensConnect(pre_focus_lens)
            lens_combo = LensConnect.connect(c, combo)
            combos.append(lens_combo)

    # Step 2
    diff = []
    for ii, combo in enumerate(self.combos):
        if combo.nlens > n:
            continue
        image = combo.image(z_obj, energy)
        diff.append(np.abs(image - target))

    # Step 3
    solution = combos[np.argmin(diff)]
    return solution, np.min(diff)