The method of setUsePhaseAtEntrance(usePhaseAtEntrance = True/False) was added to RF_Cavity class. It defines the place from where the cavity phase is defined. True means at the entrance of the 1st RF gap of the cavity, and False means the center of 1st gap. This parameter is used only for Axis Field RF gaps.

Author: shishlo

py/orbit/py_linac/lattice/LinacAccLatticeLib.py

@@ -375,6 +375,14 @@ def __init__(self, name="none"):
         self.addParam("designArrivalTime", 0.0)
         self.addParam("isDesignSetUp", False)
         self.addParam("pos", 0.0)
+        #---- This parameter is only for RF gap types with 
+        #---- the continuous RF fields on the axis of the cavity.
+        #---- If usePhaseAtEntrance = False we will use the phase at the center
+        #---- of RF gap as for a standard cavity representations as a set 
+        #---- of zero-length RF gaps.
+        #---- If usePhaseAtEntrance = False we use the phase at the entrance
+        #---- of the cavity.
+        self.usePhaseAtEntrance = False
 
     def setDesignSetUp(self, designOnOf):
         """Sets the design set up information (True,False)."""
@@ -482,6 +490,26 @@ def getAvgGapPhase(self):
     def getAvgGapPhaseDeg(self):
         """Returns average phase in degrees for all RF gaps in the cavity"""
         return self.getAvgGapPhase() * 180.0 / math.pi
+        
+    def setUsePhaseAtEntrance(self,usePhaseAtEntrance):
+        """
+        This parameter is only for RF gap types with the continuous RF fields 
+        on the axis of the cavity.
+        If usePhaseAtEntrance = False we will use the phase at the center
+        of 1 st RF gap as for a standard cavity representations as a set 
+        of zero-length RF gaps.
+        If usePhaseAtEntrance = False we use the phase at the entrance
+        of the cavity.
+        By default it is False. Switching to True will change cavity phase and
+        all longitudinal dynamics calculations. You should calculate and set
+        of the cavity phase before the bunch tracking. And, of course, you 
+        should start with the trackDesignBunch(...) lattice method. 
+        """
+        self.usePhaseAtEntrance = usePhaseAtEntrance
+        
+    def getUsePhaseAtEntrance(self):
+        """ Returns the usePhaseAtEntrance parameter of the cavity """
+        return self.usePhaseAtEntrance
 
     def removeAllGapNodes(self):
         """Remove all rf gaps from this cavity."""

py/orbit/py_linac/lattice/LinacFieldOverlappingNodes.py

@@ -21,6 +21,8 @@
 # from linac import the RF gap classes
 from orbit.core.linac import RfGapThreePointTTF, RfGapThreePointTTF_slow
 
+# import from orbit c++ utilities
+from orbit.core.orbit_utils import Function
 
 class AxisField_and_Quad_RF_Gap(AbstractRF_Gap):
     """
@@ -61,8 +63,8 @@ def __init__(self, axis_field_rf_gap):
         self.z_step = 0.01
         self.z_min = 0.0
         self.z_max = 0.0
-        # ---- gap_phase_vs_z_arr keeps [pos,phase] pairs after the tracking
-        self.gap_phase_vs_z_arr = []
+        # ---- gap_pos_phase_func keeps phase=function(pos) after the tracking
+        self.gap_pos_phase_func = Function()
         # ---- The position of the particle during the run.
         # ---- It is used for the path length accounting.
         self.part_pos = 0.0
@@ -300,16 +302,18 @@ def track(self, paramsDict):
         designArrivalTime = rfCavity.getDesignArrivalTime()
         phase_shift = rfCavity.getPhase() - rfCavity.getDesignPhase()
         phase = rfCavity.getFirstGapEtnrancePhase() + phase_shift
+        usePhaseAtEntrance = rfCavity.getUsePhaseAtEntrance()
+        if(usePhaseAtEntrance):
+            phase = rfCavity.getPhase()        
         # ----------------------------------------
         phase = math.fmod(
             frequency * (arrival_time - designArrivalTime) * 2.0 * math.pi + phase,
             2.0 * math.pi,
         )
         if index == 0:
             self.part_pos = self.z_min
-            self.gap_phase_vs_z_arr = [
-                [self.part_pos, phase],
-            ]
+            self.gap_pos_phase_func.clean()
+            self.gap_pos_phase_func.add(self.part_pos, phase)
         zm = self.part_pos
         z0 = zm + part_length / 2
         zp = z0 + part_length / 2
@@ -338,7 +342,7 @@ def track(self, paramsDict):
         # call rf gap model to track the bunch
         time_middle_gap = syncPart.time() - arrival_time
         delta_phase = math.fmod(2 * math.pi * time_middle_gap * frequency, 2.0 * math.pi)
-        self.gap_phase_vs_z_arr.append([self.part_pos, phase + delta_phase])
+        self.gap_pos_phase_func.add(self.part_pos, phase + delta_phase)
         # ---- this part is the debugging ---START---
         # eKin_out = syncPart.kinEnergy()
         # s  = "debug pos[mm]= %7.2f "%(self.part_pos*1000.)
@@ -377,7 +381,7 @@ def track(self, paramsDict):
         self.part_pos += part_length / 2
         time_middle_gap = syncPart.time() - arrival_time
         delta_phase = math.fmod(2 * math.pi * time_middle_gap * frequency, 2.0 * math.pi)
-        self.gap_phase_vs_z_arr.append([self.part_pos, phase + delta_phase])
+        self.gap_pos_phase_func.add(self.part_pos, phase + delta_phase)
         # ---- this part is the debugging ---START---
         # eKin_out = syncPart.kinEnergy()
         # s  = "debug pos[mm]= %7.2f "%(self.part_pos*1000.)
@@ -388,29 +392,35 @@ def track(self, paramsDict):
         # ---- this part is the debugging ---STOP---
         # ---- Calculate the phase at the center
         if index == (nParts - 1):
-            pos_old = self.gap_phase_vs_z_arr[0][0]
-            phase_gap = self.gap_phase_vs_z_arr[0][1]
-            ind_min = -1
-            for ind in range(1, len(self.gap_phase_vs_z_arr)):
-                [pos, phase_gap] = self.gap_phase_vs_z_arr[ind]
-                if math.fabs(pos) >= math.fabs(pos_old):
-                    ind_min = ind - 1
-                    phase_gap = self.gap_phase_vs_z_arr[ind_min][1]
-                    phase_gap = phaseNearTargetPhase(phase_gap, 0.0)
-                    self.gap_phase_vs_z_arr[ind_min][1] = phase_gap
-                    break
-                pos_old = pos
-            self.setGapPhase(phase_gap)
-            # ---- wrap all gap part's phases around the central one
-            if ind_min > 0:
-                for ind in range(ind_min - 1, -1, -1):
-                    [pos, phase_gap] = self.gap_phase_vs_z_arr[ind]
-                    [pos, phase_gap1] = self.gap_phase_vs_z_arr[ind + 1]
-                    self.gap_phase_vs_z_arr[ind][1] = phaseNearTargetPhase(phase_gap, phase_gap1)
-                for ind in range(ind_min + 1, len(self.gap_phase_vs_z_arr)):
-                    [pos, phase_gap] = self.gap_phase_vs_z_arr[ind]
-                    [pos, phase_gap1] = self.gap_phase_vs_z_arr[ind - 1]
-                    self.gap_phase_vs_z_arr[ind][1] = phaseNearTargetPhase(phase_gap, phase_gap1)
+            self._phase_gap_func_analysis()
+
+    def _phase_gap_func_analysis(self):
+        """
+        Performs analysis of the RF gap function phase vs. postion
+        and calculates the accelerating phase at the center of the gap.
+        """
+        n_pos_points = self.gap_pos_phase_func.getSize()
+        phase_gap = 0.
+        if(n_pos_points != 0):
+            phase_gap_old = self.gap_pos_phase_func.y(0)
+            for pos_ind in range(n_pos_points):
+                phase_gap = self.gap_pos_phase_func.y(pos_ind)
+                phase_gap = phaseNearTargetPhase(phase_gap,phase_gap_old)
+                self.gap_pos_phase_func.updatePoint(pos_ind,phase_gap)
+                phase_gap_old = phase_gap
+            phase_gap = self.gap_pos_phase_func.getY(0.)
+            phase_gap_center = phaseNearTargetPhase(phase_gap,0.)
+            phase_gap_shift = phase_gap - phase_gap_center
+            for pos_ind in range(n_pos_points):
+                phase_gap = self.gap_pos_phase_func.y(pos_ind)
+                self.gap_pos_phase_func.updatePoint(pos_ind,phase_gap - phase_gap_shift)
+        self.setGapPhase(phase_gap_center)
+
+    def getPhaseVsPositionFuncion(self):
+        """
+        Retuns the RF gap function phase vs. postion.
+        """
+        return self.gap_pos_phase_func
 
     def trackDesign(self, paramsDict):
         """
@@ -433,10 +443,14 @@ def trackDesign(self, paramsDict):
         arrival_time = syncPart.time()
         frequency = rfCavity.getFrequency()
         phase = rfCavity.getFirstGapEtnrancePhase()
+        usePhaseAtEntrance = rfCavity.getUsePhaseAtEntrance()
+        if(usePhaseAtEntrance):
+            phase = rfCavity.getPhase()
         # ---- calculate the entance phase
         if self.isFirstRFGap() and index == 0:
             rfCavity.setDesignArrivalTime(arrival_time)
-            phase = self.axis_field_rf_gap.calculate_first_part_phase(bunch)
+            if(not usePhaseAtEntrance):           
+                phase = self.axis_field_rf_gap.calculate_first_part_phase(bunch)
             rfCavity.setFirstGapEtnrancePhase(phase)
             rfCavity.setFirstGapEtnranceDesignPhase(phase)
             rfCavity.setDesignSetUp(True)
@@ -453,9 +467,8 @@ def trackDesign(self, paramsDict):
         # print "debug design name=",self.getName()," arr_time=",arrival_time," phase=",phase*180./math.pi," E0TL=",E0TL*1.0e+3," freq=",frequency
         if index == 0:
             self.part_pos = self.z_min
-            self.gap_phase_vs_z_arr = [
-                [self.part_pos, phase],
-            ]
+            self.gap_pos_phase_func.clean()
+            self.gap_pos_phase_func.add(self.part_pos, phase)
         zm = self.part_pos
         z0 = zm + part_length / 2
         zp = z0 + part_length / 2
@@ -468,7 +481,7 @@ def trackDesign(self, paramsDict):
         # call rf gap model to track the bunch
         time_middle_gap = syncPart.time() - arrival_time
         delta_phase = math.fmod(2 * math.pi * time_middle_gap * frequency, 2.0 * math.pi)
-        self.gap_phase_vs_z_arr.append([self.part_pos, phase + delta_phase])
+        self.gap_pos_phase_func.add(self.part_pos, phase + delta_phase)
         # ---- this part is the debugging ---START---
         # eKin_out = syncPart.kinEnergy()
         # s  = "debug pos[mm]= %7.2f "%(self.part_pos*1000.)
@@ -491,7 +504,7 @@ def trackDesign(self, paramsDict):
         self.part_pos += part_length / 2
         time_middle_gap = syncPart.time() - arrival_time
         delta_phase = math.fmod(2 * math.pi * time_middle_gap * frequency, 2.0 * math.pi)
-        self.gap_phase_vs_z_arr.append([self.part_pos, phase + delta_phase])
+        self.gap_pos_phase_func.add(self.part_pos, phase + delta_phase)
         # ---- this part is the debugging ---START---
         # eKin_out = syncPart.kinEnergy()
         # s  = "debug pos[mm]= %7.2f "%(self.part_pos*1000.)
@@ -502,29 +515,7 @@ def trackDesign(self, paramsDict):
         # ---- this part is the debugging ---STOP---
         # ---- Calculate the phase at the center
         if index == (nParts - 1):
-            pos_old = self.gap_phase_vs_z_arr[0][0]
-            phase_gap = self.gap_phase_vs_z_arr[0][1]
-            ind_min = -1
-            for ind in range(1, len(self.gap_phase_vs_z_arr)):
-                [pos, phase_gap] = self.gap_phase_vs_z_arr[ind]
-                if math.fabs(pos) >= math.fabs(pos_old):
-                    ind_min = ind - 1
-                    phase_gap = self.gap_phase_vs_z_arr[ind_min][1]
-                    phase_gap = phaseNearTargetPhase(phase_gap, 0.0)
-                    self.gap_phase_vs_z_arr[ind_min][1] = phase_gap
-                    break
-                pos_old = pos
-            self.setGapPhase(phase_gap)
-            # ---- wrap all gap part's phases around the central one
-            if ind_min > 0:
-                for ind in range(ind_min - 1, -1, -1):
-                    [pos, phase_gap] = self.gap_phase_vs_z_arr[ind]
-                    [pos, phase_gap1] = self.gap_phase_vs_z_arr[ind + 1]
-                    self.gap_phase_vs_z_arr[ind][1] = phaseNearTargetPhase(phase_gap, phase_gap1)
-                for ind in range(ind_min + 1, len(self.gap_phase_vs_z_arr)):
-                    [pos, phase_gap] = self.gap_phase_vs_z_arr[ind]
-                    [pos, phase_gap1] = self.gap_phase_vs_z_arr[ind - 1]
-                    self.gap_phase_vs_z_arr[ind][1] = phaseNearTargetPhase(phase_gap, phase_gap1)
+            self._phase_gap_func_analysis()
 
 
 class OverlappingQuadsNode(BaseLinacNode):