Algorithm improved

minipti/algorithm/configs/settings.csv

@@ -1,5 +1,5 @@
 Setting,Detector 1,Detector 2,Detector 3
-Amplitude [V],0.08322018710469607,0.10759309537538397,0.10228733246527344
-Offset [V],0.1528841372841661,0.15427101834905038,0.12571701318494843
-Output Phases [deg],0.0,112.60029893195606,179.5906249311928
-Response Phases [rad],2.0,2.0,2.0
+Amplitude [V],0.1723534098779535,0.0858740658049634,0.1012922097989765
+Offset [V],0.266612253414369,0.1409671923227199,0.1103173648211971
+Output Phases [deg],0.0,250.38368974471675,158.4992379267899
+Response Phases [rad],1.05,1.05,1.05

minipti/algorithm/interferometry.py

@@ -189,9 +189,9 @@ def calculate_offsets(self, intensity: np.ndarray | None = None):
         if intensity is None:
             intensity = self.intensities
         if intensity.shape[0] == self.dimension:
-            self.offsets =  (np.max(intensity, axis=1) - np.min(intensity, axis=1)) / 2
+            self.offsets = (np.max(intensity, axis=1) - np.min(intensity, axis=1)) / 2
         else:
-            self.offsets =  (np.max(intensity, axis=0) - np.min(intensity, axis=0)) / 2
+            self.offsets = (np.max(intensity, axis=0) - np.min(intensity, axis=0)) / 2
 
     def _error_function(self, intensity: np.ndarray) -> typing.Callable:
         intensity_scaled = (intensity - self.offsets) / self.amplitudes
@@ -269,7 +269,7 @@ def hefs(self) -> None:
         z = real + compl * 1.j
         self.phase = 2 * np.pi - np.angle(z) % (2 * np.pi)
 
-    def calculate_phase(self, guess=False) -> None:
+    def calculate_phase(self) -> None:
         """
         Calculated the interferometric phase with the defined characteristic parameters.
         """
@@ -278,7 +278,7 @@ def calculate_phase(self, guess=False) -> None:
         else:
             phase = []
             for i in range(self.intensities.size // self.dimension):
-                phase.append(self._calculate_phase(self.intensities[i], guess=guess)[0])
+                phase.append(self._calculate_phase(self.intensities[i])[0])
             self.phase = np.array(phase)
 
     def calculate_sensitivity(self) -> None:
@@ -437,10 +437,7 @@ def progress(self, progress: int) -> None:
 
     @property
     def enough_values(self) -> bool:
-        mask = np.zeros(Characterization.STEP_SIZE)
-        mask[::2] = 1
-        if np.sum(self._occured_phase * mask) >= 1 / 2 * Characterization.STEP_SIZE:
-            return True
+        return np.sum(self._occured_phase) >= Characterization.STEP_SIZE * 0.9
 
     def calculate_symmetry(self) -> None:
         sensitivity = np.empty(shape=(3, len(self.interferometer.phase)))
@@ -498,7 +495,7 @@ def add_phase(self, phase: float) -> None:
             phase (float): The occurred interferometric phase in rad.
         """
         self.time_stamp += 1
-        k = int(Characterization.STEP_SIZE / ( 2 * np.pi) * phase)
+        k = int(Characterization.STEP_SIZE / (2 * np.pi) * phase)
         self.tracking_phase.append(phase)
         self._occured_phase[k] = True 
 
@@ -521,7 +518,7 @@ def _estimate_settings(self, dc_signals: np.ndarray) -> None:
         self.interferometer.calculate_offsets(dc_signals)
         self.interferometer.calculate_amplitudes(dc_signals)
         self.interferometer.intensities = dc_signals
-        self.interferometer.calculate_phase()
+        self.interferometer.hefs()
         self._characterise_interferometer_2()
 
     def process(self, dc_signals: np.ndarray) -> Generator[int, None, None]:
@@ -555,37 +552,30 @@ def transform(linear_result) -> tuple[float, float, float]:
             return (np.arctan2(linear_result[2], linear_result[1]) % (2 * np.pi),
                     np.sqrt(linear_result[1] ** 2 + linear_result[2] ** 2),
                     linear_result[0])
-
-        x = cp.Variable(3)
         cost = []
         cosine_values = np.cos(self.interferometer.phase)
         sine_values = np.sin(self.interferometer.phase)
         desing_matrix = np.array([np.ones(cosine_values.shape), cosine_values, sine_values]).T
         for channel in range(3):
             target = self.interferometer.intensities.T[channel]
-            objective = cp.Minimize(cp.sum_squares(desing_matrix @ x - target))
-            constraints = [#x[0] <= 1.1 * self.interferometer.offsets[channel],
-                           #x[0] >= 0.9 * self.interferometer.offsets[channel],
-                           cp.SOC(x[0], x[1:3])
-                           ]
-            cp.Problem(objective, constraints).solve()
-            output_phase, amplitude, offset = transform(x.value)
+            from scipy import linalg
+            x, error, _, _ = linalg.lstsq(desing_matrix, target, check_finite=False)
+            output_phase, amplitude, offset = transform(x)
             self.interferometer.output_phases[channel] = output_phase
             self.interferometer.amplitudes[channel] = amplitude
             self.interferometer.offsets[channel] = offset
-            cost.append(desing_matrix @ x.value - target)
+            cost.append(np.linalg.norm(error))
         self.interferometer.output_phases -= self.interferometer.output_phases[0]
         self.interferometer.output_phases %= 2 * np.pi
-        return np.linalg.norm(cost)
+        return np.mean(cost)
 
     def _characterise(self) -> None:
-        # self.interferometer.hefs()
         self.interferometer.calculate_phase()
         cost = [self._characterise_interferometer_2()]
         logging.info("First guess:\n%s", str(self.interferometer))
         last_output_phases = collections.deque(maxlen=2)
         for i in trange(Characterization.MAX_ITERATIONS):
-            self.interferometer.calculate_phase(guess=False)
+            self.interferometer.calculate_phase()
             cost.append(self._characterise_interferometer_2())
             last_output_phases.append(self.interferometer.output_phases)
             logging.debug("Current estimation\n:%s", str(self.interferometer))

minipti/algorithm/pti.py

@@ -116,7 +116,7 @@ def lock_in_amplifier(self) -> None:
 
     def _calculate_decimation(self) -> None:
         self.calculate_dc()
-        if False:# self.use_common_mode_noise_reduction:
+        if True:
             self.common_mode_noise_reduction()
         self.lock_in_amplifier()
         output_data = {}