Merge pull request #85 from nulinspiratie/feature/T2_parameter

feature: T2ElectronParameter and T2ElectronPulseSequence capable of T2* to T2DD

silq/parameters/acquisition_parameters.py

@@ -13,7 +13,8 @@
 
 from silq import config
 from silq.pulses import *
-from silq.pulses.pulse_sequences import ESRPulseSequence, NMRPulseSequence
+from silq.pulses.pulse_sequences import ESRPulseSequence, NMRPulseSequence, \
+    T2ElectronPulseSequence
 from silq.analysis import analysis
 from silq.tools import data_tools
 from silq.tools.general_tools import SettingsClass, clear_single_settings, \
@@ -1070,6 +1071,50 @@ def get_raw(self):
         return tuple(self.results[name] for name in self.names)
 
 
+class T2ElectronParameter(AcquisitionParameter):
+    def __init__(self, name='Electron_T2', **kwargs):
+        self.pulse_sequence = T2ElectronPulseSequence()
+
+        super().__init__(name=name,
+                         names=['up_proportion', 'num_traces'],
+                         labels=['Up proportion', 'Number of traces'],
+                         snapshot_value=False,
+                         properties_attrs=['t_skip'],
+                         **kwargs)
+
+        self.pre_pulses = self.pulse_sequence.pre_pulses
+        self.post_pulses = self.pulse_sequence.post_pulses
+        self.ESR = self.pulse_sequence.ESR
+
+    @property
+    def inter_delay(self):
+        return self.ESR['inter_delay']
+
+    @inter_delay.setter
+    def inter_delay(self, inter_delay):
+        self.ESR['inter_delay'] = inter_delay
+
+    @clear_single_settings
+    def get_raw(self):
+        self.acquire()
+
+        # Analysis
+        self.results = analysis.analyse_multi_read_EPR(
+            pulse_traces=self.data['read']['output'],
+            t_read=self.t_read,
+            t_skip=self.t_skip,
+            sample_rate=self.sample_rate)
+
+        # Store raw traces if self.save_traces is True
+        if self.save_traces:
+            self.store_traces(self.data)
+
+        if not self.silent:
+            self.print_results()
+
+        return tuple(self.results[name] for name in self.names)
+
+
 class DarkCountsParameter(AcquisitionParameter):
     def __init__(self, name='dark_counts', **kwargs):
         """

silq/pulses/pulse_sequences.py

@@ -188,3 +188,72 @@ def generate(self):
         # Create copy of current pulse settings for comparison later
         self._latest_pulse_settings = deepcopy(self.pulse_settings)
 
+class T2ElectronPulseSequence(PulseSequenceGenerator):
+    def __init__(self, **kwargs):
+        super().__init__(pulses=[], **kwargs)
+
+        self.pulse_settings['ESR'] = self.ESR = {
+            'stage_pulse': DCPulse('plunge'),
+            'initial_pulse': SinePulse('ESR_PiHalf'),
+            'refocusing_pulse': SinePulse('ESR_Pi'),
+            'final_pulse': SinePulse('ESR_PiHalf'),
+            'read_pulse': DCPulse('read'),
+
+            'num_refocusing_pulses': 0,
+
+            'pre_delay': None,
+            'inter_delay': None,
+            'post_delay': None,
+        }
+
+        self.pulse_settings['pre_pulses'] = self.pre_pulses = []
+        self.pulse_settings['post_pulses'] = self.post_pulses = [
+            DCPulse('empty'), DCPulse('plunge'), DCPulse('read_long', acquire=True)]
+
+    def add_ESR_pulses(self):
+        # Add stage pulse, duration will be specified later
+        stage_pulse, = self.add(self.ESR['stage_pulse'])
+
+        t = stage_pulse.t_start + self.ESR['pre_delay']
+
+        # Add initial pulse (evolve to state where T2 effects can be observed)
+        if self.ESR['initial_pulse'] is not None:
+            ESR_initial_pulse, = self.add(self.ESR['initial_pulse'])
+            ESR_initial_pulse.t_start = t
+            t += ESR_initial_pulse.duration
+
+        for k in range(self.ESR['num_refocusing_pulses']):
+            t += self.ESR['inter_delay']
+            ESR_refocusing_pulse = self.add(self.ESR['refocusing_pulse'])
+            ESR_refocusing_pulse.t_start = t
+            t += ESR_refocusing_pulse.duration
+
+        t += self.ESR['inter_delay']
+        if self.ESR['final_pulse'] is not None:
+            ESR_final_pulse, = self.add(self.ESR['final_pulse'])
+            ESR_final_pulse.t_start = t
+            t += ESR_final_pulse.duration
+
+        t += self.ESR['post_delay']
+
+        stage_pulse.duration = t - stage_pulse.t_start
+
+        # Add final read pulse
+        self.add(self.ESR['read_pulse'])
+
+    def generate(self):
+        """
+        Updates the pulse sequence
+        """
+
+        # Initialize pulse sequence
+        self.clear()
+
+        self.add(*self.pulse_settings['pre_pulses'])
+
+        self.add_ESR_pulses()
+
+        self.add(*self.pulse_settings['post_pulses'])
+
+        # Create copy of current pulse settings for comparison later
+        self._latest_pulse_settings = deepcopy(self.pulse_settings)