clorep.f File Reference

Go to the source code of this file.

Functions/Subroutines
subroutine	clorep (j, gb, q, p)

Function/Subroutine Documentation

clorep()

subroutine clorep	(	integer	j,
		type(fmom)	gb,
		type(ptcl)	q,
		type(ptcl)	p
	)

Definition at line 88 of file clorep.f.

References capplyrot4(), cgetrotmat4(), cinvrotmat4(), cmultrotmat4(), d0, and g.

Referenced by cbst0(), cibst1(), and cloreb().

         implicit none
!----         include '../Zptcl.h'
#include  "Zptcl.h"

         type(fmom):: gb
         type(ptcl):: q, p
!
         real*8 rm(4, 4), rmy(4, 4), rmyi(4, 4), rmz(4, 4),
     *          rmzi(4, 4),  rmi(4, 4), gmin/1.e4/, g
         real*8 fai1, fai2,  tmp,  gbq, a
         type(fmom):: agb
         type(ptcl):: qt

#ifdef   USESAVE
         save agb
#endif

         integer jsv/0/, i, j
         save  rm, rmi, jsv
!
         p = q
         gbq = 0.d0
         do   i=1, 3
            gbq=gbq + gb%p(i)*q%fm%p(i)
         enddo
!
         g = gb%p(4) 
         a=1.d0/(1.d0+g)
         if(gbq .ge. 0.d0 .or. g .lt. gmin) then
!         if(gbq .ge. 0.d0 ) then
              do   i=1, 3
                p%fm%p(i) = q%fm%p(i) + 
     *                      gb%p(i)*(q%fm%p(4) + a*gbq)
              enddo
             p%fm%p(4) = g*q%fm%p(4) + gbq
!               j=1, but matrix is not computed
             if(j .eq.1) jsv=0
         else
!              rotate the axes by atan(beta(y)/beta(x)) around z,
!              then rotate the axes by  atan(beta/beta(z))
!              around y, then the orignal z axis coincide with
!              beta.  apply lorentz trans. there and re-rotate
!                 matrix for z-axis
             if(j .eq. 1 .or. jsv .eq. 0) then
                 if(gb%p(2) .eq. 0. .and. gb%p(1) .eq. 0.) then
                     fai1=0.
                 else
                     fai1= atan2(gb%p(2), gb%p(1))
                 endif
                 call cgetrotmat4(3, fai1, rmz)
!                     matrix for y-axis
                 tmp=gb%p(1)**2 + gb%p(2)**2
                 agb%p(3)= sqrt(tmp + gb%p(3)**2)
                 agb%p(4)=g
                 if(tmp .eq. 0. and. gb%p(3) .eq. 0.) then
                    fai2 = 0.
                 else
                    fai2= atan2(sqrt(tmp), gb%p(3))
                 endif
                 call cgetrotmat4(2, fai2, rmy)
!                     combined rotaion matrix
                 call cmultrotmat4(rmy, rmz, rm)
             endif
!                 do combined rotaion
             qt = q
             call capplyrot4(rm, q%fm, qt%fm)
             qt%fm%p(4)=q%fm%p(4)
!           ////////////
!             call ctestOnShell('q before rot', q)
!             call ctestOnShell('qt after rot', qt)
!           ////////////////                      

!                   lorentz trans. along beta
             call clorez(agb, qt,  qt)
!           /////////
!             call ctestOnShell('after lorez', qt)
!           /////////////
!                   re-rotate; get inverse rotation matrix
             if(j .eq. 1 .or. jsv .eq. 0) then
                 call cinvrotmat4(rmz, rmzi)
                 call cinvrotmat4(rmy, rmyi)
                 call cmultrotmat4(rmzi, rmyi, rmi)
             endif
             call capplyrot4(rmi, qt%fm, p%fm)
             p%fm%p(4) = qt%fm%p(4)
!           ////////////
!             call ctestOnShell('after rot', p)
!           ////////////////                      
             jsv=1
          endif

Here is the call graph for this function:

Here is the caller graph for this function: