diff --git a/src/mad_elem.h b/src/mad_elem.h
index eb44eeb16..fa2192937 100644
--- a/src/mad_elem.h
+++ b/src/mad_elem.h
@@ -3,6 +3,7 @@
 
 // types
 enum en_apertype{circle, ellipse, rectangle, lhcscreen, rectcircle, rectellipse, racetrack, octagon, custom};
+enum track_enums{non_existing, enum_other_bv, enum_lrad, enum_noise, enum_angle, enum_time_var};
 struct node;
 struct name_list;
 struct command;
@@ -24,6 +25,8 @@ struct element  /* each element is unique */
                                 /* *this for base_type elements (rbend etc.) */
 
   struct aperture* aper;
+  double *tt_attrib;
+  struct multipole* multip;
 };
 
 struct aperture
@@ -35,6 +38,13 @@ struct aperture
   double *ylist;
   int length;
 };
+struct multipole
+{
+  int nn;
+  int ns;
+  double *knl;
+  double *ksl;
+};
 
 struct el_list /* contains list of element pointers sorted by name */
 {
diff --git a/src/mad_extrn_f.h b/src/mad_extrn_f.h
index 7dfde8e9c..bb9d6d397 100644
--- a/src/mad_extrn_f.h
+++ b/src/mad_extrn_f.h
@@ -84,7 +84,13 @@
 #define inside_userdefined_geometry inside_userdefined_geometry_
 #define node_aperture_vector node_aperture_vector_
 #define node_aperture_offset node_aperture_offset_
+#define node_obs_point node_obs_point_
 
+#define alloc_tt_attrib alloc_tt_attrib_
+#define set_tt_attrib set_tt_attrib_
+#define get_tt_attrib get_tt_attrib_
+#define set_tt_multipoles set_tt_multipoles_
+#define get_tt_multipoles get_tt_multipoles_
 // from mad_option.c
 #define get_option get_option_ // *
 #define set_option set_option_
@@ -121,6 +127,7 @@
 
 // from mad_seq.c
 #define restart_sequ restart_sequ_
+#define get_nnodes get_nnodes_
 
 // from mad_table.c
 // warning:augment_counts is provided by madx_ptc_knobs.f90
diff --git a/src/mad_node.c b/src/mad_node.c
index 06be85698..18670e5e3 100644
--- a/src/mad_node.c
+++ b/src/mad_node.c
@@ -327,6 +327,56 @@ node_value(const char* par)
   else value =  element_value(current_node, lpar);
   return value;
 }
+double node_obs_point(void){
+  return current_node->obs_point;
+}
+
+void set_tt_multipoles(int *maxmul){
+  int tmp_n, tmp_s;
+  double tmp_nv[*maxmul] ;
+  double tmp_sv[*maxmul] ;
+  current_node->p_elem->multip = mycalloc("alloc mult struct", 1, sizeof (*current_node->p_elem->multip));
+  current_node->p_elem->multip->knl = mycalloc("alloc multip normal", *maxmul, sizeof (*current_node->p_elem->multip->knl));
+  current_node->p_elem->multip->ksl = mycalloc("alloc multip skew"  , *maxmul, sizeof (*current_node->p_elem->multip->ksl));
+
+  get_node_vector("knl", &tmp_n, tmp_nv);
+  get_node_vector("ksl", &tmp_s, tmp_sv);
+  current_node->p_elem->multip->nn = tmp_n;
+  current_node->p_elem->multip->ns = tmp_s;
+  
+  for(int i=0;i<tmp_n;i++){
+    current_node->p_elem->multip->knl[i] = tmp_nv[i];
+  }
+  for(int i=0;i<tmp_s;i++){
+    current_node->p_elem->multip->ksl[i] = tmp_sv[i];
+  }
+
+
+}
+
+void get_tt_multipoles(int *nn, double *knl, int *ns, double *ksl){
+    nn[0]=current_node->p_elem->multip->nn;
+    ns[0]=current_node->p_elem->multip->ns;
+    for(int i=0;i<*nn;i++){
+      knl[i] = current_node->p_elem->multip->knl[i];
+    }
+    for(int i=0;i<*ns;i++){
+      ksl[i] = current_node->p_elem->multip->ksl[i];
+    }
+
+
+}
+void alloc_tt_attrib(int *length){
+  current_node->p_elem->tt_attrib = mycalloc("tmp_array_tt", (*length+1), sizeof (*current_node->p_elem->tt_attrib));
+}
+
+void set_tt_attrib(int *index, double *value){
+  current_node->p_elem->tt_attrib[*index] = *value;
+}
+
+double get_tt_attrib(int *index){
+  return current_node->p_elem->tt_attrib[*index];
+}
 
 void
 link_in_front(struct node* new, struct node* el)
diff --git a/src/mad_node.h b/src/mad_node.h
index 38e6c3783..9e034a3e7 100644
--- a/src/mad_node.h
+++ b/src/mad_node.h
@@ -108,6 +108,12 @@ int     inside_userdefined_geometry(double *x, double *y);
 double  get_length_(void);
 void    node_aperture_vector(double * vec);
 void    node_aperture_offset(double * vec);
+void alloc_tt_attrib(int *length);
+void set_tt_attrib(int *index, double *value);
+double get_tt_attrib(int *index);
+void set_tt_multipoles(int *maxmul);
+void get_tt_multipoles(int *nn, double *knl, int *ns, double *ksl);
+double node_obs_point(void);
 
 #endif // MAD_NODE_H
 
diff --git a/src/mad_seq.c b/src/mad_seq.c
index 25130e301..f5fab6c49 100644
--- a/src/mad_seq.c
+++ b/src/mad_seq.c
@@ -2083,6 +2083,10 @@ expand_curr_sequ(int flag)
   }
 }
 
+int get_nnodes(void){
+  return current_sequ->n_nodes;
+} 
+
 void
 reset_errors(struct sequence* sequ)
   /* zeros the sel_err node flag for all nodes of an expanded sequence */
diff --git a/src/mad_seq.h b/src/mad_seq.h
index 46119aa31..49a3d4e9f 100644
--- a/src/mad_seq.h
+++ b/src/mad_seq.h
@@ -92,6 +92,7 @@ int     set_enable(const char* type, struct in_cmd*);
 void    set_sequence(char* name);
 int     set_cont_sequence(void);
 int     sequ_check_valid_twiss(struct sequence*);
+int     get_nnodes(void);
 
 #endif // MAD_SEQ_H
 
diff --git a/src/mad_track.c b/src/mad_track.c
index 1e8e6646b..5b1cfe578 100644
--- a/src/mad_track.c
+++ b/src/mad_track.c
@@ -94,9 +94,11 @@ track_run(struct in_cmd* cmd)
   buf4    = mymalloc_atomic(rout_name, 36      * sizeof *buf4);
   buf6    = mymalloc_atomic(rout_name, nnode   * sizeof *buf6);
 
+
   // run track rountine
   trrun_(&flag, &turns,orbit0, oneturnmat, ibuf1, ibuf2, buf1, buf2,
-         buf_dxt, buf_dyt, buf3, buf4, &buf5, &e_flag, ibuf3, buf6);
+         buf_dxt, buf_dyt, buf3, buf4, &buf5, &e_flag, ibuf3, 
+         buf6);
 
   // summary
   t = find_table("tracksumm");
diff --git a/src/trrun.f90 b/src/trrun.f90
index 8fdf6c5f2..a55d6aafb 100644
--- a/src/trrun.f90
+++ b/src/trrun.f90
@@ -1,5 +1,6 @@
 subroutine trrun(switch, turns, orbit0, rt, part_id, last_turn, last_pos, &
-                 z, dxt, dyt, last_orbit, eigen, coords, e_flag, code_buf, l_buf)
+                 z, dxt, dyt, last_orbit, eigen, coords, e_flag, code_buf, & 
+                 l_buf)
   use twtrrfi
   use bbfi
   use time_varfi
@@ -11,6 +12,7 @@ subroutine trrun(switch, turns, orbit0, rt, part_id, last_turn, last_pos, &
   use matrices, only : EYE
   use math_constfi, only : zero, one, two
   use code_constfi
+  use track_enums
   implicit none
   !----------------------------------------------------------------------*
   ! Purpose:                                                             *
@@ -44,9 +46,10 @@ subroutine trrun(switch, turns, orbit0, rt, part_id, last_turn, last_pos, &
   integer :: part_id(*), last_turn(*), code_buf(*)
   double precision :: last_pos(*), z(6,*), dxt(*), dyt(*)
   double precision :: last_orbit(6,*),  l_buf(*)
-
+  double precision :: theta
+  double precision, dimension (:), allocatable :: theta_buf   
   logical :: onepass, onetable, last_out, info, aperflag, doupdate, debug
-  logical :: run=.false.,dynap=.false.
+  logical :: run=.false.,dynap=.false., thin_foc
   logical, save :: first=.true.
   logical :: bb_sxy_update, virgin_state, emittance_update
   logical :: checkpnt_restart, fast_error_func, exit_loss_turn
@@ -83,13 +86,14 @@ subroutine trrun(switch, turns, orbit0, rt, part_id, last_turn, last_pos, &
   double precision  :: Summ_t_square    ! local for rms value
 !-------------------------------------------------------------------
 
-  integer, external :: restart_sequ, advance_node, get_option, node_al_errors
-  double precision, external :: node_value, get_variable, get_value	
+  integer, external :: restart_sequ, advance_node, get_option, node_al_errors, get_nnodes
+  double precision, external :: node_value, get_variable, get_value, node_obs_point
+  external :: set_tt_attrib, alloc_tt_attrib, set_tt_multipoles, get_tt_multipoles
 
   ! 2015-Jul-08  19:16:53  ghislain: make code more readable
   run   = switch .eq. 1
   dynap = switch .eq. 2
-
+  allocate ( theta_buf(get_nnodes()) )
   !--- Initialize
   deltap = get_value('probe ','deltap ')
   betas  = get_value('probe ','beta ')
@@ -109,7 +113,9 @@ subroutine trrun(switch, turns, orbit0, rt, part_id, last_turn, last_pos, &
   quantum = get_option('quantum ') .ne. 0
 
   debug = get_option('debug ') .ne. 0
+  thin_foc = get_option('thin_foc ').eq.1
 
+  call init_elements()
   !-------added by Yipeng SUN 01-12-2008--------------
   if (deltap .eq. zero) then
      onepass = get_option('onepass ') .ne. 0
@@ -457,6 +463,8 @@ subroutine trrun(switch, turns, orbit0, rt, part_id, last_turn, last_pos, &
         !-----------------------------------------------------------------
      endif
 
+
+
      do !--- loop over nodes
 
         bbd_pos = j
@@ -467,10 +475,14 @@ subroutine trrun(switch, turns, orbit0, rt, part_id, last_turn, last_pos, &
            if (code .eq. code_placeholder) code = code_instrument
 
            el = node_value('l ')
-		   
+           theta = node_value('tilt ')
+           theta_buf(nlm+1) = theta
            code_buf(nlm+1) = code
            l_buf(nlm+1) = el
-           call element_name(el_name,len(el_name))
+           !param(nlm+1, enum_bvk) = 
+           !param(nlm+1, enum_lrad) -= 
+           !param(nlm+1, enum_bvk)
+           !param(nlm+1, enum_bvk)
 
            if ((code.eq.code_sextupole .or. &
               code.eq.code_octupole .or. &
@@ -478,6 +490,7 @@ subroutine trrun(switch, turns, orbit0, rt, part_id, last_turn, last_pos, &
               code.eq.code_rfcavity .or. &
               code.eq.code_crabcavity) .and. el.ne.zero) then
               !if (.not. (is_drift() .or. is_thin() .or. is_quad() .or. is_dipole() .or. is_matrix()) ) then
+              call element_name(el_name,len(el_name))
               print *," "
               print *,el_name, "code: ",code," el: ",el,"   THICK ELEMENT FOUND"
               print *," "
@@ -494,9 +507,10 @@ subroutine trrun(switch, turns, orbit0, rt, part_id, last_turn, last_pos, &
         else
            el = l_buf(nlm+1)
            code = code_buf(nlm+1)
+           theta = theta_buf(nlm+1)
         endif
 
-        if (run) nobs = node_value('obs_point ')
+        if (run) nobs = node_obs_point()
 
         !--------  Misalignment at beginning of element (from twissfs.f)
         if (code .ne. code_drift)  then
@@ -512,7 +526,7 @@ subroutine trrun(switch, turns, orbit0, rt, part_id, last_turn, last_pos, &
         
         !-------- Track through element  // suppress dxt 13.12.04
         call ttmap(switch, code, el, z, jmax, dxt, dyt, sum, tot_turn+turn, part_id, &
-             last_turn, last_pos, last_orbit, aperflag, maxaper, al_errors, onepass,debug)
+             last_turn, last_pos, last_orbit, aperflag, maxaper, al_errors, onepass, debug, theta, thin_foc)
 
         !-------- Space Charge update
 !frs on 04.06.2016 - fixing
@@ -696,8 +710,51 @@ subroutine trrun(switch, turns, orbit0, rt, part_id, last_turn, last_pos, &
 100 call fort_fail('TRACK: Fatal ', 'checkpoint_restart file corrupted')
 end subroutine trrun
 
+subroutine init_elements
+  use track_enums
+  use trackfi
+  use twtrrfi
+  use code_constfi
+  implicit none
+  integer:: j, code
+  integer, external :: restart_sequ, advance_node
+  double precision, external :: node_value
+ 
+  
+  j = restart_sequ()
+  do !---- loop over nodes
+    code    = node_value('mad8_type ')
+  !        if (code .eq. code_tkicker)     code = code_kicker
+    if(code .eq. code_multipole) then
+     call alloc_tt_attrib(total_enums)
+     call set_tt_attrib(enum_other_bv, node_value('other_bv '))
+     call set_tt_attrib(enum_lrad, node_value('lrad '))
+     call set_tt_attrib(enum_noise, node_value('noise '))
+     call set_tt_attrib(enum_angle, node_value('angle '))
+     call set_tt_attrib(enum_time_var, node_value('time_var '))
+     call set_tt_multipoles(maxmul)
+    endif
+
+    if(code.eq.code_hkicker .or. code.eq.code_vkicker .or. &
+      code.eq.code_kicker .or.  code.eq.code_tkicker) then
+      call alloc_tt_attrib(total_enums)
+      call set_tt_attrib(enum_other_bv, node_value('other_bv '))
+      call set_tt_attrib(enum_sinkick, node_value('sinkick '))
+      call set_tt_attrib(enum_kick, node_value('kick '))
+      call set_tt_attrib(enum_chkick, node_value('chkick '))
+      call set_tt_attrib(enum_cvkick, node_value('chkick '))
+      call set_tt_attrib(enum_hkick, node_value('hkick '))
+      call set_tt_attrib(enum_vkick, node_value('vkick '))
+    endif 
+    
+    if (advance_node() .eq. 0)  exit
+
+  end do !--- end of loop over nodes to set upt things
+
+end subroutine init_elements
+
 subroutine ttmap(switch,code,el,track,ktrack,dxt,dyt,sum,turn,part_id, &
-     last_turn,last_pos,last_orbit,aperflag,maxaper,al_errors,onepass, debug)
+     last_turn,last_pos,last_orbit,aperflag,maxaper,al_errors,onepass, debug, theta, thin_foc)
   use twtrrfi
   use twiss0fi
   use name_lenfi
@@ -725,7 +782,7 @@ subroutine ttmap(switch,code,el,track,ktrack,dxt,dyt,sum,turn,part_id, &
   logical :: aperflag, onepass, lost_global
 
   logical :: fmap, debug
-  logical :: run=.false., dynap=.false.
+  logical :: run=.false., dynap=.false., thin_foc
   integer :: i, nn, jtrk, apint
   double precision :: ct, tmp, st, theta
   double precision :: ap1, ap2, ap3, ap4, aperture(maxnaper)
@@ -742,14 +799,8 @@ subroutine ttmap(switch,code,el,track,ktrack,dxt,dyt,sum,turn,part_id, &
   run   = switch .eq. 1
   dynap = switch .eq. 2
 
-  !debug = get_option('debug ') .ne. 0
-
   fmap=.false.
-  EK(:6) = zero
-  CRAPORB(:6) = zero
-  RE(:6,:6) = zero
-  TE(:6,:6,:6) = zero
-
+ 
   !---- Drift space; no rotation or aperture check, go straight to tracking and return
   if (code .eq. code_drift) then
      call ttdrf(el,track,ktrack)
@@ -758,7 +809,7 @@ subroutine ttmap(switch,code,el,track,ktrack,dxt,dyt,sum,turn,part_id, &
   endif
 
   !---- Rotate trajectory before entry
-  theta = node_value('tilt ')
+
   if (theta .ne. zero)  then
      st = sin(theta)
      ct = cos(theta)
@@ -778,24 +829,24 @@ subroutine ttmap(switch,code,el,track,ktrack,dxt,dyt,sum,turn,part_id, &
     
      apint=node_apertype()
      if(apint .eq. ap_notset) then
-		! make global check even if aperture is not defined
-		lost_global =.false.
-     	do jtrk = 1,ktrack
-	     	lost_global =  ISNAN(track(2,jtrk)) .or. ISNAN(track(4,jtrk)) .or. &
-	        ISNAN(track(5,jtrk)) .or. ISNAN(track(6,jtrk))                                .or. &
-	        abs(track(1, jtrk)) .gt. maxaper(1) .or.  abs(track(2, jtrk)) .gt. maxaper(2) .or. &
-	        abs(track(3, jtrk)) .gt. maxaper(3) .or.  abs(track(4, jtrk)) .gt. maxaper(4) .or. &
-	        abs(track(5, jtrk)) .gt. maxaper(5) .or.  abs(track(6, jtrk)) .gt. maxaper(6)
-	        if(lost_global) then
-			    APERTURE(:maxnaper) = zero
-			    call get_node_vector('aperture ',nn,aperture)
-
-			    OFFSET = zero
-			    call get_node_vector('aper_offset ',nn,offset)
-			    call trcoll(apint,  aperture, offset, al_errors,  maxaper, &
-          			turn, sum, part_id, last_turn, last_pos, last_orbit, track, ktrack, debug)
-			    EXIT ! They are anway checked against all the particles so no need to continue to loop
-	        endif 
+    ! make global check even if aperture is not defined
+    lost_global =.false.
+      do jtrk = 1,ktrack
+        lost_global =  ISNAN(track(2,jtrk)) .or. ISNAN(track(4,jtrk)) .or. &
+          ISNAN(track(5,jtrk)) .or. ISNAN(track(6,jtrk))                                .or. &
+          abs(track(1, jtrk)) .gt. maxaper(1) .or.  abs(track(2, jtrk)) .gt. maxaper(2) .or. &
+          abs(track(3, jtrk)) .gt. maxaper(3) .or.  abs(track(4, jtrk)) .gt. maxaper(4) .or. &
+          abs(track(5, jtrk)) .gt. maxaper(5) .or.  abs(track(6, jtrk)) .gt. maxaper(6)
+          if(lost_global) then
+          APERTURE(:maxnaper) = zero
+          call get_node_vector('aperture ',nn,aperture)
+
+          OFFSET = zero
+          call get_node_vector('aper_offset ',nn,offset)
+          call trcoll(apint,  aperture, offset, al_errors,  maxaper, &
+                turn, sum, part_id, last_turn, last_pos, last_orbit, track, ktrack, debug)
+          EXIT ! They are anway checked against all the particles so no need to continue to loop
+          endif 
         enddo 
 
      else
@@ -803,8 +854,6 @@ subroutine ttmap(switch,code,el,track,ktrack,dxt,dyt,sum,turn,part_id, &
      !call get_node_vector('aperture ',nn,aperture)
      call node_aperture_vector(aperture)
      call node_aperture_offset(offset)
-     !print*, aperture
-
      !OFFSET = zero
      !call get_node_vector('aper_offset ',nn,offset)
 
@@ -829,6 +878,10 @@ subroutine ttmap(switch,code,el,track,ktrack,dxt,dyt,sum,turn,part_id, &
        call tttdipole(track,ktrack)
 
     case (code_matrix)
+       EK(:6) = zero
+       RE(:6,:6) = zero
+       TE(:6,:6,:6) = zero
+       CRAPORB(:6) = zero
        call tmarb(.false.,.false.,craporb,fmap,ek,re,te)
        call tttrak(ek,re,track,ktrack)
 
@@ -836,7 +889,7 @@ subroutine ttmap(switch,code,el,track,ktrack,dxt,dyt,sum,turn,part_id, &
        call tttquad(track,ktrack)
 
     case (code_multipole)
-       call ttmult(track,ktrack,dxt,dyt,turn)
+       call ttmult(track,ktrack,dxt,dyt,turn,thin_foc)
 
     case (code_solenoid)
        call trsol(track, ktrack,dxt,dyt)
@@ -859,7 +912,7 @@ subroutine ttmap(switch,code,el,track,ktrack,dxt,dyt,sum,turn,part_id, &
        call ttxrot(track, ktrack)
 
     case (code_hkicker, code_vkicker, code_kicker, code_tkicker)
-       call ttcorr(el, track, ktrack, turn)
+       call ttcorr(el, track, ktrack, turn, code)
 
     !case (code_ecollimator)
     !   call fort_warn('TRRUN: ','found deprecated ECOLLIMATOR element; should be replaced by COLLIMATOR')
@@ -922,12 +975,13 @@ subroutine ttmap(switch,code,el,track,ktrack,dxt,dyt,sum,turn,part_id, &
   return
 end subroutine ttmap
 
-subroutine ttmult(track,ktrack,dxt,dyt,turn)
+subroutine ttmult(track,ktrack,dxt,dyt,turn, thin_foc)
   use twtrrfi
   use name_lenfi
   use trackfi
   use time_varfi
   use math_constfi, only : zero, one, two, three
+  use track_enums
   implicit none
   !----------------------------------------------------------------------*
   ! Purpose:                                                             *
@@ -937,19 +991,22 @@ subroutine ttmult(track,ktrack,dxt,dyt,turn)
   !   KTRACK    (integer) Number of surviving tracks.                    *
   !   dxt       (double)  local buffer                                   *
   !   dyt       (double)  local buffer                                   *
+  !   el_num    (integer) elemenent number in sequence                   *
+  !   para(*,20)(double)  matrix containing the values                   *
   !----------------------------------------------------------------------*
   double precision :: track(6,*), dxt(*), dyt(*)
   integer :: ktrack, turn
 
   logical, save :: first=.true.
-  logical ::  time_var
+  logical ::  time_var,thin_foc
   integer :: iord, jtrk, nd, nord, i, j, n_ferr, nn, ns, noisemax, nn1, in, mylen
+  integer :: nnt, nst
   double precision :: curv, dbi, dbr, dipi, dipr, dx, dy, elrad
   double precision :: pt, px, py, rfac
   double precision :: f_errors(0:maxferr)
   double precision :: field(2,0:maxmul)
   !double precision :: vals(2,0:maxmul)
-  double precision :: normal(0:maxmul), skew(0:maxmul), an
+  double precision :: normal(0:maxmul), skew(0:maxmul),normalt(0:maxmul),skewt(0:maxmul),an
   double precision, save :: ordinv(maxmul), const
   double precision :: bvk, node_value, ttt
   double precision :: npeak(100), nlag(100), ntune(100), temp, noise
@@ -957,6 +1014,8 @@ subroutine ttmult(track,ktrack,dxt,dyt,turn)
   double precision :: beta_sqr, f_damp_t
   
   integer :: node_fd_errors, store_no_fd_err, get_option
+  double precision , external:: get_tt_attrib  
+  external:: get_tt_multipoles
 
   !---- Precompute reciprocals of orders and radiation constant
   if (first) then
@@ -970,20 +1029,24 @@ subroutine ttmult(track,ktrack,dxt,dyt,turn)
   F_ERRORS(0:maxferr) = zero
   n_ferr = node_fd_errors(f_errors)
 
-  bvk = node_value('other_bv ')
-
-  !---- Multipole length for radiation.
-  elrad = node_value('lrad ')
-  noise = node_value('noise ')
+  bvk = get_tt_attrib(enum_other_bv)
+    !---- Multipole length for radiation.
+  elrad = get_tt_attrib(enum_lrad)
+  noise = get_tt_attrib(enum_noise)
+  an = get_tt_attrib(enum_angle)
+  time_var = get_tt_attrib(enum_time_var) .ne. 0  
 
+  
   !---- Multipole components.
-  NORMAL(0:maxmul) = zero ; call get_node_vector('knl ',nn,normal)
-  SKEW(0:maxmul) = zero   ; call get_node_vector('ksl ',ns,skew)
+  NORMAL(0:maxmul) = zero! ; call get_node_vector('knl ',nn,normal)
+  SKEW(0:maxmul) = zero  ! ; call get_node_vector('ksl ',ns,skew)
+
+  call get_tt_multipoles(nn,normal,ns,skew)
+
 
   nd = 2 * max(nn, ns, n_ferr/2-1)
 
   !---- Angle (no bvk in track)
-  an = node_value('angle ')
   if (an .ne. 0) f_errors(0) = f_errors(0) + normal(0) - an
 
   !----
@@ -1005,8 +1068,8 @@ subroutine ttmult(track,ktrack,dxt,dyt,turn)
 
   !--- Time variation for fields in matrix, multipole or RF-cavity
   ! 2015-Jun-24  18:55:43  ghislain: DOC FIXME not documented!!!
-  time_var = node_value('time_var ') .ne. zero
-
+ ! time_var = node_value('time_var ') .ne. zero
+ time_var = .false.
   if (time_var .and. time_var_m) then
      time_var_m_cnt = time_var_m_cnt + 1
      time_var_m_lnt = time_var_m_lnt + 1
@@ -1066,7 +1129,7 @@ subroutine ttmult(track,ktrack,dxt,dyt,turn)
      dxt(:ktrack) = zero
      dyt(:ktrack) = zero
      !----------- introduction of dipole focusing
-     if (elrad.gt.zero .and. get_option('thin_foc ').eq.1) then
+     if (elrad.gt.zero .and. thin_foc) then
 
         DXT(:ktrack) = dipr*dipr*TRACK(1,:ktrack)/elrad
         DYT(:ktrack) = dipi*dipi*TRACK(3,:ktrack)/elrad
@@ -1084,7 +1147,7 @@ subroutine ttmult(track,ktrack,dxt,dyt,turn)
            dyt(jtrk) = dx*track(3,jtrk) + dy*track(1,jtrk)
         enddo
      enddo
-     if (elrad.gt.zero .and. get_option('thin_foc ').eq.1) then
+     if (elrad.gt.zero .and. thin_foc) then
         DXT(:ktrack) = DXT(:ktrack) + dipr*dipr*TRACK(1,:ktrack)/elrad
         DYT(:ktrack) = DYT(:ktrack) + dipi*dipi*TRACK(3,:ktrack)/elrad
      endif
@@ -1708,11 +1771,12 @@ subroutine ttsep(track,ktrack)
 
 end subroutine ttsep
 
-subroutine ttcorr(el,track,ktrack,turn)
+subroutine ttcorr(el,track,ktrack,turn, code)
   use twtrrfi
   use trackfi
   use math_constfi, only : zero, one, two, three, twopi
   use code_constfi
+  use track_enums
   implicit none
   !----------------------------------------------------------------------*
   ! Purpose:                                                             *
@@ -1737,19 +1801,28 @@ subroutine ttcorr(el,track,ktrack,turn)
 
   integer :: node_fd_errors, get_option
   double precision :: get_variable, get_value, node_value
+  double precision :: external, get_tt_attrib
 
   !---- Initialize.
-  bvk = node_value('other_bv ')
-  deltas = get_variable('track_deltap ')
-  arad = get_value('probe ','arad ')
-  betas = get_value('probe ','beta ')
-  gammas = get_value('probe ','gamma ')
-  dtbyds = get_value('probe ','dtbyds ')
-  radiate = get_value('probe ','radiate ') .ne. zero
-  damp = get_option('damp ') .ne. 0
-  quantum = get_option('quantum ') .ne. 0
+        
+      
+  bvk = get_tt_attrib(enum_other_bv)
+  sinkick = get_tt_attrib(enum_sinkick)
+  
+
+  
+  !deltas = get_variable('track_deltap ')
+  
+  !arad = get_value('probe ','arad ')
+  !betas = get_value('probe ','beta ')
+  !gammas = get_value('probe ','gamma ')
+  !dtbyds = get_value('probe ','dtbyds ')
+  !radiate = get_value('probe ','radiate ') .ne. zero
+  
+  !damp = get_option('damp ') .ne. 0
+  !quantum = get_option('quantum ') .ne. 0
 
-  code = node_value('mad8_type ')
+  
 !  if (code .eq. code_tkicker)      code = code_kicker
   !if (code .eq. code_placeholder) code = code_instrument
 
@@ -1765,21 +1838,20 @@ subroutine ttcorr(el,track,ktrack,turn)
 
   select case (code)
     case (code_hkicker)
-       xkick = bvk*(node_value('kick ')+node_value('chkick ')+field(1)/div)
+       xkick = bvk*(get_tt_attrib(enum_kick)+get_tt_attrib(enum_chkick)+field(1)/div)
        ykick = zero
     case (code_kicker, code_tkicker)
-       xkick = bvk*(node_value('hkick ')+node_value('chkick ')+field(1)/div)
-       ykick = bvk*(node_value('vkick ')+node_value('cvkick ')+field(2)/div)
+       xkick = bvk*(get_tt_attrib(enum_hkick)+get_tt_attrib(enum_chkick)+field(1)/div)
+       ykick = bvk*(get_tt_attrib(enum_vkick)+get_tt_attrib(enum_cvkick)+field(2)/div)
     case (code_vkicker)
        xkick = zero
-       ykick = bvk*(node_value('kick ')+node_value('cvkick ')+field(2)/div)
+       ykick = bvk*(get_tt_attrib(enum_kick)+get_tt_attrib(enum_cvkick)+field(2)/div)
     case default
        xkick = zero
        ykick = zero
   end select
 
   !---- Sinusoidal kick (not supported by tkicker)
-  sinkick = node_value('sinkick ')
   if (sinkick .eq. 1) then
      sinpeak = node_value('sinpeak ')
      sintune = node_value('sintune ')
@@ -2886,9 +2958,9 @@ subroutine trcoll(apint,  aperture, offset, al_errors, maxaper, &
         lost =  x .gt. ap1 .or. y .gt. ap2 ! First checks the user defined rectangle
         if(lost) then
           x = z(1,i) - al_errors(11) - offset(1)
-     	  y = z(3,i) - al_errors(12) - offset(2)
-     	  lost = inside_userdefined_geometry(x,y) .eq. 0
-     	endif
+        y = z(3,i) - al_errors(12) - offset(2)
+        lost = inside_userdefined_geometry(x,y) .eq. 0
+      endif
      case default
 
      end select
@@ -3469,6 +3541,7 @@ subroutine trupdate(turn)
   call pro_input(cmd)
   write(cmd, '(''exec, tr$macro($tr$turni) ; '')')
   call pro_input(cmd)
+  call init_elements() ! added since now temporary variables are used and need to update
 end subroutine trupdate
 
 subroutine trclor(switch,orbit0)
@@ -3492,7 +3565,7 @@ subroutine trclor(switch,orbit0)
   integer :: switch
   double precision :: orbit0(6)
 
-  logical :: aperflag, onepass, debug
+  logical :: aperflag, onepass, debug, thin_foc
   integer :: itra
 
   integer :: i, j, k, bbd_pos, j_tot, code, irank, n_align
@@ -3502,7 +3575,7 @@ subroutine trclor(switch,orbit0)
   double precision :: z(6,7), zz(6), z0(6,7), z00(6,7), a(6,7), ddd(6)
   double precision :: cotol, err, deltap, el, dxt(200), dyt(200)
   double precision :: al_errors(align_max)
-  double precision :: sum, orbit(6)
+  double precision :: sum, orbit(6), theta
   double precision :: last_pos(6), last_orbit(6,1), maxaper(6)
   character(len=12) :: char_a
 
@@ -3557,6 +3630,8 @@ subroutine trclor(switch,orbit0)
   ORBIT = ORBIT0
 
   !---- Iteration for closed orbit.
+  debug = get_option('debug ') .ne. 0
+  thin_foc = get_option('thin_foc ') .eq. 1
   do itra = 1, itmax
      j = restart_sequ()
 
@@ -3601,10 +3676,11 @@ subroutine trclor(switch,orbit0)
               enddo
            endif
         endif
-		debug = get_option('debug ') .ne. 0
+    
+    theta = node_value('tilt ')
         !-------- Track through element
         call ttmap(switch,code,el,z,pmax,dxt,dyt,sum,turn,part_id, &
-             last_turn,last_pos,last_orbit,aperflag,maxaper,al_errors,onepass, debug)
+             last_turn,last_pos,last_orbit,aperflag,maxaper,al_errors,onepass, debug, theta, thin_foc)
 
         !--------  Misalignment at end of element (from twissfs.f)
         if (code .ne. code_drift .and. n_align .ne. 0)  then
diff --git a/src/util.f90 b/src/util.f90
index 22729b36d..9db557652 100644
--- a/src/util.f90
+++ b/src/util.f90
@@ -128,7 +128,22 @@ module aperture_enums
   integer, parameter :: ap_custom = 8
 
 end module aperture_enums
-
+module track_enums
+  implicit none
+  public
+  integer, parameter :: enum_other_bv = 1
+  integer, parameter :: enum_lrad = 2
+  integer, parameter :: enum_noise = 3
+  integer, parameter :: enum_angle = 4
+  integer, parameter :: enum_time_var = 5
+  integer, parameter :: enum_sinkick = 6
+  integer, parameter :: enum_kick = 7
+  integer, parameter :: enum_chkick = 8
+  integer, parameter :: enum_cvkick = 9
+  integer, parameter :: enum_hkick = 10 
+  integer, parameter :: enum_vkick = 11  
+  integer, parameter :: total_enums = 11
+end module track_enums
 module Inf_NaN_Detection
 
   !!     Inf_NaN_Detection module