cloreb.f File Reference

Go to the source code of this file.

Functions/Subroutines
subroutine	cloreb (i, gb, q, p)

Function/Subroutine Documentation

cloreb()

subroutine cloreb	(	integer	i,
		type(fmom)	gb,
		type(ptcl)	q,
		type(ptcl)	p
	)

Definition at line 82 of file cloreb.f.

References clorep().

Referenced by cibstpol().

         implicit none
#include  "Zptcl.h"
         type(fmom):: gb
         type(ptcl)::  q, p
         integer i

         type(ptcl):: qq
         type(fmom):: a, b, beta
         real*8 betanorm, anorm

#ifdef USESAVE
         save a, b, beta, betanorm
#endif
  
         if(i .eq. 1) then
#ifdef NEXT486
            betanorm = gb%x**2 + gb%y**2 + gb%z**2
            if(betanorm .ne. 0.) then
               betanorm = sqrt(betanorm)
               beta%x = gb%x/betanorm
               beta%y = gb%y/betanorm
               beta%z = gb%z/betanorm
               a%x= beta%y
               a%y = -beta%x
               a%z= 0
               anorm = a%x**2 + a%y**2
               if(anorm .eq. 0.) then
                  a%x = 1.
                  a%y = 0.
                  a%z = 0.
               else
                  anorm = sqrt(anorm)
                  a%x = a%x/anorm
                  a%y = a%y/anorm
               endif
!
               b%x = beta%y*a%z - beta%z * a%y
               b%y = beta%z*a%x - beta%x* a%z
               b%z = beta%x*a%y - beta%y* a%x
            endif
         endif
         if(betanorm .eq. 0.) then
            p = q
            if(gb%z .lt. 0.) then
               p%fm%z = - p%fm%z
               p%fm%y = - p%fm%y
               p%fm%x = - p%fm%x
            endif
         else
!            assume that  qx is  a-direction and qy is b direction

               qq = q
            qq%fm%x = q%fm%x*a%x +  q%fm%y*b%x +
     *         q%fm%z*beta%x
            qq%fm%y = q%fm%x*a%y +  q%fm%y*b%y +
     *         q%fm%z*beta%y
            qq%fm%z = q%fm%x*a%z +  q%fm%y*b%z +
     *         q%fm%z*beta%z
            qq%fm%e = q%fm%e
!              Lorentz boost by gb
            call clorep(i, gb, qq, p)
         endif
#else
            betanorm = gb%p(1)**2 + gb%p(2)**2 + gb%p(3)**2 
            if(betanorm .ne. 0.) then
               betanorm = sqrt(betanorm)
               beta%p(1) = gb%p(1)/betanorm
               beta%p(2) = gb%p(2)/betanorm
               beta%p(3) = gb%p(3)/betanorm
               a%p(1)= beta%p(2)
               a%p(2) = -beta%p(1)
               a%p(3)= 0
               anorm = a%p(1)**2 + a%p(2)**2
               if(anorm .eq. 0.) then
                  a%p(1) = 1.
                  a%p(2) = 0.
                  a%p(3) = 0.
               else
                  anorm = sqrt(anorm)
                  a%p(1) = a%p(1)/anorm
                  a%p(2) = a%p(2)/anorm
               endif
!
               b%p(1) = beta%p(2)*a%p(3) - beta%p(3) * a%p(2)
               b%p(2) = beta%p(3)*a%p(1) - beta%p(1)* a%p(3)
               b%p(3) = beta%p(1)*a%p(2) - beta%p(2)* a%p(1)
            endif
         endif
         if(betanorm .eq. 0.) then
            p = q
            if(gb%p(3) .lt. 0.) then
               p%fm%p(3) = - p%fm%p(3)
               p%fm%p(2) = - p%fm%p(2)
               p%fm%p(1) = - p%fm%p(1)
            endif
         else
!            assume that  qx is  a-direction and qy is b direction
!
            qq = q
            qq%fm%p(1) = q%fm%p(1)*a%p(1) +  q%fm%p(2)*b%p(1) +
     *           q%fm%p(3)*beta%p(1)
            qq%fm%p(2) = q%fm%p(1)*a%p(2) +  q%fm%p(2)*b%p(2) + 
     *           q%fm%p(3)*beta%p(2)
            qq%fm%p(3) = q%fm%p(1)*a%p(3) +  q%fm%p(2)*b%p(3) +
     *           q%fm%p(3)*beta%p(3)
            qq%fm%p(4) = q%fm%p(4)
!              Lorentz boost by gb
            call clorep(i, gb, qq, p)
         endif
#endif

Here is the call graph for this function:

Here is the caller graph for this function: