Lecture 2 How do we approach Perturbation theory with a Tracking Code equipped with a TPSA package? a.Description of our goals b.Concept of a Hierarchical theory and its advantages c.Normal Form of an Accelerator d.Computation of Approximate Invariants: Lattice Functions e.Computation of Moments: Lattice Functions again f.Tracking the Canonical Transformation A g.Phase Advance: Map in the Normal Variables

Question What was the quintessential ( 典型的な ｛てんけいてき ) message of Lecture 1?

Exercise Of Lectures 1 1.Use Complex Taylor series! 2.Use the anti-derivative 3.Use an inverse DAMAP 4.Use an inverse DAMAP and compute it with a vector field!

What is our goal? We want to be able to compute all the objects which normally enter into the analysis of a repetitive (periodic) systemWe want to be able to compute all the objects which normally enter into the analysis of a repetitive (periodic) system For example: Twiss functions, linear and nonlinear resonance driving terms, tunes, etc…For example: Twiss functions, linear and nonlinear resonance driving terms, tunes, etc… We want a theory which relies on the objects computed by the tracking code We want a theory which relies on the objects computed by the tracking code So, what can we compute? Remember 1 st lecture?So, what can we compute? Remember 1 st lecture? only

So what is a Tracking Code? A tracking code by definition is an algorithm to compute the ray, floating points numbers, for example, x,x’,y,y’,t,  E. We have seen in Lecture 1, that the introduction of an overloaded TPSA package allows the extension of algorithm from floating to Truncated Power Series. So we write our own toy Tracking code for this lecture! Therefore, we decree ( 命令をする ), that a tracking code is an algorithm to compute rays and Taylor series expansions of that ray in variables chosen by the user/programmer.

Goal: to understand the output of a Tracking Code We will look at a system which is stable around some closed orbit. A system which is Hamiltonian (canonical) At first, we use a system in one degree of freedom, i.e. phase space is (x,p), in our example code. Time for our weekly lesson of English: Canonical

English Lesson! Canonical : 教会法上に従った ( したがった） Canon Law: 教会法律 Canonical theory : 正準理論 Dogma: 教会の教義 Hierarchical Abstraction: 階層抽象化｛かいそう ちゅうしょうか｝ My lectures will be canonical in the Church sense as well! I will describe a hierarchical approach. Hierarchical methods are well suited for computer implementations because modern computers are highly hierarchical in structure. In addition, in a hierarchical system full understanding is not necessary. One can stop at anywhere in the hierarchy without comprising the whole structure. For example, one may know how to use Microsoft Word without knowledge of programming or computer architecture!

Religious or Canonical Hierarchical Structure Dogma Derived Laws Derived Mathematical Properties of the Laws Mathematical Tools Derived from the Laws Computer Implementations Newton’s Laws: not subject to discussion at all! Least Action, Lagrangian, Hamiltonian Symplectic, determinant=1, Liouville, Invariants, etc.. Generating Functions, Lie Transformations, Canonical Transformations, etc… Canonical Integrators, TPSA, DA, TPSA vector Fields, TPSA Poisson Brackets, etc… User Manual Read code manual, if do not understand, it is OK! Just run the code! Level 0 Level 1 Level 2 Level 3 Level 4 Level 5

My own library (FPP) is Hierarchical

Our Starting Point Tracking Rays using the code Producing a Taylor map, here linear, using the code equipped with TPSA. M 11 M 12 M 21 M 22

Theory: a Level 2 Religious Result For a stable accelerator there exists an infinite number Canonical Transformation A such that: M s =A s ◦R◦A s -1 This result is exact for linear map and formal for nonlinear maps with irrational tunes. R is called the Normal Form of a stable accelerator. It represents the fact that the accelerator produces pseudo-harmonic oscillations around its orbit. Formal = Only True in a TPSA sense around the design orbit. TPSA sense around the design orbit = DA sense.

How do we do this ? My_map = Type(damap) My_map Type(normalform) My_normal My_normal = My_map My_normal contains the normal form and the transformation A s in My_normal%a_t A s -1 my_a_inv = (My_normal%a_t)**(-1) **(-1) : Level 4 mystery My_normal = My_map Is a Level 3 religious mystery Code + TPSA Code + TPSA + Analysis Library my_a_inv =

Example Program available on WEB

Invariant ε s Using A s we can easily compute the invariant. Obviously x 2 +p 2 =(x 2 +p 2 ) ◦ R But, using the normal form M s =A s ◦R◦A s -1 x 2 +p 2 =(x 2 +p 2 ) ◦A s -1 ◦M s ◦A s → (x 2 +p 2 ) ◦A s -1 ◦M s = (x 2 +p 2 ) ◦A s -1 → ε s = (x 2 +p 2 ) ◦A s -1 is invariant of M s

ε= (x 2 +p 2 ) ◦A -1 = { {A } 2 + {A } 2 } x 2 + { {A } 2 + {A } 2 } p { A A A A } xp Results for Linear Maps α γβ

Code In FPP for ε s This is the algorithm to compute the Invariant ! Here we compute the invariant in the space of circles ! It is obviously a circle! my_invariant=(1.d0.mono.1)**2+(1.d0.mono.2)**2 ! Now we act with A**(-1) to compute the invariant in the normal space around the closed orbit my_invariant=my_invariant*my_a_inv 注意 : Functions transform in an inverse manner from the rays! my_invariant is of type TAYLOR and My_a_inv is of type DAMAP

Notice that the same results can be derived using This comes from the Det(A)=1 or more generally the symplectic condition. Lattice Functions as Averages of Quadratic Moments For example averaged for a single ray over many turns. Such averages can only depend on the initial conditions through the value of the invariant, and the coefficients of the invariant (i.e. (  ) here)

Tracking the Map A: B s =M 0s ◦A 0 (Theory) Suppose we have M 0 =A 0 ◦R◦A 0 -1 From the tracking code with TPSA, we can also get M 0s, the map from position 0 to position s. Let us obtain a map which diagonalize the one-turn map M s at s. M s =M 0s ◦M 0 ◦M 0s -1 → M s =M 0s ◦A 0 ◦R◦A 0 -1 ◦M 0s -1 If B s =M 0s ◦A 0 then M s =B s ◦R ◦B s -1 B s =M 0s ◦A 0 is a fundamental result of the full nonlinear Normal form theory: the map A 0 can be tracked.

!This is the algorithm to compute the lattice function ! Here we initialize the ray = Closed Orbit + A my_y(1)=my_fix(1)+ my_normal%a_t%v(1) my_y(2)=my_fix(2)+ my_normal%a_t%v(2) my_y(3)=my_fix(3) ! Now let us do loop over lattice starting at position = pos do k = pos, pos+lattice%n-1 ! Beta function is computed here in front of magnet “k” Beta = (my_y(1).sub.'1')**2+(my_y(1).sub.'01')**2 gamma = (my_y(2).sub.'1')**2+(my_y(2).sub.'01')**2 alpha = -((my_y(2).sub.'1')*(my_y(1).sub.'1')+(my_y(2).sub.'01')*(my_y(1).sub.'01')) call track(my_y,lattice,k,k+1) ! B k+1 = M k,k+1 B k end do Tracking the Map A: B s =M 0s ◦A 0 (FPP Coding)

Phase Advance: Difference between A s and B s We know that a stable accelerator map M 0 can be linearly exactly and nonlinearly formally put into a normal form i.e. M 0 = A 0 ◦R◦A 0 -1 Of course we can also do this at some position s: M s = A s ◦R◦A s -1 Finally we can also use the map from 0 to s and achieve the same result: M s = B s ◦R◦B s -1 where B s =M 0s ◦A 0 The difference between A s and B s is a rotation called the phase advance.

Code Example: Phase Advance = Map in Normal Coordinates

Theory deduced from pictures From above picture: M 12 = A 2 ◦R 12 ◦A 1 -1 thus A 2 -1 ◦M 12 ◦A 1 = R 12 A 2 -1 ◦ B 2 = R 12 Important Point: A s is really a function of the one-turn map at M s and nothing else. A s = F[M s ] Usual in one degree of freedom, people follow the Courant-Snyder recipe. So A s = F C-S [M s ] Notice that F is periodic by construction: F[M s+C ] = F[M s ] But, B s+C =M s ◦ B s is not !

Code for Phase Advance my_y(1)=my_fix(1)+ (1.d0.mono.1) my_y(2)=my_fix(2)+ (1.d0.mono.2) my_y(3)=my_fix(3) my_map1=my_map ! We track one turn with our favourite code my_a1=my_normal%a_t dphase=0.d0 k=pos4-1 if(pos4==pos) k=k+lattice%n do i=pos,k call track(my_y,lattice,i,i+1) my_map12%v(1)=my_y(1); my_map12%v(2)=my_y(2); my_map2=my_map12*my_map1*my_map12**(-1) my_normal2=my_map2 my_a2=my_normal2%a_t my_r12=my_a2**(-1)*my_map12*my_a1 onelie12=my_r12 ! This is a single exponent Vector Field Representation h12=onelie12%vector ! H12 is a phasor representation dphase=(h12%sin%v(2).k.2)/2.d0/pi +dphase my_a1=my_a2 my_y(1)=(my_y(1).sub.'0')+(1.d0.mono.1) my_y(2)=(my_y(2).sub.'0')+(1.d0.mono.2) my_map1=my_map2 enddo M 2 =M 12 ◦M 1 ◦M A s = F[M s ] A 2 -1 ◦M 12 ◦A 1 = R 12 This code contains a two “vector” field objects. It is time to describe in detail what these are and what purpose they serve.