2056 lines
58 KiB
Fortran
2056 lines
58 KiB
Fortran
c -------------------------------------------------------------------- c
|
|
c ------ This and the following subroutines read in the spectrum ----- c
|
|
c ------ file given in the SUSY Les Houches Accord format ----- c
|
|
c ------ hep-ph/0311123. ----- c
|
|
c ------ Thanks to Tilman Plehn for the first version which has ----- c
|
|
c ------ been expanded and changed here. ----- c
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_read_leshouches_HDEC(ninlha)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
double precision minval(1:20),smval(1:30),massval(1:50),
|
|
. nmixval(4,4),umixval(2,2),vmixval(2,2),
|
|
. stopmixval(2,2),sbotmixval(2,2),staumixval(2,2),
|
|
. hmixval(1:10),gaugeval(1:3),msoftval(1:100),
|
|
. auval(3,3),adval(3,3),aeval(3,3),yuval(3,3),
|
|
. ydval(3,3),yeval(3,3),qvalue(1:20),extval(0:100)
|
|
double precision tuval(3,3),tdval(3,3),teval(3,3)
|
|
double precision vckmval(4)
|
|
integer check(1:22),check_final,imod(1:2)
|
|
character line1*6,line2*100,
|
|
. spinfo1*100,spinfo2*100,modselval*100,mincom(1:20)*20,
|
|
. extcom(0:100)*20,softcom(1:100)*20,hmixcom(1:10)*20
|
|
logical done
|
|
|
|
COMMON/SLHA_leshouches1_HDEC/spinfo1,spinfo2,modselval,mincom,
|
|
. extcom,softcom,hmixcom
|
|
COMMON/SLHA_leshouches2_HDEC/minval,extval,smval,massval,nmixval,
|
|
. umixval,vmixval,stopmixval,sbotmixval,
|
|
. staumixval,hmixval,gaugeval,msoftval,auval,
|
|
. adval,aeval,yuval,ydval,yeval,alphaval,
|
|
. qvalue,imod
|
|
COMMON/SLHA_leshouches3_HDEC/vckmval
|
|
COMMON/SLHA_checkval_HDEC/check
|
|
|
|
c -- start from the beginning of the file SLHA_leshouches.in --
|
|
rewind(ninlha)
|
|
|
|
c -- initialization of the check array --
|
|
do i1=1,22,1
|
|
check(i1) = 0
|
|
end do
|
|
|
|
c -- the scale Q --
|
|
do i=1,20,1
|
|
qvalue(i) = 0.D0
|
|
end do
|
|
|
|
c a trick to jump over undefined parameters in subsequent writings
|
|
unlikely = -123456789D0
|
|
do i=1,100,1
|
|
extval(i-1) = unlikely
|
|
end do
|
|
do i=1,20,1
|
|
minval(i) = unlikely
|
|
end do
|
|
do i=1,10,1
|
|
hmixval(i) = unlikely
|
|
end do
|
|
do i=1,100,1
|
|
msoftval(i) = unlikely
|
|
end do
|
|
do i=1,3,1
|
|
do j=1,3,1
|
|
auval(i,j) = unlikely
|
|
adval(i,j) = unlikely
|
|
aeval(i,j) = unlikely
|
|
end do
|
|
end do
|
|
do i=1,4,1
|
|
vckmval(i) = unlikely
|
|
end do
|
|
|
|
c ------------------------------------------------------------------- c
|
|
do i=1,10000,1
|
|
|
|
c -- check if routine can be left --
|
|
check_final = 1
|
|
do i1=1,22,1
|
|
check_final = check_final*check(i1)
|
|
end do
|
|
if(check_final.eq.1) then
|
|
return
|
|
endif
|
|
|
|
c -- read in new line --
|
|
line1=' '
|
|
read(ninlha,'(a6,a100)',end=9900,err=9900) line1,line2
|
|
|
|
c -- rewrite line1(1:6) and line2(1:20) to upper case --
|
|
do j1=1,6,1
|
|
if(line1(j1:j1).ne.'#') then
|
|
do j2=97,122,1
|
|
if(line1(j1:j1).eq.char(j2)) line1(j1:j1)=char(j2-32)
|
|
end do
|
|
endif
|
|
end do
|
|
|
|
do j1=1,20,1
|
|
if(line2(j1:j1).ne.'#') then
|
|
do j2=97,122,1
|
|
if(line2(j1:j1).eq.char(j2)) line2(j1:j1)=char(j2-32)
|
|
end do
|
|
endif
|
|
end do
|
|
|
|
c -- looks for blocks and reads them in one after the other --
|
|
if(line1(1:1).eq.'B') then
|
|
|
|
c -- look for Block MODSEL --
|
|
if(line2(1:6).eq.'MODSEL') then
|
|
call SLHA_READ_MODSEL_HDEC(ninlha,modselval,imod,done)
|
|
if (done) then
|
|
check(1) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in MODSEL'
|
|
endif
|
|
|
|
c -- look for Block SMINPUTS --
|
|
elseif(line2(1:8).eq.'SMINPUTS') then
|
|
call SLHA_READ_SMINPUTS_HDEC(ninlha,smval,done)
|
|
if (done) then
|
|
check(2) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in SMINPUTS'
|
|
endif
|
|
|
|
c -- look for Block MINPAR --
|
|
elseif(line2(1:6).eq.'MINPAR') then
|
|
call SLHA_READ_MINPAR_HDEC(ninlha,minval,mincom,done)
|
|
if (done) then
|
|
check(3) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in MINPAR'
|
|
endif
|
|
|
|
c -- look for Block EXTPAR --
|
|
elseif(line2(1:6).eq.'EXTPAR') then
|
|
call SLHA_READ_EXTPAR_HDEC(ninlha,extval,extcom,done)
|
|
if (done) then
|
|
check(4) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in EXTPAR'
|
|
endif
|
|
|
|
c -- look for Block MASS --
|
|
elseif(line2(1:4).eq.'MASS') then
|
|
call SLHA_READ_MASS_HDEC(ninlha,massval,done)
|
|
if (done) then
|
|
check(5) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in MASS'
|
|
endif
|
|
|
|
c -- look for Block NMIX --
|
|
elseif(line2(1:4).eq.'NMIX') then
|
|
call SLHA_READ_NMIX_HDEC(ninlha,nmixval,done)
|
|
if (done) then
|
|
check(6) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in NMIX'
|
|
endif
|
|
|
|
c -- look for Block UMIX --
|
|
elseif(line2(1:4).eq.'UMIX') then
|
|
call SLHA_READ_UMIX_HDEC(ninlha,umixval,done)
|
|
if (done) then
|
|
check(7) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in UMIX'
|
|
endif
|
|
|
|
c -- look for Block VMIX --
|
|
elseif(line2(1:4).eq.'VMIX') then
|
|
call SLHA_READ_VMIX_HDEC(ninlha,vmixval,done)
|
|
if (done) then
|
|
check(8) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in VMIX'
|
|
endif
|
|
|
|
c -- look for Block STOPMIX --
|
|
elseif(line2(1:7).eq.'STOPMIX') then
|
|
call SLHA_READ_STOPMIX_HDEC(ninlha,stopmixval,done)
|
|
if (done) then
|
|
check(9) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in STOPMIX'
|
|
endif
|
|
|
|
c -- look for Block SBOTMIX --
|
|
elseif(line2(1:7).eq.'SBOTMIX') then
|
|
call SLHA_READ_SBOTMIX_HDEC(ninlha,sbotmixval,done)
|
|
if (done) then
|
|
check(10) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in SBOTMIX'
|
|
endif
|
|
|
|
c -- look for Block STAUMIX --
|
|
elseif(line2(1:7).eq.'STAUMIX') then
|
|
call SLHA_READ_STAUMIX_HDEC(ninlha,staumixval,done)
|
|
if (done) then
|
|
check(11) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in STAUMIX'
|
|
endif
|
|
|
|
c -- look for Block ALPHA --
|
|
elseif(line2(1:5).eq.'ALPHA') then
|
|
call SLHA_READ_ALPHA_HDEC(ninlha,alphaval,done)
|
|
if (done) then
|
|
check(12) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in ALPHA'
|
|
endif
|
|
|
|
c -- look for Block HMIX --
|
|
elseif(line2(1:4).eq.'HMIX') then
|
|
c backspace ninlha
|
|
c read(ninlha,'(16x,E16.8)') Qval
|
|
call readQval(ninlha,Qval)
|
|
qvalue(1) = Qval
|
|
call SLHA_READ_HMIX_HDEC(ninlha,hmixval,hmixcom,done)
|
|
if (done) then
|
|
check(13) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in HMIX'
|
|
endif
|
|
|
|
c -- look for Block GAUGE --
|
|
elseif(line2(1:5).eq.'GAUGE') then
|
|
c backspace ninlha
|
|
c read(ninlha,'(16x,E16.8)') Qval
|
|
call readQval(ninlha,Qval)
|
|
qvalue(2) = Qval
|
|
call SLHA_READ_GAUGE_HDEC(ninlha,gaugeval,done)
|
|
if (done) then
|
|
check(14) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in GAUGE'
|
|
endif
|
|
|
|
c -- look for Block MSOFT --
|
|
elseif(line2(1:5).eq.'MSOFT') then
|
|
c backspace ninlha
|
|
c read(ninlha,'(16x,E16.8)') Qval
|
|
call readQval(ninlha,Qval)
|
|
qvalue(3) = Qval
|
|
call SLHA_READ_MSOFT_HDEC(ninlha,msoftval,softcom,done)
|
|
if (done) then
|
|
check(15) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in MSOFT'
|
|
endif
|
|
|
|
c -- look for Block AU --
|
|
elseif(line2(1:2).eq.'AU') then
|
|
c backspace ninlha
|
|
c read(ninlha,'(13x,E16.8)') Qval
|
|
call readQval(ninlha,Qval)
|
|
qvalue(4) = Qval
|
|
call SLHA_READ_AU_HDEC(ninlha,auval,done)
|
|
if (done) then
|
|
check(16) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in AU'
|
|
endif
|
|
|
|
c -- look for Block AD --
|
|
elseif(line2(1:2).eq.'AD') then
|
|
c backspace ninlha
|
|
c read(ninlha,'(13x,E16.8)') Qval
|
|
call readQval(ninlha,Qval)
|
|
qvalue(5) = Qval
|
|
call SLHA_READ_AD_HDEC(ninlha,adval,done)
|
|
if (done) then
|
|
check(17) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in AD'
|
|
endif
|
|
|
|
c -- look for Block AE --
|
|
elseif(line2(1:2).eq.'AE') then
|
|
c backspace ninlha
|
|
c read(ninlha,'(13x,E16.8)') Qval
|
|
call readQval(ninlha,Qval)
|
|
qvalue(6) = Qval
|
|
call SLHA_READ_AE_HDEC(ninlha,aeval,done)
|
|
if (done) then
|
|
check(18) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in AE'
|
|
endif
|
|
|
|
c -- look for Block YU --
|
|
elseif(line2(1:2).eq.'YU') then
|
|
c backspace ninlha
|
|
c read(ninlha,'(13x,E16.8)') Qval
|
|
call readQval(ninlha,Qval)
|
|
qvalue(7) = Qval
|
|
call SLHA_READ_YU_HDEC(ninlha,yuval,done)
|
|
if (done) then
|
|
check(19) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in YU'
|
|
endif
|
|
|
|
c -- look for Block YD --
|
|
elseif(line2(1:2).eq.'YD') then
|
|
c backspace ninlha
|
|
c read(ninlha,'(13x,E16.8)') Qval
|
|
call readQval(ninlha,Qval)
|
|
qvalue(8) = Qval
|
|
call SLHA_READ_YD_HDEC(ninlha,ydval,done)
|
|
if (done) then
|
|
check(20) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in YD'
|
|
endif
|
|
|
|
c -- look for Block YE --
|
|
elseif(line2(1:2).eq.'YE') then
|
|
c backspace ninlha
|
|
c read(ninlha,'(13x,E16.8)') Qval
|
|
call readQval(ninlha,Qval)
|
|
qvalue(9) = Qval
|
|
call SLHA_READ_YE_HDEC(ninlha,yeval,done)
|
|
if (done) then
|
|
check(21) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in YE'
|
|
endif
|
|
|
|
c -- look for Block SPINFO --
|
|
elseif(line2(1:6).eq.'SPINFO') then
|
|
call SLHA_READ_SPINFO_HDEC(ninlha,spinfo1,spinfo2,done)
|
|
if (done) then
|
|
check(22) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in SPINFO'
|
|
endif
|
|
|
|
c -- look for Block TUIN --
|
|
elseif(line2(1:4).eq.'TUIN') then
|
|
c backspace ninlha
|
|
c read(ninlha,'(13x,E16.8)') Qval
|
|
call readQval(ninlha,Qval)
|
|
qvalue(4) = Qval
|
|
call SLHA_READ_TUIN_HDEC(ninlha,tuval,done)
|
|
auval(1,1) = tuval(1,1)/smval(22)
|
|
auval(2,2) = tuval(2,2)/smval(24)
|
|
auval(3,3) = tuval(3,3)/smval(6)
|
|
do ii=1,3
|
|
do jj=1,3
|
|
if(ii.ne.jj)auval(ii,jj)=0
|
|
enddo
|
|
enddo
|
|
if (done) then
|
|
check(16) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in TUIN'
|
|
endif
|
|
|
|
c -- look for Block TDIN --
|
|
elseif(line2(1:4).eq.'TDIN') then
|
|
c backspace ninlha
|
|
c read(ninlha,'(13x,E16.8)') Qval
|
|
call readQval(ninlha,Qval)
|
|
qvalue(5) = Qval
|
|
call SLHA_READ_TDIN_HDEC(ninlha,tdval,done)
|
|
adval(1,1) = tdval(1,1)/smval(21)
|
|
adval(2,2) = tdval(2,2)/smval(23)
|
|
adval(3,3) = tdval(3,3)/smval(5)
|
|
do ii=1,3
|
|
do jj=1,3
|
|
if(ii.ne.jj)adval(ii,jj)=0
|
|
enddo
|
|
enddo
|
|
if (done) then
|
|
check(17) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in TDIN'
|
|
endif
|
|
|
|
c -- look for Block TEIN --
|
|
elseif(line2(1:4).eq.'TEIN') then
|
|
c backspace ninlha
|
|
c read(ninlha,'(13x,E16.8)') Qval
|
|
call readQval(ninlha,Qval)
|
|
qvalue(6) = Qval
|
|
call SLHA_READ_TEIN_HDEC(ninlha,teval,done)
|
|
aeval(1,1) = teval(1,1)/smval(11)
|
|
aeval(2,2) = teval(2,2)/smval(13)
|
|
aeval(3,3) = teval(3,3)/smval(7)
|
|
do ii=1,3
|
|
do jj=1,3
|
|
if(ii.ne.jj)aeval(ii,jj)=0
|
|
enddo
|
|
enddo
|
|
if (done) then
|
|
check(18) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in TEIN'
|
|
endif
|
|
|
|
|
|
c -- look for Block VCKMIN --
|
|
elseif(line2(1:6).eq.'VCKMIN') then
|
|
call SLHA_READ_VCKMIN_HDEC(ninlha,vckmval,done)
|
|
if (done) then
|
|
check(2) = 1
|
|
goto 1111
|
|
else
|
|
print*,'SLHA_read_leshouches: problem in VCKMIN'
|
|
endif
|
|
|
|
c -- continue if the Block is not interesting --
|
|
else
|
|
goto 1111
|
|
endif
|
|
|
|
c -- continue if it is not a Block statement --
|
|
else
|
|
goto 1111
|
|
endif
|
|
|
|
c -- maximum number of lines exhausted --
|
|
1111 continue
|
|
end do
|
|
|
|
c>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
|
c -- only absolute values --
|
|
c do i=1,20,1
|
|
c qvalue(i) = dabs(qvalue(i))
|
|
c end do
|
|
c>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
|
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
|
|
return
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_MODSEL_HDEC(ninlha,modselval,imod,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
integer imod(1:2)
|
|
character line1*1,line2*1,line3*100,modselval*100
|
|
logical done
|
|
|
|
done=.false.
|
|
|
|
modselval = ' '
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,*) idum1,idum2,line2,line3
|
|
|
|
if(idum1.eq.1) then
|
|
imod(1) = idum1
|
|
imod(2) = idum2
|
|
modselval = line3
|
|
endif
|
|
|
|
elseif(line1.eq.'#') then
|
|
go to 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done =.true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_SMINPUTS_HDEC(ninlha,smval,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
double precision smval(30)
|
|
character line1*1
|
|
logical done
|
|
|
|
done=.false.
|
|
|
|
do i=1,30,1
|
|
smval(i) = 0.D0
|
|
end do
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,*) idum,val
|
|
|
|
c -- inverse EM coupling at the Z pole in the MS_bar scheme (with --
|
|
c -- five active flavours) --
|
|
if(idum.eq.1) then
|
|
smval(1) = val
|
|
c -- G_F, Fermi constant (in units of GeV^-2)
|
|
elseif(idum.eq.2) then
|
|
smval(2) = val
|
|
c -- Strong coupling at the Z pole in the MS_bar scheme (with five --
|
|
c -- active flavours) --
|
|
elseif(idum.eq.3) then
|
|
smval(3) = val
|
|
c -- M_Z, pole mass --
|
|
elseif(idum.eq.4) then
|
|
smval(4) = val
|
|
c -- mb(mb)^MS_bar. b quark running mass in the MS_bar scheme --
|
|
elseif(idum.eq.5) then
|
|
smval(5) = val
|
|
c -- mt, pole mass --
|
|
elseif(idum.eq.6) then
|
|
smval(6) = val
|
|
c -- mtau, pole mass --
|
|
elseif(idum.eq.7) then
|
|
smval(7) = val
|
|
endif
|
|
|
|
elseif(line1.eq.'#') then
|
|
go to 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done =.true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_MINPAR_HDEC(ninlha,minval,mincom,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
double precision minval(20)
|
|
character line1*1,line2*1,line3*20,mincom(1:20)*20
|
|
logical done
|
|
|
|
done= .false.
|
|
|
|
do i=1,20,1
|
|
mincom(i) = ' '
|
|
end do
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,*) idum,val,line2,line3
|
|
|
|
do ii=1,6,1
|
|
if(idum.eq.ii) then
|
|
minval(ii) = val
|
|
mincom(ii) = line3
|
|
endif
|
|
end do
|
|
|
|
c -- i=3: value for tanbeta(MZ) --
|
|
|
|
elseif(line1.eq.'#') then
|
|
goto 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done = .true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_EXTPAR_HDEC(ninlha,extval,extcom,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
double precision extval(0:100)
|
|
character line1*1,line2*1,line3*20,extcom(0:100)*20
|
|
logical done
|
|
|
|
done= .false.
|
|
|
|
do i=1,100,1
|
|
extcom(i-1) = ' '
|
|
end do
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,*) idum,val,line2,line3
|
|
|
|
do ii=1,54,1
|
|
if(idum.eq.(ii-1)) then
|
|
extval(ii-1) = val
|
|
extcom(ii-1) = line3
|
|
endif
|
|
end do
|
|
|
|
elseif(line1.eq.'#') then
|
|
goto 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done = .true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_MASS_HDEC(ninlha,massval,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
double precision massval(50)
|
|
character line1*1
|
|
logical done
|
|
|
|
done= .false.
|
|
|
|
do i=1,50,1
|
|
massval(i) = 0.D0
|
|
end do
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,*) idum,val
|
|
|
|
c -- value for M_W --
|
|
if(idum.eq.24) then
|
|
massval(1) = val
|
|
c -- value for M_h --
|
|
elseif(idum.eq.25) then
|
|
massval(2) = val
|
|
c -- value for M_H --
|
|
elseif(idum.eq.35) then
|
|
massval(3) = val
|
|
c -- value for M_A --
|
|
elseif(idum.eq.36) then
|
|
massval(4) = val
|
|
c -- value for M_H+/- --
|
|
elseif(idum.eq.37) then
|
|
massval(5) = val
|
|
c -- value for ~d_L --
|
|
elseif(idum.eq.1000001) then
|
|
massval(6) = val
|
|
c -- value for ~d_R --
|
|
elseif(idum.eq.2000001) then
|
|
massval(7) = val
|
|
c -- value for ~u_L --
|
|
elseif(idum.eq.1000002) then
|
|
massval(8) = val
|
|
c -- value for ~u_R --
|
|
elseif(idum.eq.2000002) then
|
|
massval(9) = val
|
|
c -- value for ~s_L --
|
|
elseif(idum.eq.1000003) then
|
|
massval(10) = val
|
|
c -- value for ~s_R --
|
|
elseif(idum.eq.2000003) then
|
|
massval(11) = val
|
|
c -- value for ~c_L --
|
|
elseif(idum.eq.1000004) then
|
|
massval(12) = val
|
|
c -- value for ~c_R --
|
|
elseif(idum.eq.2000004) then
|
|
massval(13) = val
|
|
c -- value for ~b_1 --
|
|
elseif(idum.eq.1000005) then
|
|
massval(14) = val
|
|
c -- value for ~b_2 --
|
|
elseif(idum.eq.2000005) then
|
|
massval(15) = val
|
|
c -- value for ~t_1 --
|
|
elseif(idum.eq.1000006) then
|
|
massval(16) = val
|
|
c -- value for ~t_2 --
|
|
elseif(idum.eq.2000006) then
|
|
massval(17) = val
|
|
c -- value for ~e_L --
|
|
elseif(idum.eq.1000011) then
|
|
massval(18) = val
|
|
c -- value for ~e_R --
|
|
elseif(idum.eq.2000011) then
|
|
massval(19) = val
|
|
c -- value for ~nu_eL --
|
|
elseif(idum.eq.1000012) then
|
|
massval(20) = val
|
|
c -- value for ~mu_L --
|
|
elseif(idum.eq.1000013) then
|
|
massval(21) = val
|
|
c -- value for ~mu_R --
|
|
elseif(idum.eq.2000013) then
|
|
massval(22) = val
|
|
c -- value for ~nu_muL --
|
|
elseif(idum.eq.1000014) then
|
|
massval(23) = val
|
|
c -- value for ~tau_1 --
|
|
elseif(idum.eq.1000015) then
|
|
massval(24) = val
|
|
c -- value for ~tau_2 --
|
|
elseif(idum.eq.2000015) then
|
|
massval(25) = val
|
|
c -- value for ~nu_tauL --
|
|
elseif(idum.eq.1000016) then
|
|
massval(26) = val
|
|
c -- value for ~g --
|
|
elseif(idum.eq.1000021) then
|
|
massval(27) = val
|
|
c -- value for ~chi_10 --
|
|
elseif(idum.eq.1000022) then
|
|
massval(28) = val
|
|
c -- value for ~chi_20 --
|
|
elseif(idum.eq.1000023) then
|
|
massval(29) = val
|
|
c -- value for ~chi_30 --
|
|
elseif(idum.eq.1000025) then
|
|
massval(30) = val
|
|
c -- value for ~chi_40 --
|
|
elseif(idum.eq.1000035) then
|
|
massval(31) = val
|
|
c -- value for ~chi_1+ --
|
|
elseif(idum.eq.1000024) then
|
|
massval(32) = val
|
|
c -- value for ~chi_2+ --
|
|
elseif(idum.eq.1000037) then
|
|
massval(33) = val
|
|
endif
|
|
|
|
elseif(line1.eq.'#') then
|
|
goto 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done = .true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_NMIX_HDEC(ninlha,nmixval,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
double precision nmixval(4,4)
|
|
character line1*1
|
|
logical done
|
|
|
|
done= .false.
|
|
|
|
do i=1,4,1
|
|
do j=1,4,1
|
|
nmixval(i,j) = 0.D0
|
|
end do
|
|
end do
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,*) idum1,idum2,val
|
|
|
|
c -- the values for the neutralino mixing matrix --
|
|
if(idum1.eq.1.and.idum2.eq.1) then
|
|
nmixval(1,1) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.2) then
|
|
nmixval(1,2) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.3) then
|
|
nmixval(1,3) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.4) then
|
|
nmixval(1,4) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.1) then
|
|
nmixval(2,1) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.2) then
|
|
nmixval(2,2) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.3) then
|
|
nmixval(2,3) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.4) then
|
|
nmixval(2,4) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.1) then
|
|
nmixval(3,1) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.2) then
|
|
nmixval(3,2) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.3) then
|
|
nmixval(3,3) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.4) then
|
|
nmixval(3,4) = val
|
|
elseif(idum1.eq.4.and.idum2.eq.1) then
|
|
nmixval(4,1) = val
|
|
elseif(idum1.eq.4.and.idum2.eq.2) then
|
|
nmixval(4,2) = val
|
|
elseif(idum1.eq.4.and.idum2.eq.3) then
|
|
nmixval(4,3) = val
|
|
elseif(idum1.eq.4.and.idum2.eq.4) then
|
|
nmixval(4,4) = val
|
|
endif
|
|
|
|
elseif(line1.eq.'#') then
|
|
goto 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done = .true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_UMIX_HDEC(ninlha,umixval,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
double precision umixval(2,2)
|
|
character line1*1
|
|
logical done
|
|
|
|
done= .false.
|
|
|
|
do i=1,2,1
|
|
do j=1,2,1
|
|
umixval(i,j) = 0.D0
|
|
end do
|
|
end do
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,*) idum1,idum2,val
|
|
|
|
c -- the values for the chargino mixing matrix U --
|
|
if(idum1.eq.1.and.idum2.eq.1) then
|
|
umixval(1,1) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.2) then
|
|
umixval(1,2) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.1) then
|
|
umixval(2,1) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.2) then
|
|
umixval(2,2) = val
|
|
endif
|
|
|
|
elseif(line1.eq.'#') then
|
|
goto 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done = .true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_VMIX_HDEC(ninlha,vmixval,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
double precision vmixval(2,2)
|
|
character line1*1
|
|
logical done
|
|
|
|
done= .false.
|
|
|
|
do i=1,2,1
|
|
do j=1,2,1
|
|
vmixval(i,j) = 0.D0
|
|
end do
|
|
end do
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,*) idum1,idum2,val
|
|
|
|
c -- the values for the chargino mixing matrix V --
|
|
if(idum1.eq.1.and.idum2.eq.1) then
|
|
vmixval(1,1) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.2) then
|
|
vmixval(1,2) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.1) then
|
|
vmixval(2,1) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.2) then
|
|
vmixval(2,2) = val
|
|
endif
|
|
|
|
elseif(line1.eq.'#') then
|
|
goto 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done = .true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_STOPMIX_HDEC(ninlha,stopmixval,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
double precision stopmixval(2,2)
|
|
character line1*1
|
|
logical done
|
|
|
|
done= .false.
|
|
|
|
do i=1,2,1
|
|
do j=1,2,1
|
|
stopmixval(i,j) = 0.D0
|
|
end do
|
|
end do
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,*) idum1,idum2,val
|
|
|
|
c -- the values for the stop mixing matrix: m(1,1) = cos(theta), --
|
|
c -- m(1,2) = sin(theta), m(2,1) = -sin(theta), m(2,2) = cos(theta). --
|
|
if(idum1.eq.1.and.idum2.eq.1) then
|
|
stopmixval(1,1) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.2) then
|
|
stopmixval(1,2) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.1) then
|
|
stopmixval(2,1) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.2) then
|
|
stopmixval(2,2) = val
|
|
endif
|
|
|
|
elseif(line1.eq.'#') then
|
|
goto 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done = .true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_SBOTMIX_HDEC(ninlha,sbotmixval,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
double precision sbotmixval(2,2)
|
|
character line1*1
|
|
logical done
|
|
|
|
done= .false.
|
|
|
|
do i=1,2,1
|
|
do j=1,2,1
|
|
sbotmixval(i,j) = 0.D0
|
|
end do
|
|
end do
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,*) idum1,idum2,val
|
|
|
|
c -- the values for the sbottom mixing matrix: m(1,1) = cos(theta), --
|
|
c -- m(1,2) = sin(theta), m(2,1) = -sin(theta), m(2,2) = cos(theta). --
|
|
if(idum1.eq.1.and.idum2.eq.1) then
|
|
sbotmixval(1,1) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.2) then
|
|
sbotmixval(1,2) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.1) then
|
|
sbotmixval(2,1) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.2) then
|
|
sbotmixval(2,2) = val
|
|
endif
|
|
|
|
elseif(line1.eq.'#') then
|
|
goto 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done = .true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_STAUMIX_HDEC(ninlha,staumixval,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
double precision staumixval(2,2)
|
|
character line1*1
|
|
logical done
|
|
|
|
done= .false.
|
|
|
|
do i=1,2,1
|
|
do j=1,2,1
|
|
staumixval(i,j) = 0.D0
|
|
end do
|
|
end do
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,*) idum1,idum2,val
|
|
|
|
c -- the values for the stau mixing matrix: m(1,1) = cos(theta), --
|
|
c -- m(1,2) = sin(theta), m(2,1) = -sin(theta), m(2,2) = cos(theta). --
|
|
if(idum1.eq.1.and.idum2.eq.1) then
|
|
staumixval(1,1) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.2) then
|
|
staumixval(1,2) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.1) then
|
|
staumixval(2,1) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.2) then
|
|
staumixval(2,2) = val
|
|
endif
|
|
|
|
elseif(line1.eq.'#') then
|
|
goto 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done = .true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_ALPHA_HDEC(ninlha,alphaval,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
character line1*1
|
|
logical done
|
|
|
|
done= .false.
|
|
|
|
alphaval = 0.D0
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,*) val
|
|
|
|
c -- value for the effective Higgs mixing parameter alpha --
|
|
c -- ! The given value is the 'best choice' solution. Depending on ! --
|
|
c -- ! the spectrum calcluator it can be an on-shell parameter or ! --
|
|
c -- ! can be given in the DR_bar definition at a certain ! --
|
|
c -- ! characteristic scale etc. For details on the specific ! --
|
|
c -- ! prescriptions see the manual of the particular spectrum ! --
|
|
c -- ! calculator. ! --
|
|
alphaval = val
|
|
|
|
elseif(line1.eq.'#') then
|
|
goto 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done = .true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_HMIX_HDEC(ninlha,hmixval,hmixcom,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
double precision hmixval(1:10)
|
|
character line1*1,line2*1,line3*20,hmixcom(1:10)*20
|
|
logical done
|
|
|
|
done= .false.
|
|
|
|
do i=1,10,1
|
|
hmixcom(i) = ' '
|
|
end do
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,*) idum,val,line2,line3
|
|
|
|
do ii=1,10,1
|
|
if(idum.eq.ii) then
|
|
hmixval(ii) = val
|
|
hmixcom(ii) = line3
|
|
endif
|
|
end do
|
|
|
|
elseif(line1.eq.'#') then
|
|
goto 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done = .true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_GAUGE_HDEC(ninlha,gaugeval,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
double precision gaugeval(1:3)
|
|
character line1*1
|
|
logical done
|
|
|
|
done= .false.
|
|
|
|
do i=1,3,1
|
|
gaugeval(i) = 0.D0
|
|
end do
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,*) idum,val
|
|
|
|
c -- The following parameters are the DR_bar running parameters at --
|
|
c -- the scale Q. --
|
|
c -- value for g_prime at the scale Q --
|
|
if(idum.eq.1) then
|
|
gaugeval(1) = val
|
|
|
|
c -- value for g at the scale Q --
|
|
elseif(idum.eq.2) then
|
|
gaugeval(2) = val
|
|
|
|
c -- value for g3 at the scale Q --
|
|
elseif(idum.eq.3) then
|
|
gaugeval(3) = val
|
|
endif
|
|
|
|
elseif(line1.eq.'#') then
|
|
goto 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done = .true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_MSOFT_HDEC(ninlha,msoftval,softcom,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
double precision msoftval(1:100)
|
|
character line1*1,line2*1,line3*20,softcom(1:100)*20
|
|
logical done
|
|
|
|
done= .false.
|
|
|
|
do i=1,100,1
|
|
softcom(i) = ' '
|
|
end do
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,*) idum,val,line2,line3
|
|
|
|
do ii=1,100,1
|
|
if(idum.eq.ii) then
|
|
msoftval(ii) = val
|
|
softcom(ii) = line3
|
|
endif
|
|
end do
|
|
|
|
elseif(line1.eq.'#') then
|
|
goto 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done = .true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_AU_HDEC(ninlha,auval,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
double precision auval(3,3)
|
|
character line1*1
|
|
logical done
|
|
|
|
done= .false.
|
|
|
|
do i=1,3,1
|
|
do j=1,3,1
|
|
auval(i,j) = 0.D0
|
|
end do
|
|
end do
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,*) idum1,idum2,val
|
|
|
|
c -- The following parameters are the DR_bar running parameters at --
|
|
c -- the scale Q. --
|
|
c -- values for AU(i,j) at the scale Q --
|
|
if(idum1.eq.1.and.idum2.eq.1) then
|
|
auval(1,1) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.2) then
|
|
auval(1,2) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.3) then
|
|
auval(1,3) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.1) then
|
|
auval(2,1) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.2) then
|
|
auval(2,2) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.3) then
|
|
auval(2,3) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.1) then
|
|
auval(3,1) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.2) then
|
|
auval(3,2) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.3) then
|
|
auval(3,3) = val
|
|
endif
|
|
|
|
elseif(line1.eq.'#') then
|
|
goto 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done = .true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_AD_HDEC(ninlha,adval,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
double precision adval(3,3)
|
|
character line1*1
|
|
logical done
|
|
|
|
done= .false.
|
|
|
|
do i=1,3,1
|
|
do j=1,3,1
|
|
adval(i,j) = 0.D0
|
|
end do
|
|
end do
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,*) idum1,idum2,val
|
|
|
|
c -- The following parameters are the DR_bar running parameters at --
|
|
c -- the scale Q. --
|
|
c -- values for AD(i,j) at the scale Q --
|
|
if(idum1.eq.1.and.idum2.eq.1) then
|
|
adval(1,1) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.2) then
|
|
adval(1,2) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.3) then
|
|
adval(1,3) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.1) then
|
|
adval(2,1) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.2) then
|
|
adval(2,2) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.3) then
|
|
adval(2,3) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.1) then
|
|
adval(3,1) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.2) then
|
|
adval(3,2) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.3) then
|
|
adval(3,3) = val
|
|
endif
|
|
|
|
elseif(line1.eq.'#') then
|
|
goto 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done = .true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_AE_HDEC(ninlha,aeval,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
double precision aeval(3,3)
|
|
character line1*1
|
|
logical done
|
|
|
|
done= .false.
|
|
|
|
do i=1,3,1
|
|
do j=1,3,1
|
|
aeval(i,j) = 0.D0
|
|
end do
|
|
end do
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,*) idum1,idum2,val
|
|
|
|
c -- The following parameters are the DR_bar running parameters at --
|
|
c -- the scale Q. --
|
|
c -- values for AE(i,j) at the scale Q --
|
|
if(idum1.eq.1.and.idum2.eq.1) then
|
|
aeval(1,1) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.2) then
|
|
aeval(1,2) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.3) then
|
|
aeval(1,3) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.1) then
|
|
aeval(2,1) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.2) then
|
|
aeval(2,2) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.3) then
|
|
aeval(2,3) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.1) then
|
|
aeval(3,1) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.2) then
|
|
aeval(3,2) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.3) then
|
|
aeval(3,3) = val
|
|
endif
|
|
|
|
elseif(line1.eq.'#') then
|
|
goto 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done = .true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_YU_HDEC(ninlha,yuval,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
double precision yuval(3,3)
|
|
character line1*1
|
|
logical done
|
|
|
|
done= .false.
|
|
|
|
do i=1,3,1
|
|
do j=1,3,1
|
|
yuval(i,j) = 0.D0
|
|
end do
|
|
end do
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,*) idum1,idum2,val
|
|
|
|
c -- The following parameters are the DR_bar running parameters at --
|
|
c -- the scale Q. --
|
|
c -- values for YU(i,j) at the scale Q --
|
|
if(idum1.eq.1.and.idum2.eq.1) then
|
|
yuval(1,1) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.2) then
|
|
yuval(1,2) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.3) then
|
|
yuval(1,3) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.1) then
|
|
yuval(2,1) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.2) then
|
|
yuval(2,2) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.3) then
|
|
yuval(2,3) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.1) then
|
|
yuval(3,1) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.2) then
|
|
yuval(3,2) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.3) then
|
|
yuval(3,3) = val
|
|
endif
|
|
|
|
elseif(line1.eq.'#') then
|
|
goto 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done = .true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_YD_HDEC(ninlha,ydval,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
double precision ydval(3,3)
|
|
character line1*1
|
|
logical done
|
|
|
|
done= .false.
|
|
|
|
do i=1,3,1
|
|
do j=1,3,1
|
|
ydval(i,j) = 0.D0
|
|
end do
|
|
end do
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,*) idum1,idum2,val
|
|
|
|
c -- The following parameters are the DR_bar running parameters at --
|
|
c -- the scale Q. --
|
|
c -- values for YD(i,j) at the scale Q --
|
|
if(idum1.eq.1.and.idum2.eq.1) then
|
|
ydval(1,1) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.2) then
|
|
ydval(1,2) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.3) then
|
|
ydval(1,3) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.1) then
|
|
ydval(2,1) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.2) then
|
|
ydval(2,2) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.3) then
|
|
ydval(2,3) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.1) then
|
|
ydval(3,1) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.2) then
|
|
ydval(3,2) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.3) then
|
|
ydval(3,3) = val
|
|
endif
|
|
|
|
elseif(line1.eq.'#') then
|
|
goto 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done = .true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_YE_HDEC(ninlha,yeval,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
double precision yeval(3,3)
|
|
character line1*1
|
|
logical done
|
|
|
|
done= .false.
|
|
|
|
do i=1,3,1
|
|
do j=1,3,1
|
|
yeval(i,j) = 0.D0
|
|
end do
|
|
end do
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,*) idum1,idum2,val
|
|
|
|
c -- The following parameters are the DR_bar running parameters at --
|
|
c -- the scale Q. --
|
|
c -- values for YE(i,j) at the scale Q --
|
|
if(idum1.eq.1.and.idum2.eq.1) then
|
|
yeval(1,1) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.2) then
|
|
yeval(1,2) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.3) then
|
|
yeval(1,3) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.1) then
|
|
yeval(2,1) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.2) then
|
|
yeval(2,2) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.3) then
|
|
yeval(2,3) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.1) then
|
|
yeval(3,1) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.2) then
|
|
yeval(3,2) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.3) then
|
|
yeval(3,3) = val
|
|
endif
|
|
|
|
elseif(line1.eq.'#') then
|
|
goto 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done = .true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_SPINFO_HDEC(ninlha,spinfo1,spinfo2,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
character line1*1,line2*100,spinfo1*100,spinfo2*100
|
|
logical done
|
|
|
|
done= .false.
|
|
|
|
spinfo1 = ' '
|
|
spinfo2 = ' '
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,'(1x,i5,3x,a100)') idum,line2
|
|
|
|
c -- the name of the spectrum calculator --
|
|
if(idum.eq.1) then
|
|
spinfo1 = line2
|
|
|
|
c -- the version number of the spectrum calculator --
|
|
elseif(idum.eq.2) then
|
|
spinfo2 = line2
|
|
endif
|
|
|
|
elseif(line1.eq.'#') then
|
|
goto 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done = .true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_TUIN_HDEC(ninlha,auval,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
double precision auval(3,3)
|
|
character line1*1
|
|
logical done
|
|
|
|
done= .false.
|
|
|
|
do i=1,3,1
|
|
do j=1,3,1
|
|
auval(i,j) = 0.D0
|
|
end do
|
|
end do
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,*) idum1,idum2,val
|
|
|
|
c -- The following parameters are the DR_bar running parameters at --
|
|
c -- the scale Q. --
|
|
c -- values for AU(i,j) at the scale Q --
|
|
if(idum1.eq.1.and.idum2.eq.1) then
|
|
auval(1,1) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.2) then
|
|
auval(1,2) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.3) then
|
|
auval(1,3) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.1) then
|
|
auval(2,1) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.2) then
|
|
auval(2,2) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.3) then
|
|
auval(2,3) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.1) then
|
|
auval(3,1) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.2) then
|
|
auval(3,2) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.3) then
|
|
auval(3,3) = val
|
|
endif
|
|
|
|
elseif(line1.eq.'#') then
|
|
goto 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done = .true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_TDIN_HDEC(ninlha,adval,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
double precision adval(3,3)
|
|
character line1*1
|
|
logical done
|
|
|
|
done= .false.
|
|
|
|
do i=1,3,1
|
|
do j=1,3,1
|
|
adval(i,j) = 0.D0
|
|
end do
|
|
end do
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,*) idum1,idum2,val
|
|
|
|
c -- The following parameters are the DR_bar running parameters at --
|
|
c -- the scale Q. --
|
|
c -- values for AD(i,j) at the scale Q --
|
|
if(idum1.eq.1.and.idum2.eq.1) then
|
|
adval(1,1) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.2) then
|
|
adval(1,2) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.3) then
|
|
adval(1,3) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.1) then
|
|
adval(2,1) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.2) then
|
|
adval(2,2) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.3) then
|
|
adval(2,3) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.1) then
|
|
adval(3,1) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.2) then
|
|
adval(3,2) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.3) then
|
|
adval(3,3) = val
|
|
endif
|
|
|
|
elseif(line1.eq.'#') then
|
|
goto 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done = .true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_TEIN_HDEC(ninlha,aeval,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
double precision aeval(3,3)
|
|
character line1*1
|
|
logical done
|
|
|
|
done= .false.
|
|
|
|
do i=1,3,1
|
|
do j=1,3,1
|
|
aeval(i,j) = 0.D0
|
|
end do
|
|
end do
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,*) idum1,idum2,val
|
|
|
|
c -- The following parameters are the DR_bar running parameters at --
|
|
c -- the scale Q. --
|
|
c -- values for AE(i,j) at the scale Q --
|
|
if(idum1.eq.1.and.idum2.eq.1) then
|
|
aeval(1,1) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.2) then
|
|
aeval(1,2) = val
|
|
elseif(idum1.eq.1.and.idum2.eq.3) then
|
|
aeval(1,3) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.1) then
|
|
aeval(2,1) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.2) then
|
|
aeval(2,2) = val
|
|
elseif(idum1.eq.2.and.idum2.eq.3) then
|
|
aeval(2,3) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.1) then
|
|
aeval(3,1) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.2) then
|
|
aeval(3,2) = val
|
|
elseif(idum1.eq.3.and.idum2.eq.3) then
|
|
aeval(3,3) = val
|
|
endif
|
|
|
|
elseif(line1.eq.'#') then
|
|
goto 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done = .true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
c -------------------------------------------------------------------- c
|
|
|
|
subroutine SLHA_READ_VCKMIN_HDEC(ninlha,vckmval,done)
|
|
|
|
implicit double precision (a-h,m,o-z)
|
|
double precision vckmval(4)
|
|
character line1*1
|
|
logical done
|
|
|
|
done=.false.
|
|
|
|
do i=1,4,1
|
|
vckmval(i) = 0.D0
|
|
end do
|
|
|
|
do i=1,200,1
|
|
read(ninlha,'(a1)',end=9900) line1
|
|
|
|
c -- decide what it is and read the line if anything of interest --
|
|
if (line1.eq.' ') then
|
|
backspace ninlha
|
|
read(ninlha,*) idum,val
|
|
|
|
c -- lambda
|
|
if(idum.eq.1) then
|
|
vckmval(1) = val
|
|
c -- A
|
|
elseif(idum.eq.2) then
|
|
vckmval(2) = val
|
|
c -- rhobar
|
|
elseif(idum.eq.3) then
|
|
vckmval(3) = val
|
|
c -- etabar
|
|
elseif(idum.eq.4) then
|
|
vckmval(4) = val
|
|
endif
|
|
|
|
elseif(line1.eq.'#') then
|
|
go to 1111
|
|
elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
|
|
..'D') then
|
|
backspace ninlha
|
|
done =.true.
|
|
return
|
|
endif
|
|
|
|
1111 continue
|
|
end do
|
|
|
|
9900 print*,'SLHA_read_leshouches: end of file'
|
|
done = .true.
|
|
|
|
end
|
|
|
|
|
|
subroutine readQval(ninlha,Qval)
|
|
character buff*100
|
|
integer ninlha,i
|
|
real*8 Qval
|
|
backspace ninlha
|
|
read(ninlha,fmt='(A100)') buff
|
|
do i=1,100
|
|
if(buff(i:i).eq.'=') then
|
|
read(buff(i+1:100),*) Qval
|
|
return
|
|
endif
|
|
enddo
|
|
end
|