Page MenuHomeHEPForge
Files F11222536

No OneTemporary
Actions

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.
diff --git a/Cards/HiggsBasis.dat b/Cards/HiggsBasis.dat
index 3e6e7ef..cc9d5db 100644
--- a/Cards/HiggsBasis.dat
+++ b/Cards/HiggsBasis.dat
@@ -1,633 +1,621 @@
################################################################################
####################### ROSETTA: HIGGS BASIS INPUT CARD ########################
-###################### GENERATED FRI AUG 14 09:12:39 2015 ######################
+###################### GENERATED THU AUG 20 17:15:38 2015 ######################
################################################################################
BLOCK mass #
- 1 +4.80000e-03 # Mu
- 2 +2.30000e-03 # Md
- 3 +9.50000e-02 # Ms
- 4 +1.42000e+00 # Mc
- 5 +4.70000e+00 # Mb
- 6 +1.73000e+02 # Mt
- 11 +5.11000e-04 # Me
- 12 +0.00000e+00 # Mve
- 13 +1.05658e-01 # Mmu
- 14 +0.00000e+00 # Mvmu
- 15 +1.77680e+00 # Mta
- 16 +0.00000e+00 # Mvta
25 +1.25000e+02 # MH
BLOCK sminputs #
1 +1.32507e+02 # aEWM1
2 +1.16639e-05 # Gf
3 +1.18000e-01 # aS
4 +9.11880e+01 # MZ
###################################
## CKM INFORMATION
###################################
BLOCK VCKM
1 1 +9.74272e-01 # RVud1x1
1 2 +2.25349e-01 # RVus1x2
1 3 +1.21581e-03 # RVub1x3
2 1 -2.25208e-01 # RVcd2x1
2 2 +9.73440e-01 # RVcs2x2
2 3 +4.11845e-02 # RVcb2x3
3 1 +8.09744e-03 # RVtd3x1
3 2 -4.03991e-02 # RVts3x2
3 3 +9.99146e-01 # RVtb3x3
BLOCK IMVCKM
1 1 +0.00000e+00 # IVud1x1
1 2 +0.00000e+00 # IVus1x2
1 3 -3.20194e-03 # IVub1x3
2 1 -1.28479e-04 # IVcd2x1
2 2 -2.97171e-05 # IVcs2x2
2 3 +0.00000e+00 # IVcb2x3
3 1 -3.11693e-03 # IVtd3x1
3 2 -7.20944e-04 # IVts3x2
3 3 +0.00000e+00 # IVtb3x3
###################################
## INFORMATION FOR HIGGS BASIS
###################################
BLOCK basis #
1 higgs # translated basis
BLOCK HBx4F #
1 +0.00000e+00 # cll1122
2 +0.00000e+00 # cpuu3333
BLOCK HBxh #
1 +0.00000e+00 # dCz
2 +0.00000e+00 # Cgg
3 +0.00000e+00 # Caa
4 +0.00000e+00 # Cza
5 +0.00000e+00 # Czz
6 +0.00000e+00 # Czbx
8 +0.00000e+00 # tCgg
9 +0.00000e+00 # tCaa
10 +0.00000e+00 # tCza
11 +0.00000e+00 # tCzz
BLOCK HBxhself #
1 +0.00000e+00 # dL3
BLOCK HBxMASS #
1 +0.00000e+00 # dM
BLOCK HBxTGC #
1 +0.00000e+00 # Lz
2 +0.00000e+00 # tLz
3 +0.00000e+00 # C3g
4 +0.00000e+00 # tC3g
BLOCK HBxdad
1 1 +0.00000e+00 # Rdad1x1
1 2 +0.00000e+00 # Rdad1x2
1 3 +0.00000e+00 # Rdad1x3
2 2 +0.00000e+00 # Rdad2x2
2 3 +0.00000e+00 # Rdad2x3
3 3 +0.00000e+00 # Rdad3x3
BLOCK IMHBxdad
1 1 +0.00000e+00 # Idad1x1
1 2 +0.00000e+00 # Idad1x2
1 3 +0.00000e+00 # Idad1x3
2 2 +0.00000e+00 # Idad2x2
2 3 +0.00000e+00 # Idad2x3
3 3 +0.00000e+00 # Idad3x3
BLOCK HBxdae
1 1 +0.00000e+00 # Rdae1x1
1 2 +0.00000e+00 # Rdae1x2
1 3 +0.00000e+00 # Rdae1x3
2 2 +0.00000e+00 # Rdae2x2
2 3 +0.00000e+00 # Rdae2x3
3 3 +0.00000e+00 # Rdae3x3
BLOCK IMHBxdae
1 1 +0.00000e+00 # Idae1x1
1 2 +0.00000e+00 # Idae1x2
1 3 +0.00000e+00 # Idae1x3
2 2 +0.00000e+00 # Idae2x2
2 3 +0.00000e+00 # Idae2x3
3 3 +0.00000e+00 # Idae3x3
BLOCK HBxdau
1 1 +0.00000e+00 # Rdau1x1
1 2 +0.00000e+00 # Rdau1x2
1 3 +0.00000e+00 # Rdau1x3
2 2 +0.00000e+00 # Rdau2x2
2 3 +0.00000e+00 # Rdau2x3
3 3 +0.00000e+00 # Rdau3x3
BLOCK IMHBxdau
1 1 +0.00000e+00 # Idau1x1
1 2 +0.00000e+00 # Idau1x2
1 3 +0.00000e+00 # Idau1x3
2 2 +0.00000e+00 # Idau2x2
2 3 +0.00000e+00 # Idau2x3
3 3 +0.00000e+00 # Idau3x3
BLOCK HBxdgd
1 1 +0.00000e+00 # Rdgd1x1
1 2 +0.00000e+00 # Rdgd1x2
1 3 +0.00000e+00 # Rdgd1x3
2 2 +0.00000e+00 # Rdgd2x2
2 3 +0.00000e+00 # Rdgd2x3
3 3 +0.00000e+00 # Rdgd3x3
BLOCK IMHBxdgd
1 1 +0.00000e+00 # Idgd1x1
1 2 +0.00000e+00 # Idgd1x2
1 3 +0.00000e+00 # Idgd1x3
2 2 +0.00000e+00 # Idgd2x2
2 3 +0.00000e+00 # Idgd2x3
3 3 +0.00000e+00 # Idgd3x3
BLOCK HBxdGLwl
1 1 +0.00000e+00 # RdGLwl1x1
1 2 +0.00000e+00 # RdGLwl1x2
1 3 +0.00000e+00 # RdGLwl1x3
2 2 +0.00000e+00 # RdGLwl2x2
2 3 +0.00000e+00 # RdGLwl2x3
3 3 +0.00000e+00 # RdGLwl3x3
BLOCK IMHBxdGLwl
1 1 +0.00000e+00 # IdGLwl1x1
1 2 +0.00000e+00 # IdGLwl1x2
1 3 +0.00000e+00 # IdGLwl1x3
2 2 +0.00000e+00 # IdGLwl2x2
2 3 +0.00000e+00 # IdGLwl2x3
3 3 +0.00000e+00 # IdGLwl3x3
BLOCK HBxdGLzd
1 1 +0.00000e+00 # RdGLzd1x1
1 2 +0.00000e+00 # RdGLzd1x2
1 3 +0.00000e+00 # RdGLzd1x3
2 2 +0.00000e+00 # RdGLzd2x2
2 3 +0.00000e+00 # RdGLzd2x3
3 3 +0.00000e+00 # RdGLzd3x3
BLOCK IMHBxdGLzd
1 1 +0.00000e+00 # IdGLzd1x1
1 2 +0.00000e+00 # IdGLzd1x2
1 3 +0.00000e+00 # IdGLzd1x3
2 2 +0.00000e+00 # IdGLzd2x2
2 3 +0.00000e+00 # IdGLzd2x3
3 3 +0.00000e+00 # IdGLzd3x3
BLOCK HBxdGLze
1 1 +0.00000e+00 # RdGLze1x1
1 2 +0.00000e+00 # RdGLze1x2
1 3 +0.00000e+00 # RdGLze1x3
2 2 +0.00000e+00 # RdGLze2x2
2 3 +0.00000e+00 # RdGLze2x3
3 3 +0.00000e+00 # RdGLze3x3
BLOCK IMHBxdGLze
1 1 +0.00000e+00 # IdGLze1x1
1 2 +0.00000e+00 # IdGLze1x2
1 3 +0.00000e+00 # IdGLze1x3
2 2 +0.00000e+00 # IdGLze2x2
2 3 +0.00000e+00 # IdGLze2x3
3 3 +0.00000e+00 # IdGLze3x3
BLOCK HBxdGLzu
1 1 +0.00000e+00 # RdGLzu1x1
1 2 +0.00000e+00 # RdGLzu1x2
1 3 +0.00000e+00 # RdGLzu1x3
2 2 +0.00000e+00 # RdGLzu2x2
2 3 +0.00000e+00 # RdGLzu2x3
3 3 +0.00000e+00 # RdGLzu3x3
BLOCK IMHBxdGLzu
1 1 +0.00000e+00 # IdGLzu1x1
1 2 +0.00000e+00 # IdGLzu1x2
1 3 +0.00000e+00 # IdGLzu1x3
2 2 +0.00000e+00 # IdGLzu2x2
2 3 +0.00000e+00 # IdGLzu2x3
3 3 +0.00000e+00 # IdGLzu3x3
BLOCK HBxdGRwq
1 1 +0.00000e+00 # RdGRwq1x1
1 2 +0.00000e+00 # RdGRwq1x2
1 3 +0.00000e+00 # RdGRwq1x3
2 1 +0.00000e+00 # RdGRwq2x1
2 2 +0.00000e+00 # RdGRwq2x2
2 3 +0.00000e+00 # RdGRwq2x3
3 1 +0.00000e+00 # RdGRwq3x1
3 2 +0.00000e+00 # RdGRwq3x2
3 3 +0.00000e+00 # RdGRwq3x3
BLOCK IMHBxdGRwq
1 1 +0.00000e+00 # IdGRwq1x1
1 2 +0.00000e+00 # IdGRwq1x2
1 3 +0.00000e+00 # IdGRwq1x3
2 1 +0.00000e+00 # IdGRwq2x1
2 2 +0.00000e+00 # IdGRwq2x2
2 3 +0.00000e+00 # IdGRwq2x3
3 1 +0.00000e+00 # IdGRwq3x1
3 2 +0.00000e+00 # IdGRwq3x2
3 3 +0.00000e+00 # IdGRwq3x3
BLOCK HBxdGRzd
1 1 +0.00000e+00 # RdGRzd1x1
1 2 +0.00000e+00 # RdGRzd1x2
1 3 +0.00000e+00 # RdGRzd1x3
2 2 +0.00000e+00 # RdGRzd2x2
2 3 +0.00000e+00 # RdGRzd2x3
3 3 +0.00000e+00 # RdGRzd3x3
BLOCK IMHBxdGRzd
1 1 +0.00000e+00 # IdGRzd1x1
1 2 +0.00000e+00 # IdGRzd1x2
1 3 +0.00000e+00 # IdGRzd1x3
2 2 +0.00000e+00 # IdGRzd2x2
2 3 +0.00000e+00 # IdGRzd2x3
3 3 +0.00000e+00 # IdGRzd3x3
BLOCK HBxdGRze
1 1 +0.00000e+00 # RdGRze1x1
1 2 +0.00000e+00 # RdGRze1x2
1 3 +0.00000e+00 # RdGRze1x3
2 2 +0.00000e+00 # RdGRze2x2
2 3 +0.00000e+00 # RdGRze2x3
3 3 +0.00000e+00 # RdGRze3x3
BLOCK IMHBxdGRze
1 1 +0.00000e+00 # IdGRze1x1
1 2 +0.00000e+00 # IdGRze1x2
1 3 +0.00000e+00 # IdGRze1x3
2 2 +0.00000e+00 # IdGRze2x2
2 3 +0.00000e+00 # IdGRze2x3
3 3 +0.00000e+00 # IdGRze3x3
BLOCK HBxdGRzu
1 1 +0.00000e+00 # RdGRzu1x1
1 2 +0.00000e+00 # RdGRzu1x2
1 3 +0.00000e+00 # RdGRzu1x3
2 2 +0.00000e+00 # RdGRzu2x2
2 3 +0.00000e+00 # RdGRzu2x3
3 3 +0.00000e+00 # RdGRzu3x3
BLOCK IMHBxdGRzu
1 1 +0.00000e+00 # IdGRzu1x1
1 2 +0.00000e+00 # IdGRzu1x2
1 3 +0.00000e+00 # IdGRzu1x3
2 2 +0.00000e+00 # IdGRzu2x2
2 3 +0.00000e+00 # IdGRzu2x3
3 3 +0.00000e+00 # IdGRzu3x3
BLOCK HBxdgu
1 1 +0.00000e+00 # Rdgu1x1
1 2 +0.00000e+00 # Rdgu1x2
1 3 +0.00000e+00 # Rdgu1x3
2 2 +0.00000e+00 # Rdgu2x2
2 3 +0.00000e+00 # Rdgu2x3
3 3 +0.00000e+00 # Rdgu3x3
BLOCK IMHBxdgu
1 1 +0.00000e+00 # Idgu1x1
1 2 +0.00000e+00 # Idgu1x2
1 3 +0.00000e+00 # Idgu1x3
2 2 +0.00000e+00 # Idgu2x2
2 3 +0.00000e+00 # Idgu2x3
3 3 +0.00000e+00 # Idgu3x3
BLOCK HBxdwl
1 1 +0.00000e+00 # Rdwl1x1
1 2 +0.00000e+00 # Rdwl1x2
1 3 +0.00000e+00 # Rdwl1x3
2 1 +0.00000e+00 # Rdwl2x1
2 2 +0.00000e+00 # Rdwl2x2
2 3 +0.00000e+00 # Rdwl2x3
3 1 +0.00000e+00 # Rdwl3x1
3 2 +0.00000e+00 # Rdwl3x2
3 3 +0.00000e+00 # Rdwl3x3
BLOCK IMHBxdwl
1 1 +0.00000e+00 # Idwl1x1
1 2 +0.00000e+00 # Idwl1x2
1 3 +0.00000e+00 # Idwl1x3
2 1 +0.00000e+00 # Idwl2x1
2 2 +0.00000e+00 # Idwl2x2
2 3 +0.00000e+00 # Idwl2x3
3 1 +0.00000e+00 # Idwl3x1
3 2 +0.00000e+00 # Idwl3x2
3 3 +0.00000e+00 # Idwl3x3
BLOCK HBxdwq
1 1 +0.00000e+00 # Rdwq1x1
1 2 +0.00000e+00 # Rdwq1x2
1 3 +0.00000e+00 # Rdwq1x3
2 1 +0.00000e+00 # Rdwq2x1
2 2 +0.00000e+00 # Rdwq2x2
2 3 +0.00000e+00 # Rdwq2x3
3 1 +0.00000e+00 # Rdwq3x1
3 2 +0.00000e+00 # Rdwq3x2
3 3 +0.00000e+00 # Rdwq3x3
BLOCK IMHBxdwq
1 1 +0.00000e+00 # Idwq1x1
1 2 +0.00000e+00 # Idwq1x2
1 3 +0.00000e+00 # Idwq1x3
2 1 +0.00000e+00 # Idwq2x1
2 2 +0.00000e+00 # Idwq2x2
2 3 +0.00000e+00 # Idwq2x3
3 1 +0.00000e+00 # Idwq3x1
3 2 +0.00000e+00 # Idwq3x2
3 3 +0.00000e+00 # Idwq3x3
BLOCK HBxdYd
1 1 +0.00000e+00 # dYd1x1
1 2 +0.00000e+00 # dYd1x2
1 3 +0.00000e+00 # dYd1x3
2 1 +0.00000e+00 # dYd2x1
2 2 +0.00000e+00 # dYd2x2
2 3 +0.00000e+00 # dYd2x3
3 1 +0.00000e+00 # dYd3x1
3 2 +0.00000e+00 # dYd3x2
3 3 +0.00000e+00 # dYd3x3
BLOCK HBxdYe
1 1 +0.00000e+00 # dYe1x1
1 2 +0.00000e+00 # dYe1x2
1 3 +0.00000e+00 # dYe1x3
2 1 +0.00000e+00 # dYe2x1
2 2 +0.00000e+00 # dYe2x2
2 3 +0.00000e+00 # dYe2x3
3 1 +0.00000e+00 # dYe3x1
3 2 +0.00000e+00 # dYe3x2
3 3 +0.00000e+00 # dYe3x3
BLOCK HBxdYu
1 1 +0.00000e+00 # dYu1x1
1 2 +0.00000e+00 # dYu1x2
1 3 +0.00000e+00 # dYu1x3
2 1 +0.00000e+00 # dYu2x1
2 2 +0.00000e+00 # dYu2x2
2 3 +0.00000e+00 # dYu2x3
3 1 +0.00000e+00 # dYu3x1
3 2 +0.00000e+00 # dYu3x2
3 3 +0.00000e+00 # dYu3x3
BLOCK HBxdzd
1 1 +0.00000e+00 # Rdzd1x1
1 2 +0.00000e+00 # Rdzd1x2
1 3 +0.00000e+00 # Rdzd1x3
2 2 +0.00000e+00 # Rdzd2x2
2 3 +0.00000e+00 # Rdzd2x3
3 3 +0.00000e+00 # Rdzd3x3
BLOCK IMHBxdzd
1 1 +0.00000e+00 # Idzd1x1
1 2 +0.00000e+00 # Idzd1x2
1 3 +0.00000e+00 # Idzd1x3
2 2 +0.00000e+00 # Idzd2x2
2 3 +0.00000e+00 # Idzd2x3
3 3 +0.00000e+00 # Idzd3x3
BLOCK HBxdze
1 1 +0.00000e+00 # Rdze1x1
1 2 +0.00000e+00 # Rdze1x2
1 3 +0.00000e+00 # Rdze1x3
2 2 +0.00000e+00 # Rdze2x2
2 3 +0.00000e+00 # Rdze2x3
3 3 +0.00000e+00 # Rdze3x3
BLOCK IMHBxdze
1 1 +0.00000e+00 # Idze1x1
1 2 +0.00000e+00 # Idze1x2
1 3 +0.00000e+00 # Idze1x3
2 2 +0.00000e+00 # Idze2x2
2 3 +0.00000e+00 # Idze2x3
3 3 +0.00000e+00 # Idze3x3
BLOCK HBxdzu
1 1 +0.00000e+00 # Rdzu1x1
1 2 +0.00000e+00 # Rdzu1x2
1 3 +0.00000e+00 # Rdzu1x3
2 2 +0.00000e+00 # Rdzu2x2
2 3 +0.00000e+00 # Rdzu2x3
3 3 +0.00000e+00 # Rdzu3x3
BLOCK IMHBxdzu
1 1 +0.00000e+00 # Idzu1x1
1 2 +0.00000e+00 # Idzu1x2
1 3 +0.00000e+00 # Idzu1x3
2 2 +0.00000e+00 # Idzu2x2
2 3 +0.00000e+00 # Idzu2x3
3 3 +0.00000e+00 # Idzu3x3
BLOCK HBxSd
1 1 +0.00000e+00 # Sd1x1
1 2 +0.00000e+00 # Sd1x2
1 3 +0.00000e+00 # Sd1x3
2 1 +0.00000e+00 # Sd2x1
2 2 +0.00000e+00 # Sd2x2
2 3 +0.00000e+00 # Sd2x3
3 1 +0.00000e+00 # Sd3x1
3 2 +0.00000e+00 # Sd3x2
3 3 +0.00000e+00 # Sd3x3
BLOCK HBxSe
1 1 +0.00000e+00 # Se1x1
1 2 +0.00000e+00 # Se1x2
1 3 +0.00000e+00 # Se1x3
2 1 +0.00000e+00 # Se2x1
2 2 +0.00000e+00 # Se2x2
2 3 +0.00000e+00 # Se2x3
3 1 +0.00000e+00 # Se3x1
3 2 +0.00000e+00 # Se3x2
3 3 +0.00000e+00 # Se3x3
BLOCK HBxSu
1 1 +0.00000e+00 # Su1x1
1 2 +0.00000e+00 # Su1x2
1 3 +0.00000e+00 # Su1x3
2 1 +0.00000e+00 # Su2x1
2 2 +0.00000e+00 # Su2x2
2 3 +0.00000e+00 # Su2x3
3 1 +0.00000e+00 # Su3x1
3 2 +0.00000e+00 # Su3x2
3 3 +0.00000e+00 # Su3x3
BLOCK HBxtdad
1 1 +0.00000e+00 # Rtdad1x1
1 2 +0.00000e+00 # Rtdad1x2
1 3 +0.00000e+00 # Rtdad1x3
2 2 +0.00000e+00 # Rtdad2x2
2 3 +0.00000e+00 # Rtdad2x3
3 3 +0.00000e+00 # Rtdad3x3
BLOCK IMHBxtdad
1 1 +0.00000e+00 # Itdad1x1
1 2 +0.00000e+00 # Itdad1x2
1 3 +0.00000e+00 # Itdad1x3
2 2 +0.00000e+00 # Itdad2x2
2 3 +0.00000e+00 # Itdad2x3
3 3 +0.00000e+00 # Itdad3x3
BLOCK HBxtdae
1 1 +0.00000e+00 # Rtdae1x1
1 2 +0.00000e+00 # Rtdae1x2
1 3 +0.00000e+00 # Rtdae1x3
2 2 +0.00000e+00 # Rtdae2x2
2 3 +0.00000e+00 # Rtdae2x3
3 3 +0.00000e+00 # Rtdae3x3
BLOCK IMHBxtdae
1 1 +0.00000e+00 # Itdae1x1
1 2 +0.00000e+00 # Itdae1x2
1 3 +0.00000e+00 # Itdae1x3
2 2 +0.00000e+00 # Itdae2x2
2 3 +0.00000e+00 # Itdae2x3
3 3 +0.00000e+00 # Itdae3x3
BLOCK HBxtdau
1 1 +0.00000e+00 # Rtdau1x1
1 2 +0.00000e+00 # Rtdau1x2
1 3 +0.00000e+00 # Rtdau1x3
2 2 +0.00000e+00 # Rtdau2x2
2 3 +0.00000e+00 # Rtdau2x3
3 3 +0.00000e+00 # Rtdau3x3
BLOCK IMHBxtdau
1 1 +0.00000e+00 # Itdau1x1
1 2 +0.00000e+00 # Itdau1x2
1 3 +0.00000e+00 # Itdau1x3
2 2 +0.00000e+00 # Itdau2x2
2 3 +0.00000e+00 # Itdau2x3
3 3 +0.00000e+00 # Itdau3x3
BLOCK HBxtdgd
1 1 +0.00000e+00 # Rtdgd1x1
1 2 +0.00000e+00 # Rtdgd1x2
1 3 +0.00000e+00 # Rtdgd1x3
2 2 +0.00000e+00 # Rtdgd2x2
2 3 +0.00000e+00 # Rtdgd2x3
3 3 +0.00000e+00 # Rtdgd3x3
BLOCK IMHBxtdgd
1 1 +0.00000e+00 # Itdgd1x1
1 2 +0.00000e+00 # Itdgd1x2
1 3 +0.00000e+00 # Itdgd1x3
2 2 +0.00000e+00 # Itdgd2x2
2 3 +0.00000e+00 # Itdgd2x3
3 3 +0.00000e+00 # Itdgd3x3
BLOCK HBxtdgu
1 1 +0.00000e+00 # Rtdgu1x1
1 2 +0.00000e+00 # Rtdgu1x2
1 3 +0.00000e+00 # Rtdgu1x3
2 2 +0.00000e+00 # Rtdgu2x2
2 3 +0.00000e+00 # Rtdgu2x3
3 3 +0.00000e+00 # Rtdgu3x3
BLOCK IMHBxtdgu
1 1 +0.00000e+00 # Itdgu1x1
1 2 +0.00000e+00 # Itdgu1x2
1 3 +0.00000e+00 # Itdgu1x3
2 2 +0.00000e+00 # Itdgu2x2
2 3 +0.00000e+00 # Itdgu2x3
3 3 +0.00000e+00 # Itdgu3x3
BLOCK HBxtdwl
1 1 +0.00000e+00 # Rtdwl1x1
1 2 +0.00000e+00 # Rtdwl1x2
1 3 +0.00000e+00 # Rtdwl1x3
2 1 +0.00000e+00 # Rtdwl2x1
2 2 +0.00000e+00 # Rtdwl2x2
2 3 +0.00000e+00 # Rtdwl2x3
3 1 +0.00000e+00 # Rtdwl3x1
3 2 +0.00000e+00 # Rtdwl3x2
3 3 +0.00000e+00 # Rtdwl3x3
BLOCK IMHBxtdwl
1 1 +0.00000e+00 # Itdwl1x1
1 2 +0.00000e+00 # Itdwl1x2
1 3 +0.00000e+00 # Itdwl1x3
2 1 +0.00000e+00 # Itdwl2x1
2 2 +0.00000e+00 # Itdwl2x2
2 3 +0.00000e+00 # Itdwl2x3
3 1 +0.00000e+00 # Itdwl3x1
3 2 +0.00000e+00 # Itdwl3x2
3 3 +0.00000e+00 # Itdwl3x3
BLOCK HBxtdwq
1 1 +0.00000e+00 # Rtdwq1x1
1 2 +0.00000e+00 # Rtdwq1x2
1 3 +0.00000e+00 # Rtdwq1x3
2 1 +0.00000e+00 # Rtdwq2x1
2 2 +0.00000e+00 # Rtdwq2x2
2 3 +0.00000e+00 # Rtdwq2x3
3 1 +0.00000e+00 # Rtdwq3x1
3 2 +0.00000e+00 # Rtdwq3x2
3 3 +0.00000e+00 # Rtdwq3x3
BLOCK IMHBxtdwq
1 1 +0.00000e+00 # Itdwq1x1
1 2 +0.00000e+00 # Itdwq1x2
1 3 +0.00000e+00 # Itdwq1x3
2 1 +0.00000e+00 # Itdwq2x1
2 2 +0.00000e+00 # Itdwq2x2
2 3 +0.00000e+00 # Itdwq2x3
3 1 +0.00000e+00 # Itdwq3x1
3 2 +0.00000e+00 # Itdwq3x2
3 3 +0.00000e+00 # Itdwq3x3
BLOCK HBxtdzd
1 1 +0.00000e+00 # Rtdzd1x1
1 2 +0.00000e+00 # Rtdzd1x2
1 3 +0.00000e+00 # Rtdzd1x3
2 2 +0.00000e+00 # Rtdzd2x2
2 3 +0.00000e+00 # Rtdzd2x3
3 3 +0.00000e+00 # Rtdzd3x3
BLOCK IMHBxtdzd
1 1 +0.00000e+00 # Itdzd1x1
1 2 +0.00000e+00 # Itdzd1x2
1 3 +0.00000e+00 # Itdzd1x3
2 2 +0.00000e+00 # Itdzd2x2
2 3 +0.00000e+00 # Itdzd2x3
3 3 +0.00000e+00 # Itdzd3x3
BLOCK HBxtdze
1 1 +0.00000e+00 # Rtdze1x1
1 2 +0.00000e+00 # Rtdze1x2
1 3 +0.00000e+00 # Rtdze1x3
2 2 +0.00000e+00 # Rtdze2x2
2 3 +0.00000e+00 # Rtdze2x3
3 3 +0.00000e+00 # Rtdze3x3
BLOCK IMHBxtdze
1 1 +0.00000e+00 # Itdze1x1
1 2 +0.00000e+00 # Itdze1x2
1 3 +0.00000e+00 # Itdze1x3
2 2 +0.00000e+00 # Itdze2x2
2 3 +0.00000e+00 # Itdze2x3
3 3 +0.00000e+00 # Itdze3x3
BLOCK HBxtdzu
1 1 +0.00000e+00 # Rtdzu1x1
1 2 +0.00000e+00 # Rtdzu1x2
1 3 +0.00000e+00 # Rtdzu1x3
2 2 +0.00000e+00 # Rtdzu2x2
2 3 +0.00000e+00 # Rtdzu2x3
3 3 +0.00000e+00 # Rtdzu3x3
BLOCK IMHBxtdzu
1 1 +0.00000e+00 # Itdzu1x1
1 2 +0.00000e+00 # Itdzu1x2
1 3 +0.00000e+00 # Itdzu1x3
2 2 +0.00000e+00 # Itdzu2x2
2 3 +0.00000e+00 # Itdzu2x3
3 3 +0.00000e+00 # Itdzu3x3
################################################################################
################################################################################
\ No newline at end of file
diff --git a/Cards/HiggsBasis_diagonal.dat b/Cards/HiggsBasis_diagonal.dat
index 671d86c..331e7b8 100644
--- a/Cards/HiggsBasis_diagonal.dat
+++ b/Cards/HiggsBasis_diagonal.dat
@@ -1,399 +1,387 @@
################################################################################
####################### ROSETTA: HIGGS BASIS INPUT CARD ########################
-###################### GENERATED FRI AUG 14 09:12:52 2015 ######################
+###################### GENERATED THU AUG 20 17:15:28 2015 ######################
################################################################################
BLOCK mass #
- 1 +4.80000e-03 # Mu
- 2 +2.30000e-03 # Md
- 3 +9.50000e-02 # Ms
- 4 +1.42000e+00 # Mc
- 5 +4.70000e+00 # Mb
- 6 +1.73000e+02 # Mt
- 11 +5.11000e-04 # Me
- 12 +0.00000e+00 # Mve
- 13 +1.05658e-01 # Mmu
- 14 +0.00000e+00 # Mvmu
- 15 +1.77680e+00 # Mta
- 16 +0.00000e+00 # Mvta
25 +1.25000e+02 # MH
BLOCK sminputs #
1 +1.32507e+02 # aEWM1
2 +1.16639e-05 # Gf
3 +1.18000e-01 # aS
4 +9.11880e+01 # MZ
###################################
## CKM INFORMATION
###################################
BLOCK VCKM
1 1 +9.74272e-01 # RVud1x1
1 2 +2.25349e-01 # RVus1x2
1 3 +1.21581e-03 # RVub1x3
2 1 -2.25208e-01 # RVcd2x1
2 2 +9.73440e-01 # RVcs2x2
2 3 +4.11845e-02 # RVcb2x3
3 1 +8.09744e-03 # RVtd3x1
3 2 -4.03991e-02 # RVts3x2
3 3 +9.99146e-01 # RVtb3x3
BLOCK IMVCKM
1 1 +0.00000e+00 # IVud1x1
1 2 +0.00000e+00 # IVus1x2
1 3 -3.20194e-03 # IVub1x3
2 1 -1.28479e-04 # IVcd2x1
2 2 -2.97171e-05 # IVcs2x2
2 3 +0.00000e+00 # IVcb2x3
3 1 -3.11693e-03 # IVtd3x1
3 2 -7.20944e-04 # IVts3x2
3 3 +0.00000e+00 # IVtb3x3
###################################
## INFORMATION FOR HIGGS BASIS
###################################
BLOCK basis #
1 higgs # translated basis
BLOCK HBx4F #
1 +0.00000e+00 # cll1122
2 +0.00000e+00 # cpuu3333
BLOCK HBxh #
1 +0.00000e+00 # dCz
2 +0.00000e+00 # Cgg
3 +0.00000e+00 # Caa
4 +0.00000e+00 # Cza
5 +0.00000e+00 # Czz
6 +0.00000e+00 # Czbx
8 +0.00000e+00 # tCgg
9 +0.00000e+00 # tCaa
10 +0.00000e+00 # tCza
11 +0.00000e+00 # tCzz
BLOCK HBxhself #
1 +0.00000e+00 # dL3
BLOCK HBxMASS #
1 +0.00000e+00 # dM
BLOCK HBxTGC #
1 +0.00000e+00 # Lz
2 +0.00000e+00 # tLz
3 +0.00000e+00 # C3g
4 +0.00000e+00 # tC3g
BLOCK HBxdad
1 1 +0.00000e+00 # Rdad1x1
2 2 +0.00000e+00 # Rdad2x2
3 3 +0.00000e+00 # Rdad3x3
BLOCK IMHBxdad
1 1 +0.00000e+00 # Idad1x1
2 2 +0.00000e+00 # Idad2x2
3 3 +0.00000e+00 # Idad3x3
BLOCK HBxdae
1 1 +0.00000e+00 # Rdae1x1
2 2 +0.00000e+00 # Rdae2x2
3 3 +0.00000e+00 # Rdae3x3
BLOCK IMHBxdae
1 1 +0.00000e+00 # Idae1x1
2 2 +0.00000e+00 # Idae2x2
3 3 +0.00000e+00 # Idae3x3
BLOCK HBxdau
1 1 +0.00000e+00 # Rdau1x1
2 2 +0.00000e+00 # Rdau2x2
3 3 +0.00000e+00 # Rdau3x3
BLOCK IMHBxdau
1 1 +0.00000e+00 # Idau1x1
2 2 +0.00000e+00 # Idau2x2
3 3 +0.00000e+00 # Idau3x3
BLOCK HBxdgd
1 1 +0.00000e+00 # Rdgd1x1
2 2 +0.00000e+00 # Rdgd2x2
3 3 +0.00000e+00 # Rdgd3x3
BLOCK IMHBxdgd
1 1 +0.00000e+00 # Idgd1x1
2 2 +0.00000e+00 # Idgd2x2
3 3 +0.00000e+00 # Idgd3x3
BLOCK HBxdGLwl
1 1 +0.00000e+00 # RdGLwl1x1
2 2 +0.00000e+00 # RdGLwl2x2
3 3 +0.00000e+00 # RdGLwl3x3
BLOCK IMHBxdGLwl
1 1 +0.00000e+00 # IdGLwl1x1
2 2 +0.00000e+00 # IdGLwl2x2
3 3 +0.00000e+00 # IdGLwl3x3
BLOCK HBxdGLzd
1 1 +0.00000e+00 # RdGLzd1x1
2 2 +0.00000e+00 # RdGLzd2x2
3 3 +0.00000e+00 # RdGLzd3x3
BLOCK IMHBxdGLzd
1 1 +0.00000e+00 # IdGLzd1x1
2 2 +0.00000e+00 # IdGLzd2x2
3 3 +0.00000e+00 # IdGLzd3x3
BLOCK HBxdGLze
1 1 +0.00000e+00 # RdGLze1x1
2 2 +0.00000e+00 # RdGLze2x2
3 3 +0.00000e+00 # RdGLze3x3
BLOCK IMHBxdGLze
1 1 +0.00000e+00 # IdGLze1x1
2 2 +0.00000e+00 # IdGLze2x2
3 3 +0.00000e+00 # IdGLze3x3
BLOCK HBxdGLzu
1 1 +0.00000e+00 # RdGLzu1x1
2 2 +0.00000e+00 # RdGLzu2x2
3 3 +0.00000e+00 # RdGLzu3x3
BLOCK IMHBxdGLzu
1 1 +0.00000e+00 # IdGLzu1x1
2 2 +0.00000e+00 # IdGLzu2x2
3 3 +0.00000e+00 # IdGLzu3x3
BLOCK HBxdGRwq
1 1 +0.00000e+00 # RdGRwq1x1
2 2 +0.00000e+00 # RdGRwq2x2
3 3 +0.00000e+00 # RdGRwq3x3
BLOCK IMHBxdGRwq
1 1 +0.00000e+00 # IdGRwq1x1
2 2 +0.00000e+00 # IdGRwq2x2
3 3 +0.00000e+00 # IdGRwq3x3
BLOCK HBxdGRzd
1 1 +0.00000e+00 # RdGRzd1x1
2 2 +0.00000e+00 # RdGRzd2x2
3 3 +0.00000e+00 # RdGRzd3x3
BLOCK IMHBxdGRzd
1 1 +0.00000e+00 # IdGRzd1x1
2 2 +0.00000e+00 # IdGRzd2x2
3 3 +0.00000e+00 # IdGRzd3x3
BLOCK HBxdGRze
1 1 +0.00000e+00 # RdGRze1x1
2 2 +0.00000e+00 # RdGRze2x2
3 3 +0.00000e+00 # RdGRze3x3
BLOCK IMHBxdGRze
1 1 +0.00000e+00 # IdGRze1x1
2 2 +0.00000e+00 # IdGRze2x2
3 3 +0.00000e+00 # IdGRze3x3
BLOCK HBxdGRzu
1 1 +0.00000e+00 # RdGRzu1x1
2 2 +0.00000e+00 # RdGRzu2x2
3 3 +0.00000e+00 # RdGRzu3x3
BLOCK IMHBxdGRzu
1 1 +0.00000e+00 # IdGRzu1x1
2 2 +0.00000e+00 # IdGRzu2x2
3 3 +0.00000e+00 # IdGRzu3x3
BLOCK HBxdgu
1 1 +0.00000e+00 # Rdgu1x1
2 2 +0.00000e+00 # Rdgu2x2
3 3 +0.00000e+00 # Rdgu3x3
BLOCK IMHBxdgu
1 1 +0.00000e+00 # Idgu1x1
2 2 +0.00000e+00 # Idgu2x2
3 3 +0.00000e+00 # Idgu3x3
BLOCK HBxdwl
1 1 +0.00000e+00 # Rdwl1x1
2 2 +0.00000e+00 # Rdwl2x2
3 3 +0.00000e+00 # Rdwl3x3
BLOCK IMHBxdwl
1 1 +0.00000e+00 # Idwl1x1
2 2 +0.00000e+00 # Idwl2x2
3 3 +0.00000e+00 # Idwl3x3
BLOCK HBxdwq
1 1 +0.00000e+00 # Rdwq1x1
2 2 +0.00000e+00 # Rdwq2x2
3 3 +0.00000e+00 # Rdwq3x3
BLOCK IMHBxdwq
1 1 +0.00000e+00 # Idwq1x1
2 2 +0.00000e+00 # Idwq2x2
3 3 +0.00000e+00 # Idwq3x3
BLOCK HBxdYd
1 1 +0.00000e+00 # dYd1x1
2 2 +0.00000e+00 # dYd2x2
3 3 +0.00000e+00 # dYd3x3
BLOCK HBxdYe
1 1 +0.00000e+00 # dYe1x1
2 2 +0.00000e+00 # dYe2x2
3 3 +0.00000e+00 # dYe3x3
BLOCK HBxdYu
1 1 +0.00000e+00 # dYu1x1
2 2 +0.00000e+00 # dYu2x2
3 3 +0.00000e+00 # dYu3x3
BLOCK HBxdzd
1 1 +0.00000e+00 # Rdzd1x1
2 2 +0.00000e+00 # Rdzd2x2
3 3 +0.00000e+00 # Rdzd3x3
BLOCK IMHBxdzd
1 1 +0.00000e+00 # Idzd1x1
2 2 +0.00000e+00 # Idzd2x2
3 3 +0.00000e+00 # Idzd3x3
BLOCK HBxdze
1 1 +0.00000e+00 # Rdze1x1
2 2 +0.00000e+00 # Rdze2x2
3 3 +0.00000e+00 # Rdze3x3
BLOCK IMHBxdze
1 1 +0.00000e+00 # Idze1x1
2 2 +0.00000e+00 # Idze2x2
3 3 +0.00000e+00 # Idze3x3
BLOCK HBxdzu
1 1 +0.00000e+00 # Rdzu1x1
2 2 +0.00000e+00 # Rdzu2x2
3 3 +0.00000e+00 # Rdzu3x3
BLOCK IMHBxdzu
1 1 +0.00000e+00 # Idzu1x1
2 2 +0.00000e+00 # Idzu2x2
3 3 +0.00000e+00 # Idzu3x3
BLOCK HBxSd
1 1 +0.00000e+00 # Sd1x1
2 2 +0.00000e+00 # Sd2x2
3 3 +0.00000e+00 # Sd3x3
BLOCK HBxSe
1 1 +0.00000e+00 # Se1x1
2 2 +0.00000e+00 # Se2x2
3 3 +0.00000e+00 # Se3x3
BLOCK HBxSu
1 1 +0.00000e+00 # Su1x1
2 2 +0.00000e+00 # Su2x2
3 3 +0.00000e+00 # Su3x3
BLOCK HBxtdad
1 1 +0.00000e+00 # Rtdad1x1
2 2 +0.00000e+00 # Rtdad2x2
3 3 +0.00000e+00 # Rtdad3x3
BLOCK IMHBxtdad
1 1 +0.00000e+00 # Itdad1x1
2 2 +0.00000e+00 # Itdad2x2
3 3 +0.00000e+00 # Itdad3x3
BLOCK HBxtdae
1 1 +0.00000e+00 # Rtdae1x1
2 2 +0.00000e+00 # Rtdae2x2
3 3 +0.00000e+00 # Rtdae3x3
BLOCK IMHBxtdae
1 1 +0.00000e+00 # Itdae1x1
2 2 +0.00000e+00 # Itdae2x2
3 3 +0.00000e+00 # Itdae3x3
BLOCK HBxtdau
1 1 +0.00000e+00 # Rtdau1x1
2 2 +0.00000e+00 # Rtdau2x2
3 3 +0.00000e+00 # Rtdau3x3
BLOCK IMHBxtdau
1 1 +0.00000e+00 # Itdau1x1
2 2 +0.00000e+00 # Itdau2x2
3 3 +0.00000e+00 # Itdau3x3
BLOCK HBxtdgd
1 1 +0.00000e+00 # Rtdgd1x1
2 2 +0.00000e+00 # Rtdgd2x2
3 3 +0.00000e+00 # Rtdgd3x3
BLOCK IMHBxtdgd
1 1 +0.00000e+00 # Itdgd1x1
2 2 +0.00000e+00 # Itdgd2x2
3 3 +0.00000e+00 # Itdgd3x3
BLOCK HBxtdgu
1 1 +0.00000e+00 # Rtdgu1x1
2 2 +0.00000e+00 # Rtdgu2x2
3 3 +0.00000e+00 # Rtdgu3x3
BLOCK IMHBxtdgu
1 1 +0.00000e+00 # Itdgu1x1
2 2 +0.00000e+00 # Itdgu2x2
3 3 +0.00000e+00 # Itdgu3x3
BLOCK HBxtdwl
1 1 +0.00000e+00 # Rtdwl1x1
2 2 +0.00000e+00 # Rtdwl2x2
3 3 +0.00000e+00 # Rtdwl3x3
BLOCK IMHBxtdwl
1 1 +0.00000e+00 # Itdwl1x1
2 2 +0.00000e+00 # Itdwl2x2
3 3 +0.00000e+00 # Itdwl3x3
BLOCK HBxtdwq
1 1 +0.00000e+00 # Rtdwq1x1
2 2 +0.00000e+00 # Rtdwq2x2
3 3 +0.00000e+00 # Rtdwq3x3
BLOCK IMHBxtdwq
1 1 +0.00000e+00 # Itdwq1x1
2 2 +0.00000e+00 # Itdwq2x2
3 3 +0.00000e+00 # Itdwq3x3
BLOCK HBxtdzd
1 1 +0.00000e+00 # Rtdzd1x1
2 2 +0.00000e+00 # Rtdzd2x2
3 3 +0.00000e+00 # Rtdzd3x3
BLOCK IMHBxtdzd
1 1 +0.00000e+00 # Itdzd1x1
2 2 +0.00000e+00 # Itdzd2x2
3 3 +0.00000e+00 # Itdzd3x3
BLOCK HBxtdze
1 1 +0.00000e+00 # Rtdze1x1
2 2 +0.00000e+00 # Rtdze2x2
3 3 +0.00000e+00 # Rtdze3x3
BLOCK IMHBxtdze
1 1 +0.00000e+00 # Itdze1x1
2 2 +0.00000e+00 # Itdze2x2
3 3 +0.00000e+00 # Itdze3x3
BLOCK HBxtdzu
1 1 +0.00000e+00 # Rtdzu1x1
2 2 +0.00000e+00 # Rtdzu2x2
3 3 +0.00000e+00 # Rtdzu3x3
BLOCK IMHBxtdzu
1 1 +0.00000e+00 # Itdzu1x1
2 2 +0.00000e+00 # Itdzu2x2
3 3 +0.00000e+00 # Itdzu3x3
################################################################################
################################################################################
\ No newline at end of file
diff --git a/Cards/HiggsBasis_universal.dat b/Cards/HiggsBasis_universal.dat
index 390df77..0ba10ed 100644
--- a/Cards/HiggsBasis_universal.dat
+++ b/Cards/HiggsBasis_universal.dat
@@ -1,275 +1,263 @@
################################################################################
####################### ROSETTA: HIGGS BASIS INPUT CARD ########################
-###################### GENERATED FRI AUG 14 09:12:47 2015 ######################
+###################### GENERATED THU AUG 20 17:15:34 2015 ######################
################################################################################
BLOCK mass #
- 1 +4.80000e-03 # Mu
- 2 +2.30000e-03 # Md
- 3 +9.50000e-02 # Ms
- 4 +1.42000e+00 # Mc
- 5 +4.70000e+00 # Mb
- 6 +1.73000e+02 # Mt
- 11 +5.11000e-04 # Me
- 12 +0.00000e+00 # Mve
- 13 +1.05658e-01 # Mmu
- 14 +0.00000e+00 # Mvmu
- 15 +1.77680e+00 # Mta
- 16 +0.00000e+00 # Mvta
25 +1.25000e+02 # MH
BLOCK sminputs #
1 +1.32507e+02 # aEWM1
2 +1.16639e-05 # Gf
3 +1.18000e-01 # aS
4 +9.11880e+01 # MZ
###################################
## CKM INFORMATION
###################################
BLOCK VCKM
1 1 +9.74272e-01 # RVud1x1
1 2 +2.25349e-01 # RVus1x2
1 3 +1.21581e-03 # RVub1x3
2 1 -2.25208e-01 # RVcd2x1
2 2 +9.73440e-01 # RVcs2x2
2 3 +4.11845e-02 # RVcb2x3
3 1 +8.09744e-03 # RVtd3x1
3 2 -4.03991e-02 # RVts3x2
3 3 +9.99146e-01 # RVtb3x3
BLOCK IMVCKM
1 1 +0.00000e+00 # IVud1x1
1 2 +0.00000e+00 # IVus1x2
1 3 -3.20194e-03 # IVub1x3
2 1 -1.28479e-04 # IVcd2x1
2 2 -2.97171e-05 # IVcs2x2
2 3 +0.00000e+00 # IVcb2x3
3 1 -3.11693e-03 # IVtd3x1
3 2 -7.20944e-04 # IVts3x2
3 3 +0.00000e+00 # IVtb3x3
###################################
## INFORMATION FOR HIGGS BASIS
###################################
BLOCK basis #
1 higgs # translated basis
BLOCK HBx4F #
1 +0.00000e+00 # cll1122
2 +0.00000e+00 # cpuu3333
BLOCK HBxh #
1 +0.00000e+00 # dCz
2 +0.00000e+00 # Cgg
3 +0.00000e+00 # Caa
4 +0.00000e+00 # Cza
5 +0.00000e+00 # Czz
6 +0.00000e+00 # Czbx
8 +0.00000e+00 # tCgg
9 +0.00000e+00 # tCaa
10 +0.00000e+00 # tCza
11 +0.00000e+00 # tCzz
BLOCK HBxhself #
1 +0.00000e+00 # dL3
BLOCK HBxMASS #
1 +0.00000e+00 # dM
BLOCK HBxTGC #
1 +0.00000e+00 # Lz
2 +0.00000e+00 # tLz
3 +0.00000e+00 # C3g
4 +0.00000e+00 # tC3g
BLOCK HBxdad
1 1 +0.00000e+00 # Rdad1x1
BLOCK IMHBxdad
1 1 +0.00000e+00 # Idad1x1
BLOCK HBxdae
1 1 +0.00000e+00 # Rdae1x1
BLOCK IMHBxdae
1 1 +0.00000e+00 # Idae1x1
BLOCK HBxdau
1 1 +0.00000e+00 # Rdau1x1
BLOCK IMHBxdau
1 1 +0.00000e+00 # Idau1x1
BLOCK HBxdgd
1 1 +0.00000e+00 # Rdgd1x1
BLOCK IMHBxdgd
1 1 +0.00000e+00 # Idgd1x1
BLOCK HBxdGLwl
1 1 +0.00000e+00 # RdGLwl1x1
BLOCK IMHBxdGLwl
1 1 +0.00000e+00 # IdGLwl1x1
BLOCK HBxdGLzd
1 1 +0.00000e+00 # RdGLzd1x1
BLOCK IMHBxdGLzd
1 1 +0.00000e+00 # IdGLzd1x1
BLOCK HBxdGLze
1 1 +0.00000e+00 # RdGLze1x1
BLOCK IMHBxdGLze
1 1 +0.00000e+00 # IdGLze1x1
BLOCK HBxdGLzu
1 1 +0.00000e+00 # RdGLzu1x1
BLOCK IMHBxdGLzu
1 1 +0.00000e+00 # IdGLzu1x1
BLOCK HBxdGRwq
1 1 +0.00000e+00 # RdGRwq1x1
BLOCK IMHBxdGRwq
1 1 +0.00000e+00 # IdGRwq1x1
BLOCK HBxdGRzd
1 1 +0.00000e+00 # RdGRzd1x1
BLOCK IMHBxdGRzd
1 1 +0.00000e+00 # IdGRzd1x1
BLOCK HBxdGRze
1 1 +0.00000e+00 # RdGRze1x1
BLOCK IMHBxdGRze
1 1 +0.00000e+00 # IdGRze1x1
BLOCK HBxdGRzu
1 1 +0.00000e+00 # RdGRzu1x1
BLOCK IMHBxdGRzu
1 1 +0.00000e+00 # IdGRzu1x1
BLOCK HBxdgu
1 1 +0.00000e+00 # Rdgu1x1
BLOCK IMHBxdgu
1 1 +0.00000e+00 # Idgu1x1
BLOCK HBxdwl
1 1 +0.00000e+00 # Rdwl1x1
BLOCK IMHBxdwl
1 1 +0.00000e+00 # Idwl1x1
BLOCK HBxdwq
1 1 +0.00000e+00 # Rdwq1x1
BLOCK IMHBxdwq
1 1 +0.00000e+00 # Idwq1x1
BLOCK HBxdYd
1 1 +0.00000e+00 # dYd1x1
BLOCK HBxdYe
1 1 +0.00000e+00 # dYe1x1
BLOCK HBxdYu
1 1 +0.00000e+00 # dYu1x1
BLOCK HBxdzd
1 1 +0.00000e+00 # Rdzd1x1
BLOCK IMHBxdzd
1 1 +0.00000e+00 # Idzd1x1
BLOCK HBxdze
1 1 +0.00000e+00 # Rdze1x1
BLOCK IMHBxdze
1 1 +0.00000e+00 # Idze1x1
BLOCK HBxdzu
1 1 +0.00000e+00 # Rdzu1x1
BLOCK IMHBxdzu
1 1 +0.00000e+00 # Idzu1x1
BLOCK HBxSd
1 1 +0.00000e+00 # Sd1x1
BLOCK HBxSe
1 1 +0.00000e+00 # Se1x1
BLOCK HBxSu
1 1 +0.00000e+00 # Su1x1
BLOCK HBxtdad
1 1 +0.00000e+00 # Rtdad1x1
BLOCK IMHBxtdad
1 1 +0.00000e+00 # Itdad1x1
BLOCK HBxtdae
1 1 +0.00000e+00 # Rtdae1x1
BLOCK IMHBxtdae
1 1 +0.00000e+00 # Itdae1x1
BLOCK HBxtdau
1 1 +0.00000e+00 # Rtdau1x1
BLOCK IMHBxtdau
1 1 +0.00000e+00 # Itdau1x1
BLOCK HBxtdgd
1 1 +0.00000e+00 # Rtdgd1x1
BLOCK IMHBxtdgd
1 1 +0.00000e+00 # Itdgd1x1
BLOCK HBxtdgu
1 1 +0.00000e+00 # Rtdgu1x1
BLOCK IMHBxtdgu
1 1 +0.00000e+00 # Itdgu1x1
BLOCK HBxtdwl
1 1 +0.00000e+00 # Rtdwl1x1
BLOCK IMHBxtdwl
1 1 +0.00000e+00 # Itdwl1x1
BLOCK HBxtdwq
1 1 +0.00000e+00 # Rtdwq1x1
BLOCK IMHBxtdwq
1 1 +0.00000e+00 # Itdwq1x1
BLOCK HBxtdzd
1 1 +0.00000e+00 # Rtdzd1x1
BLOCK IMHBxtdzd
1 1 +0.00000e+00 # Itdzd1x1
BLOCK HBxtdze
1 1 +0.00000e+00 # Rtdze1x1
BLOCK IMHBxtdze
1 1 +0.00000e+00 # Itdze1x1
BLOCK HBxtdzu
1 1 +0.00000e+00 # Rtdzu1x1
BLOCK IMHBxtdzu
1 1 +0.00000e+00 # Itdzu1x1
################################################################################
################################################################################
\ No newline at end of file
diff --git a/Cards/SILHBasis.dat b/Cards/SILHBasis.dat
index 2ac84c0..03d42a9 100644
--- a/Cards/SILHBasis.dat
+++ b/Cards/SILHBasis.dat
@@ -1,285 +1,274 @@
################################################################################
######################## ROSETTA: SILH BASIS INPUT CARD ########################
-###################### GENERATED FRI AUG 14 09:12:41 2015 ######################
+###################### GENERATED THU AUG 20 17:15:38 2015 ######################
################################################################################
BLOCK mass #
- 1 +4.80000e-03 # Mu
- 2 +2.30000e-03 # Md
- 3 +9.50000e-02 # Ms
- 4 +1.42000e+00 # Mc
- 5 +4.70000e+00 # Mb
- 6 +1.73000e+02 # Mt
- 11 +5.11000e-04 # Me
- 12 +0.00000e+00 # Mve
- 13 +1.05658e-01 # Mmu
- 14 +0.00000e+00 # Mvmu
- 15 +1.77680e+00 # Mta
- 16 +0.00000e+00 # Mvta
+ 25 +1.25000e+02 # MH
BLOCK sminputs #
1 +1.32507e+02 # aEWM1
2 +1.16639e-05 # Gf
3 +1.18000e-01 # aS
4 +9.11880e+01 # MZ
25 +1.25000e+02 # MH
###################################
## CKM INFORMATION
###################################
BLOCK VCKM
1 1 +9.74272e-01 # RVud1x1
1 2 +2.25349e-01 # RVus1x2
1 3 +1.21581e-03 # RVub1x3
2 1 -2.25208e-01 # RVcd2x1
2 2 +9.73440e-01 # RVcs2x2
2 3 +4.11845e-02 # RVcb2x3
3 1 +8.09744e-03 # RVtd3x1
3 2 -4.03991e-02 # RVts3x2
3 3 +9.99146e-01 # RVtb3x3
BLOCK IMVCKM
1 1 +0.00000e+00 # IVud1x1
1 2 +0.00000e+00 # IVus1x2
1 3 -3.20194e-03 # IVub1x3
2 1 -1.28479e-04 # IVcd2x1
2 2 -2.97171e-05 # IVcs2x2
2 3 +0.00000e+00 # IVcb2x3
3 1 -3.11693e-03 # IVtd3x1
3 2 -7.20944e-04 # IVts3x2
3 3 +0.00000e+00 # IVtb3x3
###################################
## INFORMATION FOR SILH BASIS
###################################
BLOCK basis #
1 silh # translated basis
BLOCK SBxH4D2 #
1 +0.00000e+00 # sH
2 +0.00000e+00 # sT
BLOCK SBxH6 #
1 +0.00000e+00 # s6H
BLOCK SBxV2H2 #
1 +0.00000e+00 # sGG
2 +0.00000e+00 # sBB
3 +0.00000e+00 # sW
4 +0.00000e+00 # sB
5 +0.00000e+00 # sHW
6 +0.00000e+00 # sHB
7 +0.00000e+00 # s2W
8 +0.00000e+00 # s2B
9 +0.00000e+00 # s2G
10 +0.00000e+00 # tsGG
11 +0.00000e+00 # tsBB
12 +0.00000e+00 # tsHW
13 +0.00000e+00 # tsHB
BLOCK SBxV3D3 #
1 +0.00000e+00 # s3W
2 +0.00000e+00 # s3G
3 +0.00000e+00 # ts3W
4 +0.00000e+00 # ts3G
BLOCK SBxd
1 1 +0.00000e+00 # Rsd1x1
1 2 +0.00000e+00 # Rsd1x2
1 3 +0.00000e+00 # Rsd1x3
2 1 +0.00000e+00 # Rsd2x1
2 2 +0.00000e+00 # Rsd2x2
2 3 +0.00000e+00 # Rsd2x3
3 1 +0.00000e+00 # Rsd3x1
3 2 +0.00000e+00 # Rsd3x2
3 3 +0.00000e+00 # Rsd3x3
BLOCK IMSBxd
1 1 +0.00000e+00 # Isd1x1
1 2 +0.00000e+00 # Isd1x2
1 3 +0.00000e+00 # Isd1x3
2 1 +0.00000e+00 # Isd2x1
2 2 +0.00000e+00 # Isd2x2
2 3 +0.00000e+00 # Isd2x3
3 1 +0.00000e+00 # Isd3x1
3 2 +0.00000e+00 # Isd3x2
3 3 +0.00000e+00 # Isd3x3
BLOCK SBxe
1 1 +0.00000e+00 # Rse1x1
1 2 +0.00000e+00 # Rse1x2
1 3 +0.00000e+00 # Rse1x3
2 1 +0.00000e+00 # Rse2x1
2 2 +0.00000e+00 # Rse2x2
2 3 +0.00000e+00 # Rse2x3
3 1 +0.00000e+00 # Rse3x1
3 2 +0.00000e+00 # Rse3x2
3 3 +0.00000e+00 # Rse3x3
BLOCK IMSBxe
1 1 +0.00000e+00 # Ise1x1
1 2 +0.00000e+00 # Ise1x2
1 3 +0.00000e+00 # Ise1x3
2 1 +0.00000e+00 # Ise2x1
2 2 +0.00000e+00 # Ise2x2
2 3 +0.00000e+00 # Ise2x3
3 1 +0.00000e+00 # Ise3x1
3 2 +0.00000e+00 # Ise3x2
3 3 +0.00000e+00 # Ise3x3
BLOCK SBxHd
1 1 +0.00000e+00 # RsHd1x1
1 2 +0.00000e+00 # RsHd1x2
1 3 +0.00000e+00 # RsHd1x3
2 2 +0.00000e+00 # RsHd2x2
2 3 +0.00000e+00 # RsHd2x3
3 3 +0.00000e+00 # RsHd3x3
BLOCK IMSBxHd
1 1 +0.00000e+00 # IsHd1x1
1 2 +0.00000e+00 # IsHd1x2
1 3 +0.00000e+00 # IsHd1x3
2 2 +0.00000e+00 # IsHd2x2
2 3 +0.00000e+00 # IsHd2x3
3 3 +0.00000e+00 # IsHd3x3
BLOCK SBxHe
1 1 +0.00000e+00 # RsHe1x1
1 2 +0.00000e+00 # RsHe1x2
1 3 +0.00000e+00 # RsHe1x3
2 2 +0.00000e+00 # RsHe2x2
2 3 +0.00000e+00 # RsHe2x3
3 3 +0.00000e+00 # RsHe3x3
BLOCK IMSBxHe
1 1 +0.00000e+00 # IsHe1x1
1 2 +0.00000e+00 # IsHe1x2
1 3 +0.00000e+00 # IsHe1x3
2 2 +0.00000e+00 # IsHe2x2
2 3 +0.00000e+00 # IsHe2x3
3 3 +0.00000e+00 # IsHe3x3
BLOCK SBxHl
1 2 +0.00000e+00 # RsHl1x2
1 3 +0.00000e+00 # RsHl1x3
2 2 +0.00000e+00 # RsHl2x2
2 3 +0.00000e+00 # RsHl2x3
3 3 +0.00000e+00 # RsHl3x3
BLOCK IMSBxHl
1 2 +0.00000e+00 # IsHl1x2
1 3 +0.00000e+00 # IsHl1x3
2 2 +0.00000e+00 # IsHl2x2
2 3 +0.00000e+00 # IsHl2x3
3 3 +0.00000e+00 # IsHl3x3
BLOCK SBxHpl
1 2 +0.00000e+00 # RsHpl1x2
1 3 +0.00000e+00 # RsHpl1x3
2 2 +0.00000e+00 # RsHpl2x2
2 3 +0.00000e+00 # RsHpl2x3
3 3 +0.00000e+00 # RsHpl3x3
BLOCK IMSBxHpl
1 2 +0.00000e+00 # IsHpl1x2
1 3 +0.00000e+00 # IsHpl1x3
2 2 +0.00000e+00 # IsHpl2x2
2 3 +0.00000e+00 # IsHpl2x3
3 3 +0.00000e+00 # IsHpl3x3
BLOCK SBxHpq
1 1 +0.00000e+00 # RsHpq1x1
1 2 +0.00000e+00 # RsHpq1x2
1 3 +0.00000e+00 # RsHpq1x3
2 2 +0.00000e+00 # RsHpq2x2
2 3 +0.00000e+00 # RsHpq2x3
3 3 +0.00000e+00 # RsHpq3x3
BLOCK IMSBxHpq
1 1 +0.00000e+00 # IsHpq1x1
1 2 +0.00000e+00 # IsHpq1x2
1 3 +0.00000e+00 # IsHpq1x3
2 2 +0.00000e+00 # IsHpq2x2
2 3 +0.00000e+00 # IsHpq2x3
3 3 +0.00000e+00 # IsHpq3x3
BLOCK SBxHq
1 1 +0.00000e+00 # RsHq1x1
1 2 +0.00000e+00 # RsHq1x2
1 3 +0.00000e+00 # RsHq1x3
2 2 +0.00000e+00 # RsHq2x2
2 3 +0.00000e+00 # RsHq2x3
3 3 +0.00000e+00 # RsHq3x3
BLOCK IMSBxHq
1 1 +0.00000e+00 # IsHq1x1
1 2 +0.00000e+00 # IsHq1x2
1 3 +0.00000e+00 # IsHq1x3
2 2 +0.00000e+00 # IsHq2x2
2 3 +0.00000e+00 # IsHq2x3
3 3 +0.00000e+00 # IsHq3x3
BLOCK SBxHu
1 1 +0.00000e+00 # RsHu1x1
1 2 +0.00000e+00 # RsHu1x2
1 3 +0.00000e+00 # RsHu1x3
2 2 +0.00000e+00 # RsHu2x2
2 3 +0.00000e+00 # RsHu2x3
3 3 +0.00000e+00 # RsHu3x3
BLOCK IMSBxHu
1 1 +0.00000e+00 # IsHu1x1
1 2 +0.00000e+00 # IsHu1x2
1 3 +0.00000e+00 # IsHu1x3
2 2 +0.00000e+00 # IsHu2x2
2 3 +0.00000e+00 # IsHu2x3
3 3 +0.00000e+00 # IsHu3x3
BLOCK SBxHud
1 1 +0.00000e+00 # RsHud1x1
1 2 +0.00000e+00 # RsHud1x2
1 3 +0.00000e+00 # RsHud1x3
2 1 +0.00000e+00 # RsHud2x1
2 2 +0.00000e+00 # RsHud2x2
2 3 +0.00000e+00 # RsHud2x3
3 1 +0.00000e+00 # RsHud3x1
3 2 +0.00000e+00 # RsHud3x2
3 3 +0.00000e+00 # RsHud3x3
BLOCK IMSBxHud
1 1 +0.00000e+00 # IsHud1x1
1 2 +0.00000e+00 # IsHud1x2
1 3 +0.00000e+00 # IsHud1x3
2 1 +0.00000e+00 # IsHud2x1
2 2 +0.00000e+00 # IsHud2x2
2 3 +0.00000e+00 # IsHud2x3
3 1 +0.00000e+00 # IsHud3x1
3 2 +0.00000e+00 # IsHud3x2
3 3 +0.00000e+00 # IsHud3x3
BLOCK SBxu
1 1 +0.00000e+00 # Rsu1x1
1 2 +0.00000e+00 # Rsu1x2
1 3 +0.00000e+00 # Rsu1x3
2 1 +0.00000e+00 # Rsu2x1
2 2 +0.00000e+00 # Rsu2x2
2 3 +0.00000e+00 # Rsu2x3
3 1 +0.00000e+00 # Rsu3x1
3 2 +0.00000e+00 # Rsu3x2
3 3 +0.00000e+00 # Rsu3x3
BLOCK IMSBxu
1 1 +0.00000e+00 # Isu1x1
1 2 +0.00000e+00 # Isu1x2
1 3 +0.00000e+00 # Isu1x3
2 1 +0.00000e+00 # Isu2x1
2 2 +0.00000e+00 # Isu2x2
2 3 +0.00000e+00 # Isu2x3
3 1 +0.00000e+00 # Isu3x1
3 2 +0.00000e+00 # Isu3x2
3 3 +0.00000e+00 # Isu3x3
################################################################################
################################################################################
\ No newline at end of file
diff --git a/Cards/SILHBasis_diagonal.dat b/Cards/SILHBasis_diagonal.dat
index 3cdb798..59cf081 100644
--- a/Cards/SILHBasis_diagonal.dat
+++ b/Cards/SILHBasis_diagonal.dat
@@ -1,195 +1,184 @@
################################################################################
######################## ROSETTA: SILH BASIS INPUT CARD ########################
-###################### GENERATED FRI AUG 14 09:12:53 2015 ######################
+###################### GENERATED THU AUG 20 17:15:28 2015 ######################
################################################################################
BLOCK mass #
- 1 +4.80000e-03 # Mu
- 2 +2.30000e-03 # Md
- 3 +9.50000e-02 # Ms
- 4 +1.42000e+00 # Mc
- 5 +4.70000e+00 # Mb
- 6 +1.73000e+02 # Mt
- 11 +5.11000e-04 # Me
- 12 +0.00000e+00 # Mve
- 13 +1.05658e-01 # Mmu
- 14 +0.00000e+00 # Mvmu
- 15 +1.77680e+00 # Mta
- 16 +0.00000e+00 # Mvta
+ 25 +1.25000e+02 # MH
BLOCK sminputs #
1 +1.32507e+02 # aEWM1
2 +1.16639e-05 # Gf
3 +1.18000e-01 # aS
4 +9.11880e+01 # MZ
25 +1.25000e+02 # MH
###################################
## CKM INFORMATION
###################################
BLOCK VCKM
1 1 +9.74272e-01 # RVud1x1
1 2 +2.25349e-01 # RVus1x2
1 3 +1.21581e-03 # RVub1x3
2 1 -2.25208e-01 # RVcd2x1
2 2 +9.73440e-01 # RVcs2x2
2 3 +4.11845e-02 # RVcb2x3
3 1 +8.09744e-03 # RVtd3x1
3 2 -4.03991e-02 # RVts3x2
3 3 +9.99146e-01 # RVtb3x3
BLOCK IMVCKM
1 1 +0.00000e+00 # IVud1x1
1 2 +0.00000e+00 # IVus1x2
1 3 -3.20194e-03 # IVub1x3
2 1 -1.28479e-04 # IVcd2x1
2 2 -2.97171e-05 # IVcs2x2
2 3 +0.00000e+00 # IVcb2x3
3 1 -3.11693e-03 # IVtd3x1
3 2 -7.20944e-04 # IVts3x2
3 3 +0.00000e+00 # IVtb3x3
###################################
## INFORMATION FOR SILH BASIS
###################################
BLOCK basis #
1 silh # translated basis
BLOCK SBxH4D2 #
1 +0.00000e+00 # sH
2 +0.00000e+00 # sT
BLOCK SBxH6 #
1 +0.00000e+00 # s6H
BLOCK SBxV2H2 #
1 +0.00000e+00 # sGG
2 +0.00000e+00 # sBB
3 +0.00000e+00 # sW
4 +0.00000e+00 # sB
5 +0.00000e+00 # sHW
6 +0.00000e+00 # sHB
7 +0.00000e+00 # s2W
8 +0.00000e+00 # s2B
9 +0.00000e+00 # s2G
10 +0.00000e+00 # tsGG
11 +0.00000e+00 # tsBB
12 +0.00000e+00 # tsHW
13 +0.00000e+00 # tsHB
BLOCK SBxV3D3 #
1 +0.00000e+00 # s3W
2 +0.00000e+00 # s3G
3 +0.00000e+00 # ts3W
4 +0.00000e+00 # ts3G
BLOCK SBxd
1 1 +0.00000e+00 # Rsd1x1
2 2 +0.00000e+00 # Rsd2x2
3 3 +0.00000e+00 # Rsd3x3
BLOCK IMSBxd
1 1 +0.00000e+00 # Isd1x1
2 2 +0.00000e+00 # Isd2x2
3 3 +0.00000e+00 # Isd3x3
BLOCK SBxe
1 1 +0.00000e+00 # Rse1x1
2 2 +0.00000e+00 # Rse2x2
3 3 +0.00000e+00 # Rse3x3
BLOCK IMSBxe
1 1 +0.00000e+00 # Ise1x1
2 2 +0.00000e+00 # Ise2x2
3 3 +0.00000e+00 # Ise3x3
BLOCK SBxHd
1 1 +0.00000e+00 # RsHd1x1
2 2 +0.00000e+00 # RsHd2x2
3 3 +0.00000e+00 # RsHd3x3
BLOCK IMSBxHd
1 1 +0.00000e+00 # IsHd1x1
2 2 +0.00000e+00 # IsHd2x2
3 3 +0.00000e+00 # IsHd3x3
BLOCK SBxHe
1 1 +0.00000e+00 # RsHe1x1
2 2 +0.00000e+00 # RsHe2x2
3 3 +0.00000e+00 # RsHe3x3
BLOCK IMSBxHe
1 1 +0.00000e+00 # IsHe1x1
2 2 +0.00000e+00 # IsHe2x2
3 3 +0.00000e+00 # IsHe3x3
BLOCK SBxHl
2 2 +0.00000e+00 # RsHl2x2
3 3 +0.00000e+00 # RsHl3x3
BLOCK IMSBxHl
2 2 +0.00000e+00 # IsHl2x2
3 3 +0.00000e+00 # IsHl3x3
BLOCK SBxHpl
2 2 +0.00000e+00 # RsHpl2x2
3 3 +0.00000e+00 # RsHpl3x3
BLOCK IMSBxHpl
2 2 +0.00000e+00 # IsHpl2x2
3 3 +0.00000e+00 # IsHpl3x3
BLOCK SBxHpq
1 1 +0.00000e+00 # RsHpq1x1
2 2 +0.00000e+00 # RsHpq2x2
3 3 +0.00000e+00 # RsHpq3x3
BLOCK IMSBxHpq
1 1 +0.00000e+00 # IsHpq1x1
2 2 +0.00000e+00 # IsHpq2x2
3 3 +0.00000e+00 # IsHpq3x3
BLOCK SBxHq
1 1 +0.00000e+00 # RsHq1x1
2 2 +0.00000e+00 # RsHq2x2
3 3 +0.00000e+00 # RsHq3x3
BLOCK IMSBxHq
1 1 +0.00000e+00 # IsHq1x1
2 2 +0.00000e+00 # IsHq2x2
3 3 +0.00000e+00 # IsHq3x3
BLOCK SBxHu
1 1 +0.00000e+00 # RsHu1x1
2 2 +0.00000e+00 # RsHu2x2
3 3 +0.00000e+00 # RsHu3x3
BLOCK IMSBxHu
1 1 +0.00000e+00 # IsHu1x1
2 2 +0.00000e+00 # IsHu2x2
3 3 +0.00000e+00 # IsHu3x3
BLOCK SBxHud
1 1 +0.00000e+00 # RsHud1x1
2 2 +0.00000e+00 # RsHud2x2
3 3 +0.00000e+00 # RsHud3x3
BLOCK IMSBxHud
1 1 +0.00000e+00 # IsHud1x1
2 2 +0.00000e+00 # IsHud2x2
3 3 +0.00000e+00 # IsHud3x3
BLOCK SBxu
1 1 +0.00000e+00 # Rsu1x1
2 2 +0.00000e+00 # Rsu2x2
3 3 +0.00000e+00 # Rsu3x3
BLOCK IMSBxu
1 1 +0.00000e+00 # Isu1x1
2 2 +0.00000e+00 # Isu2x2
3 3 +0.00000e+00 # Isu3x3
################################################################################
################################################################################
\ No newline at end of file
diff --git a/Cards/SILHBasis_universal.dat b/Cards/SILHBasis_universal.dat
index e95ab37..f1a7d4f 100644
--- a/Cards/SILHBasis_universal.dat
+++ b/Cards/SILHBasis_universal.dat
@@ -1,143 +1,132 @@
################################################################################
######################## ROSETTA: SILH BASIS INPUT CARD ########################
-###################### GENERATED FRI AUG 14 09:12:47 2015 ######################
+###################### GENERATED THU AUG 20 17:15:34 2015 ######################
################################################################################
BLOCK mass #
- 1 +4.80000e-03 # Mu
- 2 +2.30000e-03 # Md
- 3 +9.50000e-02 # Ms
- 4 +1.42000e+00 # Mc
- 5 +4.70000e+00 # Mb
- 6 +1.73000e+02 # Mt
- 11 +5.11000e-04 # Me
- 12 +0.00000e+00 # Mve
- 13 +1.05658e-01 # Mmu
- 14 +0.00000e+00 # Mvmu
- 15 +1.77680e+00 # Mta
- 16 +0.00000e+00 # Mvta
+ 25 +1.25000e+02 # MH
BLOCK sminputs #
1 +1.32507e+02 # aEWM1
2 +1.16639e-05 # Gf
3 +1.18000e-01 # aS
4 +9.11880e+01 # MZ
25 +1.25000e+02 # MH
###################################
## CKM INFORMATION
###################################
BLOCK VCKM
1 1 +9.74272e-01 # RVud1x1
1 2 +2.25349e-01 # RVus1x2
1 3 +1.21581e-03 # RVub1x3
2 1 -2.25208e-01 # RVcd2x1
2 2 +9.73440e-01 # RVcs2x2
2 3 +4.11845e-02 # RVcb2x3
3 1 +8.09744e-03 # RVtd3x1
3 2 -4.03991e-02 # RVts3x2
3 3 +9.99146e-01 # RVtb3x3
BLOCK IMVCKM
1 1 +0.00000e+00 # IVud1x1
1 2 +0.00000e+00 # IVus1x2
1 3 -3.20194e-03 # IVub1x3
2 1 -1.28479e-04 # IVcd2x1
2 2 -2.97171e-05 # IVcs2x2
2 3 +0.00000e+00 # IVcb2x3
3 1 -3.11693e-03 # IVtd3x1
3 2 -7.20944e-04 # IVts3x2
3 3 +0.00000e+00 # IVtb3x3
###################################
## INFORMATION FOR SILH BASIS
###################################
BLOCK basis #
1 silh # translated basis
BLOCK SBxH4D2 #
1 +0.00000e+00 # sH
2 +0.00000e+00 # sT
BLOCK SBxH6 #
1 +0.00000e+00 # s6H
BLOCK SBxV2H2 #
1 +0.00000e+00 # sGG
2 +0.00000e+00 # sBB
3 +0.00000e+00 # sW
4 +0.00000e+00 # sB
5 +0.00000e+00 # sHW
6 +0.00000e+00 # sHB
7 +0.00000e+00 # s2W
8 +0.00000e+00 # s2B
9 +0.00000e+00 # s2G
10 +0.00000e+00 # tsGG
11 +0.00000e+00 # tsBB
12 +0.00000e+00 # tsHW
13 +0.00000e+00 # tsHB
BLOCK SBxV3D3 #
1 +0.00000e+00 # s3W
2 +0.00000e+00 # s3G
3 +0.00000e+00 # ts3W
4 +0.00000e+00 # ts3G
BLOCK SBxd
1 1 +0.00000e+00 # Rsd1x1
BLOCK IMSBxd
1 1 +0.00000e+00 # Isd1x1
BLOCK SBxe
1 1 +0.00000e+00 # Rse1x1
BLOCK IMSBxe
1 1 +0.00000e+00 # Ise1x1
BLOCK SBxHd
1 1 +0.00000e+00 # RsHd1x1
BLOCK IMSBxHd
1 1 +0.00000e+00 # IsHd1x1
BLOCK SBxHe
1 1 +0.00000e+00 # RsHe1x1
BLOCK IMSBxHe
1 1 +0.00000e+00 # IsHe1x1
BLOCK SBxHpq
1 1 +0.00000e+00 # RsHpq1x1
BLOCK IMSBxHpq
1 1 +0.00000e+00 # IsHpq1x1
BLOCK SBxHq
1 1 +0.00000e+00 # RsHq1x1
BLOCK IMSBxHq
1 1 +0.00000e+00 # IsHq1x1
BLOCK SBxHu
1 1 +0.00000e+00 # RsHu1x1
BLOCK IMSBxHu
1 1 +0.00000e+00 # IsHu1x1
BLOCK SBxHud
1 1 +0.00000e+00 # RsHud1x1
BLOCK IMSBxHud
1 1 +0.00000e+00 # IsHud1x1
BLOCK SBxu
1 1 +0.00000e+00 # Rsu1x1
BLOCK IMSBxu
1 1 +0.00000e+00 # Isu1x1
################################################################################
################################################################################
\ No newline at end of file
diff --git a/Cards/TemplateBasis.dat b/Cards/TemplateBasis.dat
index 05ccaa3..cc67385 100644
--- a/Cards/TemplateBasis.dat
+++ b/Cards/TemplateBasis.dat
@@ -1,79 +1,79 @@
################################################################################
###################### ROSETTA: TEMPLATE BASIS INPUT CARD ######################
-###################### GENERATED FRI AUG 14 09:12:39 2015 ######################
+###################### GENERATED THU AUG 20 17:15:37 2015 ######################
################################################################################
BLOCK mass #
1 +4.80000e-03 # Mu
2 +2.30000e-03 # Md
3 +9.50000e-02 # Ms
4 +1.42000e+00 # Mc
5 +4.70000e+00 # Mb
6 +1.73000e+02 # Mt
BLOCK sminputs #
1 +1.32507e+02 # aEWM1
4 +9.11880e+01 # MZ
###################################
## CKM INFORMATION
###################################
BLOCK VCKM
1 1 +9.74272e-01 # RVud1x1
1 2 +2.25349e-01 # RVus1x2
1 3 +1.21581e-03 # RVub1x3
2 1 -2.25208e-01 # RVcd2x1
2 2 +9.73440e-01 # RVcs2x2
2 3 +4.11845e-02 # RVcb2x3
3 1 +8.09744e-03 # RVtd3x1
3 2 -4.03991e-02 # RVts3x2
3 3 +9.99146e-01 # RVtb3x3
BLOCK IMVCKM
1 1 +0.00000e+00 # IVud1x1
1 2 +0.00000e+00 # IVus1x2
1 3 -3.20194e-03 # IVub1x3
2 1 -1.28479e-04 # IVcd2x1
2 2 -2.97171e-05 # IVcs2x2
2 3 +0.00000e+00 # IVcb2x3
3 1 -3.11693e-03 # IVtd3x1
3 2 -7.20944e-04 # IVts3x2
3 3 +0.00000e+00 # IVtb3x3
###################################
## INFORMATION FOR TEMPLATE BASIS
###################################
BLOCK basis #
1 template # translated basis
BLOCK newcoup #
1 +0.00000e+00 # a
2 +0.00000e+00 # b
3 +0.00000e+00 # c
BLOCK AA
1 1 +0.00000e+00 # RcAA1x1
1 2 +0.00000e+00 # RcAA1x2
1 3 +0.00000e+00 # RcAA1x3
2 1 +0.00000e+00 # RcAA2x1
2 2 +0.00000e+00 # RcAA2x2
2 3 +0.00000e+00 # RcAA2x3
3 1 +0.00000e+00 # RcAA3x1
3 2 +0.00000e+00 # RcAA3x2
3 3 +0.00000e+00 # RcAA3x3
BLOCK IMAA
1 1 +0.00000e+00 # IcAA1x1
1 2 +0.00000e+00 # IcAA1x2
1 3 +0.00000e+00 # IcAA1x3
2 1 +0.00000e+00 # IcAA2x1
2 2 +0.00000e+00 # IcAA2x2
2 3 +0.00000e+00 # IcAA2x3
3 1 +0.00000e+00 # IcAA3x1
3 2 +0.00000e+00 # IcAA3x2
3 3 +0.00000e+00 # IcAA3x3
################################################################################
################################################################################
\ No newline at end of file
diff --git a/Cards/TemplateBasis_diagonal.dat b/Cards/TemplateBasis_diagonal.dat
index d525e2b..c620bfb 100644
--- a/Cards/TemplateBasis_diagonal.dat
+++ b/Cards/TemplateBasis_diagonal.dat
@@ -1,67 +1,67 @@
################################################################################
###################### ROSETTA: TEMPLATE BASIS INPUT CARD ######################
-###################### GENERATED FRI AUG 14 09:12:52 2015 ######################
+###################### GENERATED THU AUG 20 17:15:28 2015 ######################
################################################################################
BLOCK mass #
1 +4.80000e-03 # Mu
2 +2.30000e-03 # Md
3 +9.50000e-02 # Ms
4 +1.42000e+00 # Mc
5 +4.70000e+00 # Mb
6 +1.73000e+02 # Mt
BLOCK sminputs #
1 +1.32507e+02 # aEWM1
4 +9.11880e+01 # MZ
###################################
## CKM INFORMATION
###################################
BLOCK VCKM
1 1 +9.74272e-01 # RVud1x1
1 2 +2.25349e-01 # RVus1x2
1 3 +1.21581e-03 # RVub1x3
2 1 -2.25208e-01 # RVcd2x1
2 2 +9.73440e-01 # RVcs2x2
2 3 +4.11845e-02 # RVcb2x3
3 1 +8.09744e-03 # RVtd3x1
3 2 -4.03991e-02 # RVts3x2
3 3 +9.99146e-01 # RVtb3x3
BLOCK IMVCKM
1 1 +0.00000e+00 # IVud1x1
1 2 +0.00000e+00 # IVus1x2
1 3 -3.20194e-03 # IVub1x3
2 1 -1.28479e-04 # IVcd2x1
2 2 -2.97171e-05 # IVcs2x2
2 3 +0.00000e+00 # IVcb2x3
3 1 -3.11693e-03 # IVtd3x1
3 2 -7.20944e-04 # IVts3x2
3 3 +0.00000e+00 # IVtb3x3
###################################
## INFORMATION FOR TEMPLATE BASIS
###################################
BLOCK basis #
1 template # translated basis
BLOCK newcoup #
1 +0.00000e+00 # a
2 +0.00000e+00 # b
3 +0.00000e+00 # c
BLOCK AA
1 1 +0.00000e+00 # RcAA1x1
2 2 +0.00000e+00 # RcAA2x2
3 3 +0.00000e+00 # RcAA3x3
BLOCK IMAA
1 1 +0.00000e+00 # IcAA1x1
2 2 +0.00000e+00 # IcAA2x2
3 3 +0.00000e+00 # IcAA3x3
################################################################################
################################################################################
\ No newline at end of file
diff --git a/Cards/TemplateBasis_universal.dat b/Cards/TemplateBasis_universal.dat
index 8bc4659..37b44b1 100644
--- a/Cards/TemplateBasis_universal.dat
+++ b/Cards/TemplateBasis_universal.dat
@@ -1,63 +1,63 @@
################################################################################
###################### ROSETTA: TEMPLATE BASIS INPUT CARD ######################
-###################### GENERATED FRI AUG 14 09:12:47 2015 ######################
+###################### GENERATED THU AUG 20 17:15:34 2015 ######################
################################################################################
BLOCK mass #
1 +4.80000e-03 # Mu
2 +2.30000e-03 # Md
3 +9.50000e-02 # Ms
4 +1.42000e+00 # Mc
5 +4.70000e+00 # Mb
6 +1.73000e+02 # Mt
BLOCK sminputs #
1 +1.32507e+02 # aEWM1
4 +9.11880e+01 # MZ
###################################
## CKM INFORMATION
###################################
BLOCK VCKM
1 1 +9.74272e-01 # RVud1x1
1 2 +2.25349e-01 # RVus1x2
1 3 +1.21581e-03 # RVub1x3
2 1 -2.25208e-01 # RVcd2x1
2 2 +9.73440e-01 # RVcs2x2
2 3 +4.11845e-02 # RVcb2x3
3 1 +8.09744e-03 # RVtd3x1
3 2 -4.03991e-02 # RVts3x2
3 3 +9.99146e-01 # RVtb3x3
BLOCK IMVCKM
1 1 +0.00000e+00 # IVud1x1
1 2 +0.00000e+00 # IVus1x2
1 3 -3.20194e-03 # IVub1x3
2 1 -1.28479e-04 # IVcd2x1
2 2 -2.97171e-05 # IVcs2x2
2 3 +0.00000e+00 # IVcb2x3
3 1 -3.11693e-03 # IVtd3x1
3 2 -7.20944e-04 # IVts3x2
3 3 +0.00000e+00 # IVtb3x3
###################################
## INFORMATION FOR TEMPLATE BASIS
###################################
BLOCK basis #
1 template # translated basis
BLOCK newcoup #
1 +0.00000e+00 # a
2 +0.00000e+00 # b
3 +0.00000e+00 # c
BLOCK AA
1 1 +0.00000e+00 # RcAA1x1
BLOCK IMAA
1 1 +0.00000e+00 # IcAA1x1
################################################################################
################################################################################
\ No newline at end of file
diff --git a/Cards/WarsawBasis.dat b/Cards/WarsawBasis.dat
index 0344e11..3042e0a 100644
--- a/Cards/WarsawBasis.dat
+++ b/Cards/WarsawBasis.dat
@@ -1,289 +1,278 @@
################################################################################
####################### ROSETTA: WARSAW BASIS INPUT CARD #######################
-###################### GENERATED FRI AUG 14 09:12:40 2015 ######################
+###################### GENERATED THU AUG 20 17:15:38 2015 ######################
################################################################################
BLOCK mass #
- 1 +4.80000e-03 # Mu
- 2 +2.30000e-03 # Md
- 3 +9.50000e-02 # Ms
- 4 +1.42000e+00 # Mc
- 5 +4.70000e+00 # Mb
- 6 +1.73000e+02 # Mt
- 11 +5.11000e-04 # Me
- 12 +0.00000e+00 # Mve
- 13 +1.05658e-01 # Mmu
- 14 +0.00000e+00 # Mvmu
- 15 +1.77680e+00 # Mta
- 16 +0.00000e+00 # Mvta
+ 25 +1.25000e+02 # MH
BLOCK sminputs #
1 +1.32507e+02 # aEWM1
2 +1.16639e-05 # Gf
3 +1.18000e-01 # aS
4 +9.11880e+01 # MZ
25 +1.25000e+02 # MH
###################################
## CKM INFORMATION
###################################
BLOCK VCKM
1 1 +9.74272e-01 # RVud1x1
1 2 +2.25349e-01 # RVus1x2
1 3 +1.21581e-03 # RVub1x3
2 1 -2.25208e-01 # RVcd2x1
2 2 +9.73440e-01 # RVcs2x2
2 3 +4.11845e-02 # RVcb2x3
3 1 +8.09744e-03 # RVtd3x1
3 2 -4.03991e-02 # RVts3x2
3 3 +9.99146e-01 # RVtb3x3
BLOCK IMVCKM
1 1 +0.00000e+00 # IVud1x1
1 2 +0.00000e+00 # IVus1x2
1 3 -3.20194e-03 # IVub1x3
2 1 -1.28479e-04 # IVcd2x1
2 2 -2.97171e-05 # IVcs2x2
2 3 +0.00000e+00 # IVcb2x3
3 1 -3.11693e-03 # IVtd3x1
3 2 -7.20944e-04 # IVts3x2
3 3 +0.00000e+00 # IVtb3x3
###################################
## INFORMATION FOR WARSAW BASIS
###################################
BLOCK basis #
1 warsaw # translated basis
BLOCK WBx4F #
1 +0.00000e+00 # cll1221
2 +0.00000e+00 # cll1122
3 +0.00000e+00 # cpuu3333
BLOCK WBxH4D2 #
1 +0.00000e+00 # cH
2 +0.00000e+00 # cT
BLOCK WBxH6 #
1 +0.00000e+00 # c6H
BLOCK WBxV2H2 #
1 +0.00000e+00 # cGG
- 2 +0.00000e+00 # tcGG
- 3 +0.00000e+00 # cWW
- 4 +0.00000e+00 # tcWW
- 5 +0.00000e+00 # cBB
- 6 +0.00000e+00 # tcBB
- 7 +0.00000e+00 # cWB
+ 2 +0.00000e+00 # cWW
+ 3 +0.00000e+00 # cBB
+ 4 +0.00000e+00 # cWB
+ 5 +0.00000e+00 # tcGG
+ 6 +0.00000e+00 # tcWW
+ 7 +0.00000e+00 # tcBB
8 +0.00000e+00 # tcWB
BLOCK WBxV3D3 #
1 +0.00000e+00 # c3W
2 +0.00000e+00 # c3G
3 +0.00000e+00 # tc3W
4 +0.00000e+00 # tc3G
BLOCK WBxd
1 1 +0.00000e+00 # Rcd1x1
1 2 +0.00000e+00 # Rcd1x2
1 3 +0.00000e+00 # Rcd1x3
2 1 +0.00000e+00 # Rcd2x1
2 2 +0.00000e+00 # Rcd2x2
2 3 +0.00000e+00 # Rcd2x3
3 1 +0.00000e+00 # Rcd3x1
3 2 +0.00000e+00 # Rcd3x2
3 3 +0.00000e+00 # Rcd3x3
BLOCK IMWBxd
1 1 +0.00000e+00 # Icd1x1
1 2 +0.00000e+00 # Icd1x2
1 3 +0.00000e+00 # Icd1x3
2 1 +0.00000e+00 # Icd2x1
2 2 +0.00000e+00 # Icd2x2
2 3 +0.00000e+00 # Icd2x3
3 1 +0.00000e+00 # Icd3x1
3 2 +0.00000e+00 # Icd3x2
3 3 +0.00000e+00 # Icd3x3
BLOCK WBxe
1 1 +0.00000e+00 # Rce1x1
1 2 +0.00000e+00 # Rce1x2
1 3 +0.00000e+00 # Rce1x3
2 1 +0.00000e+00 # Rce2x1
2 2 +0.00000e+00 # Rce2x2
2 3 +0.00000e+00 # Rce2x3
3 1 +0.00000e+00 # Rce3x1
3 2 +0.00000e+00 # Rce3x2
3 3 +0.00000e+00 # Rce3x3
BLOCK IMWBxe
1 1 +0.00000e+00 # Ice1x1
1 2 +0.00000e+00 # Ice1x2
1 3 +0.00000e+00 # Ice1x3
2 1 +0.00000e+00 # Ice2x1
2 2 +0.00000e+00 # Ice2x2
2 3 +0.00000e+00 # Ice2x3
3 1 +0.00000e+00 # Ice3x1
3 2 +0.00000e+00 # Ice3x2
3 3 +0.00000e+00 # Ice3x3
BLOCK WBxHd
1 1 +0.00000e+00 # RcHd1x1
1 2 +0.00000e+00 # RcHd1x2
1 3 +0.00000e+00 # RcHd1x3
2 2 +0.00000e+00 # RcHd2x2
2 3 +0.00000e+00 # RcHd2x3
3 3 +0.00000e+00 # RcHd3x3
BLOCK IMWBxHd
1 1 +0.00000e+00 # IcHd1x1
1 2 +0.00000e+00 # IcHd1x2
1 3 +0.00000e+00 # IcHd1x3
2 2 +0.00000e+00 # IcHd2x2
2 3 +0.00000e+00 # IcHd2x3
3 3 +0.00000e+00 # IcHd3x3
BLOCK WBxHe
1 1 +0.00000e+00 # RcHe1x1
1 2 +0.00000e+00 # RcHe1x2
1 3 +0.00000e+00 # RcHe1x3
2 2 +0.00000e+00 # RcHe2x2
2 3 +0.00000e+00 # RcHe2x3
3 3 +0.00000e+00 # RcHe3x3
BLOCK IMWBxHe
1 1 +0.00000e+00 # IcHe1x1
1 2 +0.00000e+00 # IcHe1x2
1 3 +0.00000e+00 # IcHe1x3
2 2 +0.00000e+00 # IcHe2x2
2 3 +0.00000e+00 # IcHe2x3
3 3 +0.00000e+00 # IcHe3x3
BLOCK WBxHl
1 1 +0.00000e+00 # RcHl1x1
1 2 +0.00000e+00 # RcHl1x2
1 3 +0.00000e+00 # RcHl1x3
2 2 +0.00000e+00 # RcHl2x2
2 3 +0.00000e+00 # RcHl2x3
3 3 +0.00000e+00 # RcHl3x3
BLOCK IMWBxHl
1 1 +0.00000e+00 # IcHl1x1
1 2 +0.00000e+00 # IcHl1x2
1 3 +0.00000e+00 # IcHl1x3
2 2 +0.00000e+00 # IcHl2x2
2 3 +0.00000e+00 # IcHl2x3
3 3 +0.00000e+00 # IcHl3x3
BLOCK WBxHpl
1 1 +0.00000e+00 # RcHpl1x1
1 2 +0.00000e+00 # RcHpl1x2
1 3 +0.00000e+00 # RcHpl1x3
2 2 +0.00000e+00 # RcHpl2x2
2 3 +0.00000e+00 # RcHpl2x3
3 3 +0.00000e+00 # RcHpl3x3
BLOCK IMWBxHpl
1 1 +0.00000e+00 # IcHpl1x1
1 2 +0.00000e+00 # IcHpl1x2
1 3 +0.00000e+00 # IcHpl1x3
2 2 +0.00000e+00 # IcHpl2x2
2 3 +0.00000e+00 # IcHpl2x3
3 3 +0.00000e+00 # IcHpl3x3
BLOCK WBxHpq
1 1 +0.00000e+00 # RcHpq1x1
1 2 +0.00000e+00 # RcHpq1x2
1 3 +0.00000e+00 # RcHpq1x3
2 2 +0.00000e+00 # RcHpq2x2
2 3 +0.00000e+00 # RcHpq2x3
3 3 +0.00000e+00 # RcHpq3x3
BLOCK IMWBxHpq
1 1 +0.00000e+00 # IcHpq1x1
1 2 +0.00000e+00 # IcHpq1x2
1 3 +0.00000e+00 # IcHpq1x3
2 2 +0.00000e+00 # IcHpq2x2
2 3 +0.00000e+00 # IcHpq2x3
3 3 +0.00000e+00 # IcHpq3x3
BLOCK WBxHq
1 1 +0.00000e+00 # RcHq1x1
1 2 +0.00000e+00 # RcHq1x2
1 3 +0.00000e+00 # RcHq1x3
2 2 +0.00000e+00 # RcHq2x2
2 3 +0.00000e+00 # RcHq2x3
3 3 +0.00000e+00 # RcHq3x3
BLOCK IMWBxHq
1 1 +0.00000e+00 # IcHq1x1
1 2 +0.00000e+00 # IcHq1x2
1 3 +0.00000e+00 # IcHq1x3
2 2 +0.00000e+00 # IcHq2x2
2 3 +0.00000e+00 # IcHq2x3
3 3 +0.00000e+00 # IcHq3x3
BLOCK WBxHu
1 1 +0.00000e+00 # RcHu1x1
1 2 +0.00000e+00 # RcHu1x2
1 3 +0.00000e+00 # RcHu1x3
2 2 +0.00000e+00 # RcHu2x2
2 3 +0.00000e+00 # RcHu2x3
3 3 +0.00000e+00 # RcHu3x3
BLOCK IMWBxHu
1 1 +0.00000e+00 # IcHu1x1
1 2 +0.00000e+00 # IcHu1x2
1 3 +0.00000e+00 # IcHu1x3
2 2 +0.00000e+00 # IcHu2x2
2 3 +0.00000e+00 # IcHu2x3
3 3 +0.00000e+00 # IcHu3x3
BLOCK WBxHud
1 1 +0.00000e+00 # RcHud1x1
1 2 +0.00000e+00 # RcHud1x2
1 3 +0.00000e+00 # RcHud1x3
2 1 +0.00000e+00 # RcHud2x1
2 2 +0.00000e+00 # RcHud2x2
2 3 +0.00000e+00 # RcHud2x3
3 1 +0.00000e+00 # RcHud3x1
3 2 +0.00000e+00 # RcHud3x2
3 3 +0.00000e+00 # RcHud3x3
BLOCK IMWBxHud
1 1 +0.00000e+00 # IcHud1x1
1 2 +0.00000e+00 # IcHud1x2
1 3 +0.00000e+00 # IcHud1x3
2 1 +0.00000e+00 # IcHud2x1
2 2 +0.00000e+00 # IcHud2x2
2 3 +0.00000e+00 # IcHud2x3
3 1 +0.00000e+00 # IcHud3x1
3 2 +0.00000e+00 # IcHud3x2
3 3 +0.00000e+00 # IcHud3x3
BLOCK WBxu
1 1 +0.00000e+00 # Rcu1x1
1 2 +0.00000e+00 # Rcu1x2
1 3 +0.00000e+00 # Rcu1x3
2 1 +0.00000e+00 # Rcu2x1
2 2 +0.00000e+00 # Rcu2x2
2 3 +0.00000e+00 # Rcu2x3
3 1 +0.00000e+00 # Rcu3x1
3 2 +0.00000e+00 # Rcu3x2
3 3 +0.00000e+00 # Rcu3x3
BLOCK IMWBxu
1 1 +0.00000e+00 # Icu1x1
1 2 +0.00000e+00 # Icu1x2
1 3 +0.00000e+00 # Icu1x3
2 1 +0.00000e+00 # Icu2x1
2 2 +0.00000e+00 # Icu2x2
2 3 +0.00000e+00 # Icu2x3
3 1 +0.00000e+00 # Icu3x1
3 2 +0.00000e+00 # Icu3x2
3 3 +0.00000e+00 # Icu3x3
################################################################################
################################################################################
\ No newline at end of file
diff --git a/Cards/WarsawBasis_diagonal.dat b/Cards/WarsawBasis_diagonal.dat
index cbce35a..00ec6fd 100644
--- a/Cards/WarsawBasis_diagonal.dat
+++ b/Cards/WarsawBasis_diagonal.dat
@@ -1,199 +1,188 @@
################################################################################
####################### ROSETTA: WARSAW BASIS INPUT CARD #######################
-###################### GENERATED FRI AUG 14 09:12:53 2015 ######################
+###################### GENERATED THU AUG 20 17:15:28 2015 ######################
################################################################################
BLOCK mass #
- 1 +4.80000e-03 # Mu
- 2 +2.30000e-03 # Md
- 3 +9.50000e-02 # Ms
- 4 +1.42000e+00 # Mc
- 5 +4.70000e+00 # Mb
- 6 +1.73000e+02 # Mt
- 11 +5.11000e-04 # Me
- 12 +0.00000e+00 # Mve
- 13 +1.05658e-01 # Mmu
- 14 +0.00000e+00 # Mvmu
- 15 +1.77680e+00 # Mta
- 16 +0.00000e+00 # Mvta
+ 25 +1.25000e+02 # MH
BLOCK sminputs #
1 +1.32507e+02 # aEWM1
2 +1.16639e-05 # Gf
3 +1.18000e-01 # aS
4 +9.11880e+01 # MZ
25 +1.25000e+02 # MH
###################################
## CKM INFORMATION
###################################
BLOCK VCKM
1 1 +9.74272e-01 # RVud1x1
1 2 +2.25349e-01 # RVus1x2
1 3 +1.21581e-03 # RVub1x3
2 1 -2.25208e-01 # RVcd2x1
2 2 +9.73440e-01 # RVcs2x2
2 3 +4.11845e-02 # RVcb2x3
3 1 +8.09744e-03 # RVtd3x1
3 2 -4.03991e-02 # RVts3x2
3 3 +9.99146e-01 # RVtb3x3
BLOCK IMVCKM
1 1 +0.00000e+00 # IVud1x1
1 2 +0.00000e+00 # IVus1x2
1 3 -3.20194e-03 # IVub1x3
2 1 -1.28479e-04 # IVcd2x1
2 2 -2.97171e-05 # IVcs2x2
2 3 +0.00000e+00 # IVcb2x3
3 1 -3.11693e-03 # IVtd3x1
3 2 -7.20944e-04 # IVts3x2
3 3 +0.00000e+00 # IVtb3x3
###################################
## INFORMATION FOR WARSAW BASIS
###################################
BLOCK basis #
1 warsaw # translated basis
BLOCK WBx4F #
1 +0.00000e+00 # cll1221
2 +0.00000e+00 # cll1122
3 +0.00000e+00 # cpuu3333
BLOCK WBxH4D2 #
1 +0.00000e+00 # cH
2 +0.00000e+00 # cT
BLOCK WBxH6 #
1 +0.00000e+00 # c6H
BLOCK WBxV2H2 #
1 +0.00000e+00 # cGG
- 2 +0.00000e+00 # tcGG
- 3 +0.00000e+00 # cWW
- 4 +0.00000e+00 # tcWW
- 5 +0.00000e+00 # cBB
- 6 +0.00000e+00 # tcBB
- 7 +0.00000e+00 # cWB
+ 2 +0.00000e+00 # cWW
+ 3 +0.00000e+00 # cBB
+ 4 +0.00000e+00 # cWB
+ 5 +0.00000e+00 # tcGG
+ 6 +0.00000e+00 # tcWW
+ 7 +0.00000e+00 # tcBB
8 +0.00000e+00 # tcWB
BLOCK WBxV3D3 #
1 +0.00000e+00 # c3W
2 +0.00000e+00 # c3G
3 +0.00000e+00 # tc3W
4 +0.00000e+00 # tc3G
BLOCK WBxd
1 1 +0.00000e+00 # Rcd1x1
2 2 +0.00000e+00 # Rcd2x2
3 3 +0.00000e+00 # Rcd3x3
BLOCK IMWBxd
1 1 +0.00000e+00 # Icd1x1
2 2 +0.00000e+00 # Icd2x2
3 3 +0.00000e+00 # Icd3x3
BLOCK WBxe
1 1 +0.00000e+00 # Rce1x1
2 2 +0.00000e+00 # Rce2x2
3 3 +0.00000e+00 # Rce3x3
BLOCK IMWBxe
1 1 +0.00000e+00 # Ice1x1
2 2 +0.00000e+00 # Ice2x2
3 3 +0.00000e+00 # Ice3x3
BLOCK WBxHd
1 1 +0.00000e+00 # RcHd1x1
2 2 +0.00000e+00 # RcHd2x2
3 3 +0.00000e+00 # RcHd3x3
BLOCK IMWBxHd
1 1 +0.00000e+00 # IcHd1x1
2 2 +0.00000e+00 # IcHd2x2
3 3 +0.00000e+00 # IcHd3x3
BLOCK WBxHe
1 1 +0.00000e+00 # RcHe1x1
2 2 +0.00000e+00 # RcHe2x2
3 3 +0.00000e+00 # RcHe3x3
BLOCK IMWBxHe
1 1 +0.00000e+00 # IcHe1x1
2 2 +0.00000e+00 # IcHe2x2
3 3 +0.00000e+00 # IcHe3x3
BLOCK WBxHl
1 1 +0.00000e+00 # RcHl1x1
2 2 +0.00000e+00 # RcHl2x2
3 3 +0.00000e+00 # RcHl3x3
BLOCK IMWBxHl
1 1 +0.00000e+00 # IcHl1x1
2 2 +0.00000e+00 # IcHl2x2
3 3 +0.00000e+00 # IcHl3x3
BLOCK WBxHpl
1 1 +0.00000e+00 # RcHpl1x1
2 2 +0.00000e+00 # RcHpl2x2
3 3 +0.00000e+00 # RcHpl3x3
BLOCK IMWBxHpl
1 1 +0.00000e+00 # IcHpl1x1
2 2 +0.00000e+00 # IcHpl2x2
3 3 +0.00000e+00 # IcHpl3x3
BLOCK WBxHpq
1 1 +0.00000e+00 # RcHpq1x1
2 2 +0.00000e+00 # RcHpq2x2
3 3 +0.00000e+00 # RcHpq3x3
BLOCK IMWBxHpq
1 1 +0.00000e+00 # IcHpq1x1
2 2 +0.00000e+00 # IcHpq2x2
3 3 +0.00000e+00 # IcHpq3x3
BLOCK WBxHq
1 1 +0.00000e+00 # RcHq1x1
2 2 +0.00000e+00 # RcHq2x2
3 3 +0.00000e+00 # RcHq3x3
BLOCK IMWBxHq
1 1 +0.00000e+00 # IcHq1x1
2 2 +0.00000e+00 # IcHq2x2
3 3 +0.00000e+00 # IcHq3x3
BLOCK WBxHu
1 1 +0.00000e+00 # RcHu1x1
2 2 +0.00000e+00 # RcHu2x2
3 3 +0.00000e+00 # RcHu3x3
BLOCK IMWBxHu
1 1 +0.00000e+00 # IcHu1x1
2 2 +0.00000e+00 # IcHu2x2
3 3 +0.00000e+00 # IcHu3x3
BLOCK WBxHud
1 1 +0.00000e+00 # RcHud1x1
2 2 +0.00000e+00 # RcHud2x2
3 3 +0.00000e+00 # RcHud3x3
BLOCK IMWBxHud
1 1 +0.00000e+00 # IcHud1x1
2 2 +0.00000e+00 # IcHud2x2
3 3 +0.00000e+00 # IcHud3x3
BLOCK WBxu
1 1 +0.00000e+00 # Rcu1x1
2 2 +0.00000e+00 # Rcu2x2
3 3 +0.00000e+00 # Rcu3x3
BLOCK IMWBxu
1 1 +0.00000e+00 # Icu1x1
2 2 +0.00000e+00 # Icu2x2
3 3 +0.00000e+00 # Icu3x3
################################################################################
################################################################################
\ No newline at end of file
diff --git a/Cards/WarsawBasis_universal.dat b/Cards/WarsawBasis_universal.dat
index 4c26862..b7e2af7 100644
--- a/Cards/WarsawBasis_universal.dat
+++ b/Cards/WarsawBasis_universal.dat
@@ -1,155 +1,144 @@
################################################################################
####################### ROSETTA: WARSAW BASIS INPUT CARD #######################
-###################### GENERATED FRI AUG 14 09:12:47 2015 ######################
+###################### GENERATED THU AUG 20 17:15:34 2015 ######################
################################################################################
BLOCK mass #
- 1 +4.80000e-03 # Mu
- 2 +2.30000e-03 # Md
- 3 +9.50000e-02 # Ms
- 4 +1.42000e+00 # Mc
- 5 +4.70000e+00 # Mb
- 6 +1.73000e+02 # Mt
- 11 +5.11000e-04 # Me
- 12 +0.00000e+00 # Mve
- 13 +1.05658e-01 # Mmu
- 14 +0.00000e+00 # Mvmu
- 15 +1.77680e+00 # Mta
- 16 +0.00000e+00 # Mvta
+ 25 +1.25000e+02 # MH
BLOCK sminputs #
1 +1.32507e+02 # aEWM1
2 +1.16639e-05 # Gf
3 +1.18000e-01 # aS
4 +9.11880e+01 # MZ
25 +1.25000e+02 # MH
###################################
## CKM INFORMATION
###################################
BLOCK VCKM
1 1 +9.74272e-01 # RVud1x1
1 2 +2.25349e-01 # RVus1x2
1 3 +1.21581e-03 # RVub1x3
2 1 -2.25208e-01 # RVcd2x1
2 2 +9.73440e-01 # RVcs2x2
2 3 +4.11845e-02 # RVcb2x3
3 1 +8.09744e-03 # RVtd3x1
3 2 -4.03991e-02 # RVts3x2
3 3 +9.99146e-01 # RVtb3x3
BLOCK IMVCKM
1 1 +0.00000e+00 # IVud1x1
1 2 +0.00000e+00 # IVus1x2
1 3 -3.20194e-03 # IVub1x3
2 1 -1.28479e-04 # IVcd2x1
2 2 -2.97171e-05 # IVcs2x2
2 3 +0.00000e+00 # IVcb2x3
3 1 -3.11693e-03 # IVtd3x1
3 2 -7.20944e-04 # IVts3x2
3 3 +0.00000e+00 # IVtb3x3
###################################
## INFORMATION FOR WARSAW BASIS
###################################
BLOCK basis #
1 warsaw # translated basis
BLOCK WBx4F #
1 +0.00000e+00 # cll1221
2 +0.00000e+00 # cll1122
3 +0.00000e+00 # cpuu3333
BLOCK WBxH4D2 #
1 +0.00000e+00 # cH
2 +0.00000e+00 # cT
BLOCK WBxH6 #
1 +0.00000e+00 # c6H
BLOCK WBxV2H2 #
1 +0.00000e+00 # cGG
- 2 +0.00000e+00 # tcGG
- 3 +0.00000e+00 # cWW
- 4 +0.00000e+00 # tcWW
- 5 +0.00000e+00 # cBB
- 6 +0.00000e+00 # tcBB
- 7 +0.00000e+00 # cWB
+ 2 +0.00000e+00 # cWW
+ 3 +0.00000e+00 # cBB
+ 4 +0.00000e+00 # cWB
+ 5 +0.00000e+00 # tcGG
+ 6 +0.00000e+00 # tcWW
+ 7 +0.00000e+00 # tcBB
8 +0.00000e+00 # tcWB
BLOCK WBxV3D3 #
1 +0.00000e+00 # c3W
2 +0.00000e+00 # c3G
3 +0.00000e+00 # tc3W
4 +0.00000e+00 # tc3G
BLOCK WBxd
1 1 +0.00000e+00 # Rcd1x1
BLOCK IMWBxd
1 1 +0.00000e+00 # Icd1x1
BLOCK WBxe
1 1 +0.00000e+00 # Rce1x1
BLOCK IMWBxe
1 1 +0.00000e+00 # Ice1x1
BLOCK WBxHd
1 1 +0.00000e+00 # RcHd1x1
BLOCK IMWBxHd
1 1 +0.00000e+00 # IcHd1x1
BLOCK WBxHe
1 1 +0.00000e+00 # RcHe1x1
BLOCK IMWBxHe
1 1 +0.00000e+00 # IcHe1x1
BLOCK WBxHl
1 1 +0.00000e+00 # RcHl1x1
BLOCK IMWBxHl
1 1 +0.00000e+00 # IcHl1x1
BLOCK WBxHpl
1 1 +0.00000e+00 # RcHpl1x1
BLOCK IMWBxHpl
1 1 +0.00000e+00 # IcHpl1x1
BLOCK WBxHpq
1 1 +0.00000e+00 # RcHpq1x1
BLOCK IMWBxHpq
1 1 +0.00000e+00 # IcHpq1x1
BLOCK WBxHq
1 1 +0.00000e+00 # RcHq1x1
BLOCK IMWBxHq
1 1 +0.00000e+00 # IcHq1x1
BLOCK WBxHu
1 1 +0.00000e+00 # RcHu1x1
BLOCK IMWBxHu
1 1 +0.00000e+00 # IcHu1x1
BLOCK WBxHud
1 1 +0.00000e+00 # RcHud1x1
BLOCK IMWBxHud
1 1 +0.00000e+00 # IcHud1x1
BLOCK WBxu
1 1 +0.00000e+00 # Rcu1x1
BLOCK IMWBxu
1 1 +0.00000e+00 # Icu1x1
################################################################################
################################################################################
\ No newline at end of file
diff --git a/README b/README
index dd515a3..d6bbcf3 100644
--- a/README
+++ b/README
@@ -1,520 +1,529 @@
################################################################################
Rosetta: A Higgs Effective Field Theory basis translator
Benjamin Fuks, Fabio Maltoni, Kentarou Mawatari,
Ken Mimasu, Veronica Sanz, Francesco Riva
Version 1.0, July 2015
################################################################################
Rosetta is a translation tool to aid in the Monte Carlo generation of events for
Higgs Effective Field Theory. The idea is to provide a simple way to map
different parametrisations of the deviations of Higgs couplings from SM
expectations to a single 'basis' of Wilson coefficients corresponding to
operators up to dimension 6.
Given an SLHA style input parameter card in the users basis of choice, Rosetta
has the capability to read in the parameters, calculate any dependent
parameters, perform a number of consistency checks with respect to required and
derived inputs and finally write out a new parameter card in the target basis.
The SHLA output for the default target, MassBasis, can be used as input to the
associated UFO model in a compatible event generator.
The tool consists of a Python package containing implementations of Higgs
Effective Theory bases and a command line tool 'translate' that performs the
task of mapping a given basis to a target output basis. The core of the package
is based on the contents of the LHC Higgs Cross Section Working Group (HXSWG)
note (LHCHXSWG-INT-2015-001).
################################################################################
Contents
################################################################################
1) Contact
2) Prerequisites
3) Usage
4) Input cards
5) The SLHA package
6) The basis class
7) Implementing your own basis
8) eHDECAY interface
################################################################################
1) Contact
################################################################################
Feel free to contact the authors with requests for features, bugs
etc. through k.mimasu@sussex.ac.uk.
################################################################################
2) Prerequisites
################################################################################
Python 2.7 or above in the 2.X series (not python 3).
################################################################################
3) Package Contents
################################################################################
Rosetta/ # Python package containing implementation of the basis
# translation machinery.
--> __init__.py # Assumes all files in the top directory other than
# itself are basis implementations and includes them
# in Rosetta's translation 'database'.
--> config.txt # file storing configuration variables
--> MassBasis.py # Basis class for the default target basis
# for output parameter cards, corresponds to the
# redundant set of operators defined in
# HiggsBasis.py without imposing any dependency
# conditions.
--> HiggsBasis.py # Basis class corresponding to the Higgs Basis as
# defined in the HXSWG draft. Using this basis as
# input calculates the dependent coefficients.
--> WarsawBasis.py # Basis class corresponding to the Warsaw Basis
# defined in arXiv:1008.4884 and the HXSWG draft.
--> SILHBasis.py # Basis class corresponding to the SILH Basis
# defined in e.g arXiv:1303.3876 and the HXSWG draft.
--> TemplateBasis.py # Template for a user-defined Basis class
# implemented in the Rosetta package. Toy versions
# of the calculate_dependent() and translation
# methods are implemented.
internal/
- --> __init__.py # Stores a number of useful dictionaries mapping PDG
+ --> __init__.py # Python module prerequisite.
+ --> constants.py # Stores a number of useful dictionaries mapping PDG
# particle IDs and SLHA input numbers to names,
# default values for SM inputs and particle masses
# etc.
--> Basis.py # Base basis class implementing internal methods
# such as reading/writing param cards and checking
# for required/calculated inputs. All basis classes
# are derived from this one.
--> SLHA.py # Machinery for reading, manipulating and writing
# SLHA style input cards. Implementation partly
# inspired by pySLHA (A. Buckley, arXiv:1305.4194).
--> eHDECAY.py # Interface with eHDECAY program (arXiv:1403.3381)
--> machinery.py # Constructs translation paths between bases.
--> matrices.py # Higher level matrix objects inheriting from
# structures in SLHA.py that can impose restrictions
# on the matrix properties such as herimticity etc.
# Also contains a number of matrix operations such
# as multiplication and element-wise addition for
# use in translation functions.
--> settings.py # Reader for config.txt
--> decorators.py # the @translation decorator used to identify
# translation functions and their target basis in
# basis implementations.
--> query.py # Yes/no query function borrowed from
# http://code.activestate.com/recipes/577058/.
Cards/ # Sample MG5-style parameter cards to be used as input.
HiggsBasis.dat # Sample HiggsBasis input parameter card
WarsawBasis.dat # Sample WarsawBasis input parameter card
SILHBasis.dat # Sample SILHBasis input parameter card
TemplateBasis.dat # Sample TemplateBasis input parameter card
_diagonal and _universal versions of thee card are also included reflecting the
-simplified input formats one can use when employing the --flavour option of
+simplified input formats one can use when employing the --flavor option of
translate
MassBasis.dat # Sample MassBasis output parameter card, needn't
# be used as input
translate # Command line tool to perform basis translation based on the
# implementations in Rosetta
################################################################################
3) Usage
################################################################################
The translate command line tool takes an SLHA-style param card (see sample
cards provided in Cards/ directory) in a particular basis and outputs a new
card in the specified basis (default is Mass Basis).
Command line documentation:
-
- >> usage: translate [-h] [-o OUTPUT] [-t TARGETBASIS] [-w] [-e] PARAMCARD
+
+ >> usage: translate [-h] [-o OUTPUT] [-t {silh,higgs,mass,template,warsaw}]
+ >> [-w] [-s] [-f {general,diagonal,universal,MFV}] [-e]
+ >> PARAMCARD
>>
>> Read in an SLHA format parameter card in a particular basis and write a
>> new card in another implemented basis.
>>
>> positional arguments:
>> PARAMCARD Input parameter card.
>>
>> optional arguments:
>> -h, --help show this help message and exit
>> -o OUTPUT, --output OUTPUT
>> Output file name. Default: [PARAMCARD]_new
- >> -t TARGETBASIS, --target TARGETBASIS
- >> Basis into which to translate (one of: silh,
- >> higgs, mass, template, warsaw). Default: mass
+ >> -t {silh,higgs,mass,template,warsaw}, --target {silh,higgs,mass,
+ >> template,warsaw}
+ >> Basis into which to translate, default: mass
>> -w, --overwrite Overwrite any pre-existing output file.
+ >> -s, --silent Suppress all warnings and take default answers to
+ >> all questions.
+ >> -f {general,diagonal,universal,MFV}, --flavour {general,diagonal,
+ >> universal,MFV}
+ >> Specify flavour structure, default : 'general'
>> -e, --ehdecay Interface with eHDECAY for Higgs branching
>> fractions.
- >> -f FLAVOUR, --flavour FLAVOUR
- Specify flavour structure ('general', 'diagonal',
- 'minimal'). Default : 'general'
-Rosetta will read the SLHA card, look for the 0th element of block "basis", and
+
+Rosetta will read the SLHA card, look for the 1st element of block "basis", and
see if any implemented basis classes have this unique identifier. If so, Rosetta
will fill an instance of this class with the values of the parameters specified
in the parameter card and perform certain consistency checks, making sure all
required parameters are defined etc. Any dependent parameters are then
calculated and the translation is performed between the input basis and the
target basis (mass basis by default), provided the right translation path
exists. An SLHA style parameter card wil then written out in the new basis.
Rosetta can optionally interface with eHDECAY provided a translation path
between the input basis and the SILH basis exists. The results of eHDECAY
are also written to the SLHA card in the form of a decay block for the Higgs.
See section 8 for more details on this.
Example basic usage:
To translate from the SILH basis to the Mass basis one could take
Cards/SILHBasis.dat as a template input card and run:
./translate -o my_out.dat my_input.dat
To translate to the Warsaw basis instead, one should use the -t option and
specify 'warsaw' as the target basis:
./translate -o my_out_warsaw.dat -t warsaw my_input.dat
-Example usage with the flavour option:
+Example usage with the flavor option:
-The flavour option '-f' currently accepts the arguments 'general', 'diagonal'
-and 'minimal'. It tells Rosetta to assume a particular flavour structure in the
+The flavor option '-f' currently accepts the arguments 'general', 'diagonal'
+and 'universal'. It tells Rosetta to assume a particular flavor structure in the
input file. When a translation to a basis which is NOT the mass basis is
specified via the '-t' option, the output file block structure also reflects
-this choice on the flavour structure.
+this choice on the flavor structure.
-- 'general' : The default setting corresponding to the full flavour structure.
-- 'diagonal': Keep only the diagonal terms in the flavour matrices i.e. the
+- 'general' : The default setting corresponding to the full flavor structure.
+- 'diagonal': Keep only the diagonal terms in the flavor matrices i.e. the
11,22,33 entries.
-- 'minimal' : Suppress all flavour indices. Coefficients are all flavour
+- 'universal' : Suppress all flavor indices. Coefficients are all flavor
diagonal and universal.
Thsi has been implemented in a simple way that relies on a particular naming
-convention for the flavoured coefficients. Namely, entries of a coefficient
-'XXX' should be appended to the name i.e. 'XXX11', 'XXX23' etc. If the
-coefficient is complex, the real and imaginary components should be labelled
-AFTER the flavour indices e.g.'XXX12Re', 'XXX12Im'.
-The function 'flavour_matrix' defined in Rosetta/internal/Basis.py is meant to
-help one generate flavour indices of a given coefficient according to the naming
-convention by specifying its properties such as 'hermitian' or 'symmetric'
-etc. It is used in the implementations of HiggsBasis, SILHBasis and WarsawBasis.
+convention for the flavored coefficients. Namely, entries of a coefficient
+'XXX' should be appended to the name i.e. 'XXX1x1', 'XXX2x3' etc. If the
+coefficient is complex, the real and imaginary components should be prefixed as
+'RXXX12' and 'IXXX12' respectively while the complex elements is prefixed with
+'C'.
As an example, taking Cards/WarsawBasis_diagonal.dat as a template input, the
command:
./translate -f diagonal -o my_out_diag.dat my_input_diagonal.dat
-Will generate a Mass basis param card with only the diagonal flavour
+Will generate a Mass basis param card with only the diagonal flavor
components non-zero. On the other hand,
./translate -t silh -f diagonal -o my_out_diag_silh.dat my_input_diagonal.dat
-Will generate a SILH basis parameter card respecting the original flavour
+Will generate a SILH basis parameter card respecting the original flavor
structure, i.e. that of Cards/SILHBasis_diagonal.dat.
In general, one should ensure that the block structure of the input card
-respects the flavour option specified, otherwise, Rosetta will crash.
+respects the flavor option specified, otherwise, Rosetta will crash.
Example usage with the eHDECAY option:
./translate -t silh -e -o my_out_ehdecay_silh.dat my_input.dat
This command will generate the same output as the basic usage example with the
addition of an SLHA decay block for the Higgs with the results of the eHDECAY
run. It will also save theeHDECAY input file fed to the program as 'ehdecay.in'.
################################################################################
4) Input cards
################################################################################
Rosetta is designed to read input cards in a format similar to the SUSY Les
Houches Accord (SLHA) detailed in http://arxiv.org/abs/hep-ph/0311123.
Sample cards can be found in the Cards/ directory.
The SHLA reader looks for block structures in a case insensitive way i.e.
>> BLOCK MYBLOCK
Specifically it will search for blocks MASS, SMINPUTS and BASIS. The basis into
which the card is read is taken from the 0 entry in the BASIS block. This name
should match a basis declared in implemented.py (see next section).
Block elements should be named by placing a comment alongside each
entry. The parameter name will be tken as the first non-whitespace characters
following the '#' character.
The main difference between the input format of Rosetta and SLHA is that names
of parameters are required for new physics parameter blocks. Parameters can
then be referenced by name or number in the corresponding block or,
alternatively, by name only from the SHLA.Card instance stored in as self.card
in the basis instance.
>>BLOCK MYBLOCK
>> 0 3.14159E+00 # pi
>> 1 1.97327E-01 # hbarc_GeVfm
>> Block sminputs
>> 1 1.325070e+02 # aEWM1 (white space doesn't matter)
ETC.
The block structure of the new physics couplings is basis dependent and should
be declared in the `blocks` data member of the basis class. This should be a
python dictionary with block names as keys and lists of parameter names as
values. The ordering of the list determines the entry number of each parameter.
For example,
>> blocks = {'ONE':['A','B','C'], 'TWO':['D','E','F']}
will generate the following block structure:
>> block one
>> 0 0.0 # A
>> 1 0.0 # B
>> 2 0.0 # C
>>
>> block two
>> 0 0.0 # D
>> 1 0.0 # E
>> 2 0.0 # F
The reader reads all lines until the next occurrence of 'BLOCK' or 'DECAY',
ignoring leading and trailing white space and all lines beginning with a '#' as
well as lines that do not match the expected pattern detailed above. For blocks
BLOCKIN and SMINPUTS, the reader stores special SLHA.Block instances as
self.mass and self.inputs data member of the basis instace.
>> block mass
>> 5 4.700000e+00 # MB
>> 6 1.730000e+02 # MT
>> 15 1.730000e+02 # MTAU
>> 23 9.118800e+01 # MZ
>> 25 1.250000e+02 # MH
Block basis should have one element corresponding to the "name" attribute of an
existing basis implementation.
>> block BASIS
>> 0 MyBasis # name of basis
################################################################################
5) The SLHA package
################################################################################
Rosetta contains a basic SLHA card reader/writer that can parse and store the
contents of an SLHA formatted input card. Individual blocks and decays are
stored as SLHA.Block and SLHA.Decay instances which are subclasses of
`OrderedDict`, meaning they can be indexed and iterated over in the same way.
SLHA.Block is essentially a named OrderedDict storing index:value pairs
corresponding to the elements of an SLHA block. SLHA.Block has a "name"
attribute and forces keys to be of type `int` or to be castable via int().
SLHA.Decay is an OrderedDict with a "PID" attribute for the particle whose
decay information it contains as well as a "total" attribute to store the
total width of the particle. Each entry key is a tuple if PIDs corresponding
to the decay products and the associated value is the branching fraction of
that particular channel.
SLHA.NamedBlock is a subclass of SHLA.Block with the additional feature that
each block entry is associated to a name in accordance with the way Rosetta
can read the input card. Each value can then be accessed either by key or
by value.
SLHA.Card is the object storing the various SLHA blocks and decays. Indexing
such an object with an integer will look for a Decay object associated to
that PID, while indexing with a string will look for a parameter with that
name in one of its NamedBlock instances. SLHA.Card objects possess two
OrderedDicts, "blocks" and "decays" storing the individual
SLHA.(Named)Block and SLHA.Decay instances.
Each SLHA object can print itself out in the usual SLHA format, while the
SLHA.Card object has a write() function to write itself to a file.
################################################################################
6) The basis class
################################################################################
Each implemented basis in Rosetta is a python class inheriting from the `Basis`
class in Rosetta/internal/Basis.py. They are designed to be instantiated with
an SLHA format parameter card using read_param_card(). The contents of the card
are stored as an SLHA.Card object and the special blocks "mass" and "sminputs"
are stored as SLHA.NamedBlock instances in self.mass and self.input
respectively. Some of the key data members are:
self.name
- Unique basis identifier. This will be compared to the 0th element
of the block basis in the SLHA parameter card to ensure that
right basis class is being instantiated for a given input card.
self.card
- SLHA.Card instance containing SLHA.NamedBlock and SLHA.Decay
instances corresponding to those specified in the parameter card.
Object names taken to be the first non-whitespace characters
after a "#" character in a block or parameter definition are also
stored.
self.mass
- SLHA.NamedBlock instance for the "mass" block
self.inputs
- SLHA.NamedBlock instance for the "sminputs" block
self.name - Unique basis identifier
self.required_inputs
- A set of SLHA input IDs denoting those required to be defined in
the SLHA input card in order to perform implemented translations.
self.required_masses
- A set of PDG particle IDs denoting particles whose mass is
required to be defined in the SLHA input card in order to perform
implemented translations.
self.independent
- A list of coefficients deemed to be input parameters to the basis
implementation.
self.blocks (optional but strongly recommended)
- A dictionary of name:coefficients pairs where name is the SLHA
block name desired and coefficients is a list of coefficient
names associated to that block.
self.blocks, self.required_inputs and self.required_masses should be defined in
accordance with block structure of the input SLHA parameter card, Blocks
"sminput" and "mass" respectively (the Z ahd Higgs masses are also stored in
self.inputs). Specifically, the block names specified as keys in self.blocks
should match block names in the SLHA card as well as the names and indices of
their elements (taken to be the order in which the appear in the list
associated the the block in self.blocks). The blocks "mass" and "sminputs" of
the SLHA card should minimally contain the entries specified in required_masses
and required_inputs respectively. A number of checks related to these
definitions are performed by check_param_data(), check_mass() and
check_sminputs() on the data read in from the parameter card.
Basis and any of its subclasses are designed to work similarly to a
dictionary in that parameter values can be referenced by name (duplicate
names in different blocks are not handled properly so try to avoid them).
A value can be referenced in various ways, see below example where the
parameter named 'D' is stored as entry 3 in the block 'letters' written in
'mycard.dat':
>> instance = MyBasis(param_card='mycard.dat')
>> instance['A'] = 0.5 # set value according to name in SLHA card
>> instance.card['A'] = 0.5 # equivalent to the above
>> instance.card.blocks['letters']['A'] = 0.5 # from block by name
>> instance.card.blocks['letters'][3] = 0.5 # from block by entry
A number of other container methods are defined for easy of manipulation:
>> print len(instance) # number of EFT coefficients
>> for i in instance: # iterator methods also defined
>> print i
>> for k, v in instance.items(): # name, value pairs
>> print k, v
write_param_card() writes the contents of the self.newcard into a new SLHA
formatted file. Another useful method write_template_card() generates and empty
parameter card according to the block definitions and required inputs of a
given basis class.
################################################################################
7) Implementing your own basis
################################################################################
Implementing ones own basis involves creating a file inside the root directory
of Rosetta, alongside HiggsBasis etc., containing a subclass of Basis. The
only required data member to be defined is self.name. However, users will
mostly likely want to define self.independent, self.required_inputs and
self.required_masses as well as structure their basis into blocks using
self.blocks (Rosetta will create one block named "newcoup" if self.blocks is
not defined). An example is shown below where the required data members are
defined outside the class construtor so as to instrinsically belong to all
instances of the class. This code would be saved in Rosetta/MyBasis.py. It is
essential that the file name match the class name.
>> from internal import Basis
>> class MyBasis(Basis.Basis):
>> name = 'mybasis'
>> independent = {'A','B','C','1','2','3'}
>> required_inputs = {1,2,4} # a_{EW}^{-1}, Gf and MZ required
>> required_masses = {24,25,6} # Z, Higgs and top masses required
>> blocks = {'letters':['A','B','C','D']
>> 'numbers':['1','2','3','4']} # Expected block structure
The list self.independent stores the basis parameters which should be read
in from the SLHA card. Any other parameters declared in self.blocks are assumed
to be set by the user in the calculate_dependent() method. The user can define
calculate_dependent() to set any dependent parameters (those listed in in
self.blocks but not in self.independent) and any number of additional
functions, usually to translate the coefficients into a given basis which sets
the SLHA.Card object, self.newcard.
Rosetta differentiaties from general utility functions and translation
functions using the "translation" decorator. Any function designed to take you
to another existing basis implemenation should be decorated with the
"translation" decorator with an argument corresponding to the name of the
target basis. This name should match the unique name of an existing basis
implementation also contained in the Rosetta root directory. Below would be
example of a translation function from our example to the Warsaw Basis.
>> @Basis.translation('warsaw') # identifies as translator to warsaw
>> def mytranslation(self, instance):
>> instance['cWW'] = 10.
>> instance['cpHl11'] = self['myparam']
>> return instance
The translating function must ONLY take an instance of the target class as its
second argument alongside the default "self" argument for a class method. In
this way, Rosetta can universally and automatically detect and use intended
translation functions.
+Additional modifications to e.g. SM input parameters or marticle masses should
+be implemented in the modify_inputs() function.
+
+ >> def modify_inputs(self):
+ >> self.mass[24]= 100.
+
Any python module saved in the root directory of the Rosetta package is
assumed to be a basis implementation. Furthermore, the class name of the
basis implementation MUST be the same as the file name of the python
module. In our example above, the class `MyBasis` would have to be saved in
a file named MyBasis.py. This is to help Rosetta automatically identify the
possible translation paths between bases. Any such class can then be used
by the command line script "translate". For example, Rosetta should be able
to figure out all possible multi-step translations.
The user is referred to Rosetta/TemplateBasis.py for a toy working example of a
user defined basis.
################################################################################
8) eHDECAY interface
################################################################################
A useful program based on HDECAY (arXiv:hep-ph/9704448) for calculating the
Higgs total width was developed in 2014 and is described in arXiv:1403.3381.
The program takes as input a number of parameters in the SILH basis to calculate
the width and branching ratios to SM particles optionally including Electroweak
corrections. In order to have this working correctly the user must modify
Rosetta/config.txt, putting the absolute path to the base directory of a local
eHDECAY installation. It goes without saying that there must exist a possible
translation path between the input basis and the SILH basis. The
internal/eHDECAY.py module then performs this translation, rescales the
relevant parameters of the Rosetta SILH basis implementation to match the
conventions of arXiv:1403.3381 and executes a run of eHDECAY. The results are
stored and a copy of the input file "ehdecay.in" is saved locally. The results
are then written to and SLHA decay block in the output card. The relevant
input parameters are:
SM inputs: # ALL masses must be nonzero for eHDECAY to give a finite result
'MC', 'MB', 'MT', 'MMU', 'MTAU, # SM fermion masses
'MH', 'MZ', 'MW', 'aEWM1' 'Gf', # EW input masses, (alpha_EW)^-1, G_Fermi
'aSMZ' # alpha_S(MZ)
SILH coefficients:
'CHbar' , 'CTbar' , 'Ctaubar', 'Cmubar', 'Ctbar',
'Cbbar' , 'Ccbar' , 'Csbar' , 'CWbar' , 'CBbar',
'CHWbar', 'CHBbar', 'Cgambar', 'Cgbar'
eHDECAY option:
'IELW' # Electroweak corrections switch (1:on, 0:off)
eHDECAY can potentially give negative branching fractions and even a negative
total Higgs width for unreasonable choices of EFT parameters. A negative total
width is currently not allowed while negative branching fractions are not
handled and will be written to the parameter card.
################################################################################
Rosetta: A Higgs Effective Field Theory basis translator
################################################################################
diff --git a/Rosetta/HiggsBasis.py b/Rosetta/HiggsBasis.py
index 4b9fbbc..5de8234 100644
--- a/Rosetta/HiggsBasis.py
+++ b/Rosetta/HiggsBasis.py
@@ -1,409 +1,409 @@
from internal import Basis
from internal.matrices import matrix_mult, matrix_add, matrix_sub, matrix_eq
import MassBasis as MB
import sys
import math, re
from math import sqrt
from itertools import combinations_with_replacement as comb
from itertools import product
-from internal import PID
+from internal.constants import PID
################################################################################
MassBasis = MB.MassBasis
################################################################################
class HiggsBasis(Basis.Basis):
'''
Main basis class for Rosetta, based on the reccomendation for the
parametrisation of Higgs Effective Field theory in the LHC Higgs cross
section working group note (LHCHXSWG-INT-2015-001). Part of the three
intrinsic basis implementations in Rosetta along with the Warsaw and SILH
bases. This implementation includes almost all operators listed in the note
apart from the dipole-type Lorentz structures (\sigma^{\mu\nu}). The
implementation only includes the minimal set (3) of four-fermion operators
required to consistently map between the three intrinsic bases as defined
in the note. A number of structures involving more than two Higgs fields
(apart from the triple Higgs vertex) or interactions between a single higgs
field and 3 or more gauge bosons are not currently included. Besides this,
the Higgs Basis encodes relations between certain parameters to ensure
SU(2)xU(1) invariance such that it is consistent with a dimension six
operator basis for an effective field theory with linearly realised
- electroweak symmetry breaking (in unitary gauge) and a general flavour
+ electroweak symmetry breaking (in unitary gauge) and a general flavor
structure. These relations are implemented in calculate_dependent().
'''
name='higgs'
##########################
# declare coefficients
# kinetic terms [Eqn. (3.3)]
HBxMASS = ['dM']
# triple gauge couplings [Eqn. (3.6)]
HBxTGC = ['Lz', 'tLz', 'C3g', 'tC3g', 'dKa', 'tKa',
'dG1z', 'dKz', 'tKz', 'La', 'tLa']
# quartic gauge couplings [Eqn. (3.7)]
HBxQGC = ['dGw4','dGw2z2','dGw2za',
'Lw4', 'Lw2z2', 'Lw2a2', 'Lw2az', 'Lw2za', 'C4g',
'tLw4', 'tLw2z2', 'tLw2a2', 'tLw2az', 'tLw2za', 'tC4g']
# single Higgs couplings [Eqn. (3.8)]
HBxh = ['dCz',
'Cgg', 'Caa', 'Cza', 'Czz', 'Czbx', 'Cabx',
'tCgg', 'tCaa', 'tCza', 'tCzz',
'dCw', 'Cww', 'Cwbx', 'tCww' ]
# double Higgs couplings [Eqn. (3.13)]
HBxhh = ['dCw2', 'dCz2', 'Cww2', 'Cwbx2',
'Cgg2', 'Caa2', 'Cza2', 'Czz2', 'Czbx2', 'Cabx2',
'tCww2', 'tCgg2', 'tCaa2', 'tCza2', 'tCzz2']
# Higgs self couplings [Eqn. (3.12)]
HBxhself = ['dL3', 'dL4']
# 4-fermion operators
HBx4F = ['cll1122', 'cpuu3333', 'cll1221']
##########################
# block structure
blocks = {'HBxMASS':HBxMASS, 'HBxTGC':HBxTGC, 'HBxQGC':HBxQGC,
'HBxh':HBxh, 'HBxhh':HBxhh, 'HBxhself':HBxhself, 'HBx4F':HBx4F}
- # copy flavoured block structure from MassBasis.MassBasis
- flavoured = {k.replace('MB','HB'):v for k,v in MassBasis.flavoured.iteritems()}
+ # copy flavored block structure from MassBasis.MassBasis
+ flavored = {k.replace('MB','HB'):v for k,v in MassBasis.flavored.iteritems()}
# independent coefficients
independent = [
# [Eqn. (5.1)]
'dM',
'HBxdGLze', 'HBxdGRze', 'HBxdGLwl', 'HBxdGLzu',
'HBxdGRzu', 'HBxdGLzd', 'HBxdGRzd', 'HBxdGRwq',
'HBxdgu', 'HBxdgd', 'HBxdau', 'HBxdad', 'HBxdae',
'HBxdzu', 'HBxdzd', 'HBxdze', 'HBxdwq', 'HBxdwl',
'HBxtdgu', 'HBxtdgd', 'HBxtdau', 'HBxtdad', 'HBxtdae',
'HBxtdzu', 'HBxtdzd', 'HBxtdze', 'HBxtdwq', 'HBxtdwl',
# [Eqn. (5.2)]
'Cgg', 'dCz', 'Caa', 'Cza', 'Czz', 'Czbx', 'tCgg', 'tCaa', 'tCza', 'tCzz',
'HBxdYu', 'HBxdYd', 'HBxdYe', 'HBxSu', 'HBxSd', 'HBxSe', 'dL3',
# [Eqn. (5.3)]
'Lz', 'tLz', 'C3g', 'tC3g',
'cll1122','cpuu3333'
]
# Required inputs/masses
# required_masses = {1, 2, 3, 4, 5, 6, 11, 12, 13, 14, 15, 16, 25}
required_masses = {25}
required_inputs = {1, 2, 3, 4} # aEWM1, Gf, aS, MZ
##########################
def calculate_inputs(self): # calculate a few required EW params from aEWM1, Gf, MZ
ee2 = 4.*math.pi/self.inputs['aEWM1'] # EM coupling squared
gs2 = 4.*math.pi*self.inputs['aS'] # strong coupling squared
Gf, MZ = self.inputs['Gf'], self.inputs['MZ']
s2w = (1.- sqrt(1. - ee2/(sqrt(2.)*Gf*MZ**2)))/2. # sin^2(theta_W)
c2w = (1.-s2w)
gw2 = ee2/s2w # SU(2) coupling squared
gp2 = gw2*s2w/c2w # Hypercharge coupling squared
vev = 2.*MZ*sqrt(c2w/gw2)
return s2w, c2w, ee2, gw2, gp2, MZ, vev, gs2
def calculate_dependent(self):
s2w, c2w, ee2, gw2, gp2, MZ, vev, gs2 = self.calculate_inputs()
A = self
MW = MZ*sqrt(c2w)
MH = self.mass[25]
def delta(i,j):
return 1. if i==j else 0.
# Higgs and EW gauge bosons [Sec 5.2] [eqn (5.5)]
A['dCw'] = A['dCz'] + A['dM']*4.
A['Cww'] = A['Czz'] + A['Cza']*2.*s2w + A['Caa'] *s2w**2
A['tCww'] = A['tCzz'] + A['tCza']*2.*s2w + A['tCaa']*s2w**2
A['Cwbx'] = (A['Czbx']*gw2 + A['Czz']*gp2 - A['Caa']*ee2*s2w
- A['Cza']*(gw2-gp2)*s2w )/(gw2-gp2)
A['Cabx'] = (A['Czbx']*2.*gw2 + A['Czz']*(gw2+gp2)
- A['Caa']*ee2 - A['Cza']*(gw2-gp2))/(gw2-gp2)
# Higgs self couplings [eqn (5.7)]
A['dL4'] = 3./2.*A['dL3'] - MH**2/vev**2/6.*A['dCz']
# dependent dgV coeffs [eqn (5.9)]
matrix_add(A['HBxdGLze'], A['HBxdGLwl'], A['HBxdGLzv'])
# dGLwq = dGLzu.VCKM - VCKM.dGLzd [eqn (5.9)]
matrix_sub(matrix_mult(A['HBxdGLzu'], A.ckm),
matrix_mult(A.ckm, A['HBxdGLzd']),
A['HBxdGLwq'])
# list of all z/w vertex correction blocks
vertex = ['HBxdGLze', 'HBxdGRze', 'HBxdGLzv', 'HBxdGLzu', 'HBxdGRzu',
'HBxdGLzd', 'HBxdGRzd', 'HBxdGLwl', 'HBxdGLwq', 'HBxdGRwq']
# list of all z/w/a dipole interaction blocks
dipole = ['HBxdgu', 'HBxdgd', 'HBxdau', 'HBxdad', 'HBxdae',
'HBxdzu', 'HBxdzd', 'HBxdze', 'HBxdwq', 'HBxdwl',
'HBxtdgu', 'HBxtdgd', 'HBxtdau', 'HBxtdad', 'HBxtdae',
'HBxtdzu', 'HBxtdzd', 'HBxtdze', 'HBxtdwq', 'HBxtdwl']
# HVFF coeffs and dipole-like Higgs couplings [Eqns. (3.10) & (5.6)]
for dG in vertex + dipole:
dGh = dG[:-2]+'h'+dG[-2:]
matrix_eq(A[dG], A[dGh])
# Triple gauge couplings [Sec 3.7] [eqn (3.21)]
A['dG1z'] = (A['Caa']*ee2*gp2 + A['Cza']*(gw2-gp2)*gp2
- A['Czz']*(gw2+gp2)*gp2 - A['Czbx']*(gw2+gp2)*gw2
)/2./(gw2-gp2)
A['dKa'] = - (A['Caa']*ee2 + A['Cza']*(gw2-gp2)
- A['Czz']*(gw2+gp2) )*gw2/2./(gw2+gp2)
A['tKa'] = - ( A['tCaa']*ee2 + A['tCza']*(gw2-gp2)
- A['tCzz']*(gw2+gp2))*gw2/2./(gw2+gp2)
A['dKz'] = A['dG1z'] - gp2/gw2*A['dKa']
A['tKz'] = - A['tKa']*gp2/gw2
A['La'] = A['Lz']
A['tLa'] = A['tLz']
# Quartic gauge couplings [Sec 3.7] [eqn (3.23)]
A['dGw4'] = 2.*c2w*A['dG1z']
A['dGw2z2'] = 2.*A['dG1z']
A['dGw2za'] = A['dG1z']
# two derivative quartic gauge couplings [Sec 3.7] [eqn (3.24)]
A['Lw4'] = -gw2/2./MW**2*A['Lz']
A['tLw4'] = -gw2/2./MW**2*A['tLz']
A['Lw2z2'] = -gw2*c2w/MW**2*A['Lz']
A['tLw2z2'] = -gw2*c2w/MW**2*A['tLz']
A['Lw2za'] = -ee2/MW**2*A['Lz']
A['tLw2za'] = -ee2/MW**2*A['tLz']
A['Lw2a2'] = -sqrt(ee2*gw2*c2w)/MW**2*A['Lz']
A['tLw2a2'] = -sqrt(ee2*gw2*c2w)/MW**2*A['tLz']
A['Lw2az'] = -sqrt(ee2*gw2*c2w)/MW**2*A['Lz']
A['tLw2az'] = -sqrt(ee2*gw2*c2w)/MW**2*A['tLz']
A['C4g'] = 3.*sqrt(gs2)**3/vev**2*A['C3g']
A['tC4g'] = 3.*sqrt(gs2)**3/vev**2*A['tC3g']
# Couplings of two Higgs bosons [Sec 3.8] [eqn (3.27)]
A['Cgg2'], A['tCgg2'] = A['Cgg'], A['tCgg']
A['dCz2'] = A['dCz']
A['dCw2'] = A['dCw'] + 3.*A['dM']
hvv = ['Cww', 'Cwbx', 'Cgg', 'Caa', 'Cza', 'Czz', 'Czbx', 'Cabx',
'tCww', 'tCgg', 'tCaa', 'tCza', 'tCzz']
for cvv in hvv:
cvv2 = cvv + '2'
A[cvv2] = A[cvv]
for f in ('u','d','e'):
yuk = 'HBxdY' + f
sin = 'HBxS' + f
yuk2 = 'HBxY2' + f
for i,j in A[yuk].keys():
Yij = A[yuk][i,j]
sinij = A[sin][i,j]
cosij = sqrt(1. - sinij**2)
re, im = (3.*Yij*cosij - A['dCz']*delta(i,j)), 3.*Yij*sinij
A[yuk2][i,j] = complex(re, im)
# 4-fermion operators [Sec. 3.9]
# [eqn (3.32)]
A['cll1221'] = (A['HBxdGLwl'][1,1].real
+ A['HBxdGLwl'][2,2].real - 2.*A['dM'])*2.
@Basis.translation('mass')
def to_mass(self, instance):
# trivial translation
for k, v in self.iteritems():
instance[k] = v
return instance
@Basis.translation('warsaw')
def to_warsaw(self, wbinstance):
def delta(i,j):
return 1. if i==j else 0.
H = self
W = wbinstance
s2w, c2w, ee2, gw2, gp2, MZ, vev, gs2 = self.calculate_inputs()
MH = self.mass[25]
dM, dCz = H['dM'], H['dCz']
W['cll1221'] = (H['HBxdGLwl'][1,1].real
+ H['HBxdGLwl'][2,2].real - 2.*dM)*2.
for w,h in [('',''),('t','T')]: # CP even and odd sum
Cgg, Caa = H['%sCgg' % h], H['%sCaa' % h]
Czz, Cza = H['%sCzz' % h], H['%sCza' % h]
W['%scGG' % w] = Cgg
W['%scWW' % w] = Czz + ( Caa*gp2 + 2.*Cza*(gw2 + gp2)
)*gp2/(gw2 + gp2)**2
W['%scBB' % w] = Czz + ( Caa*gw2 - 2.*Cza*(gw2 + gp2)
)*gw2/(gw2 + gp2)**2
W['%scWB' % w] = Czz/2. - ( Caa*gw2*gp2 + Cza*(gw2**2-gp2**2)
)/2./(gw2 + gp2)**2
Czz, Caa = H['Czz'], H['Caa']
Czbx, Cza = H['Czbx'], H['Cza']
W['cH'] = ( ( Caa*gw2**2*gp2**2
+ Cza*gw2*gp2*(gw2**2 - gp2**2)
- Czz*gw2*gp2*(gp2 + gw2)**2
- Czbx*gw2**2*(gp2 + gw2)**2
)*3./(2.*(gw2 - gp2)*(gw2 + gp2)**2)
- 3.*dM - dCz)
cH = W['cH']
W['cT'] = ((- Caa*gp2*gw2
- Cza*(gw2**2-gp2**2)
+ (Czbx+Czz)*(gp2 + gw2)**2
)*gp2*gw2/(2.*(gw2 - gp2)*(gw2 + gp2)**2)
+ dM)
cT = W['cT']
for i,j in H['HBxdGLzu'].keys():
fac = (dM-cT)*delta(i,j)
facp = -(dM + (cH + dCz)/3.)*delta(i,j)
W['WBxHq'][i,j] = (fac/3. - H['HBxdGLzu'][i,j] - H['HBxdGLzd'][i,j])
W['WBxHu'][i,j] = 4./3.*fac - 2.*H['HBxdGRzu'][i,j]
W['WBxHd'][i,j] = -2./3.*fac - 2.*H['HBxdGRzd'][i,j]
W['WBxHpq'][i,j] = (facp + H['HBxdGLzu'][i,j] - H['HBxdGLzd'][i,j])
W['WBxHl'][i,j] = -(fac + 2.*H['HBxdGLze'][i,j] + H['HBxdGLwl'][i,j])
W['WBxHpl'][i,j] = facp + H['HBxdGLwl'][i,j]
W['WBxHe'][i,j] = -2.*fac - 2.*H['HBxdGRze'][i,j]
for k,v in H['HBxdGRwq'].iteritems():
W['WBxHud'][k] = -2.*v
W['c6H'] = (3.*dCz + 8.*dM +
4*( - Caa*gw2**2*gp2**2
- Cza*gw2*gp2*(gw2**2-gp2**2)
+ Czz*gw2*gp2*(gw2+gp2)**2
+ Czbx*gw2**2*(gw2+gp2)**2
)/(gw2 - gp2)/(gw2+gp2)**2
)*MH**2/(2.*vev**2) - H['dL3']
for f in ('u','d','e'):
for i,j in H['HBxdY'+f].keys():
diag = delta(i,j)*(dCz-2.*cH)/3.
yuk = H['HBxdY'+f][i,j]
sin = H['HBxS'+f][i,j]
cos = sqrt(1.-sin**2)
re = ( yuk*cos - diag )*sqrt(2.)
im = yuk*sin*sqrt(2.)
W['WBx'+f][i,j] = complex(re, im)
W['c3G'], W['tc3G'] = H['C3g'], H['tC3g']
W['c3W'], W['tc3W'] = -2./3./gw2**2*H['Lz'], -2./3./gw2**2*H['tLz']
W['cll1122'], W['cpuu3333'] = H['cll1122'], H['cpuu3333']
return W
@Basis.translation('silh')
def to_silh(self,instance):
H = self
S = instance
s2w, c2w, ee2, gw2, gp2, MZ, vev, gs2 = self.calculate_inputs()
MH = self.mass[25]
dM, dCz = H['dM'], H['dCz']
def delta(i,j):
return 1. if i==j else 0.
for s,h in [('',''),('t','T')]: # CP even and odd sum
Cgg, Caa = H['%sCgg' % h], H['%sCaa' % h]
Czz, Cza = H['%sCzz' % h], H['%sCza' % h]
S['%ssGG' % s] = Cgg
S['%ssHW' % s] = - ( gp2**2*Caa + 2.*gp2*(gp2 + gw2)*Cza
)/(gw2 + gp2)**2 - Czz
S['%ssHB' % s] = ( gp2*(gp2 + 2.*gw2)*Caa + 2.*gw2*(gp2 + gw2)*Cza
)/(gw2 + gp2)**2 - Czz
S['%ssBB' % s] = Caa
Czz, Caa = H['Czz'], H['Caa']
Czbx, Cza = H['Czbx'], H['Cza']
S['sBB'] = Caa
S['s2W'] = (H['HBxdGLwl'][1,1].real
+ H['HBxdGLwl'][2,2].real - 2.*dM)*2./gw2
S['s2B'] = (H['cll1122'] + H['HBxdGLwl'][1,1].real
+ H['HBxdGLwl'][2,2].real - 2.*dM)*2./gp2
S['s2G'] = 3.*H['cpuu3333']/gs2
S['sB'] = (( gp2**2*Caa
- 2.*gw2*(gp2+gw2)*Czbx
- (gp2+gw2)**2*Czz
)/(gw2**2-gp2**2) -
4.*( H['cll1122'] - 2.*H['HBxdGLze'][1,1,].real
+ H['HBxdGLwl'][2,2].real - 2.*dM
)/gp2)
S['sW'] = (( -gp2**2*Caa
+ 2.*gw2*(gp2+gw2)*Czbx
+ (gp2+gw2)**2*Czz
)/(gw2**2-gp2**2) -
4.*( H['HBxdGLwl'][2,2].real - 2.*dM
)/gw2)
S['sHW'] = -( gp2**2*Caa
+ 2.*gp2*(gp2 + gw2)*Cza
)/(gw2 + gp2)**2 - Czz
S['sHB'] = ( gp2*(gp2 + 2.*gw2)*Caa
+ 2.*gw2*(gp2 + gw2)*Cza
)/(gw2 + gp2)**2 - Czz
S['sH'] = (H['HBxdGLwl'][1,1].real - H['HBxdGLwl'][2,2].real)*3./2.-dCz
S['sT'] = (H['HBxdGLwl'][1,1].real - H['HBxdGLwl'][2,2].real
- H['cll1122'] + 4.*dM + 4.*H['HBxdGLze'][1,1].real )/2.
S['s3G'], S['ts3G'] = H['C3g'], H['tC3g']
S['s3W'], S['ts3W'] = -2./3./gw2**2*H['Lz'], -2./3./gw2**2*H['tLz']
S['s6H'] = (3.*dCz - 4.*H['HBxdGLwl'][1,1].real
+ 4.*H['HBxdGLwl'][2,2].real )*MH**2/(2.*vev**2) - H['dL3']
for i, j in H['HBxdGLzu'].keys():
fac = -delta(i,j)*(4.*H['HBxdGLze'][1,1].real
+ 2.*H['HBxdGLwl'][1,1].real)
facp = -delta(i,j)*H['HBxdGLwl'][1,1].real
S['SBxHq'][i,j] = (fac/6. - H['HBxdGLzu'][i,j]
- H['HBxdGLzd'][i,j])
S['SBxHu'][i,j] = 2./3.*fac - 2.*H['HBxdGRzu'][i,j]
S['SBxHd'][i,j] = -1./3.*fac - 2.*H['HBxdGRzd'][i,j]
S['SBxHpq'][i,j] = (facp + H['HBxdGLzu'][i,j]
- H['HBxdGLzd'][i,j])
S['SBxHl'][i,j] = (- fac/2. - 2.*H['HBxdGLze'][i,j]
- H['HBxdGLwl'][i,j])
S['SBxHpl'][i,j] = facp + H['HBxdGLwl'][i,j]
S['SBxHe'][i,j] = - fac - 2.*H['HBxdGRze'][i,j]
for k, v in H['HBxdGRwq'].iteritems():
S['SBxHud'][k] = -2.*v
for f in ('u','d','e'):
for i,j in H['HBxdY'+f].keys():
diag = delta(i,j)*(dCz - H['HBxdGLwl'][1,1].real
+ H['HBxdGLwl'][2,2].real)
yuk = H['HBxdY'+f][i,j]
sin = H['HBxS'+f][i,j]
cos = sqrt(1.-sin**2)
re = ( yuk*cos - diag )*sqrt(2.)
im = yuk*sin*sqrt(2.)
S['SBx'+f][i,j] = complex(re, im)
return S
def modify_inputs(self):
'''
W mass modification from dM.
'''
s2w, c2w, ee2, gw2, gp2, MZ, vev, gs2 = self.calculate_inputs()
MW = MZ*sqrt(c2w)
if 24 in self.mass:
self.mass[24] = MW + self['dM']
else:
self.mass.new_entry(24, MW + self['dM'], name = 'MW')
################################################################################
\ No newline at end of file
diff --git a/Rosetta/MassBasis.py b/Rosetta/MassBasis.py
index 84fa498..90065b8 100644
--- a/Rosetta/MassBasis.py
+++ b/Rosetta/MassBasis.py
@@ -1,140 +1,140 @@
from internal import Basis
import math
from math import sqrt
################################################################################
class MassBasis(Basis.Basis):
'''
The main output basis for the Rosetta translation module. Based entirely on
the Higgs basis parametrisation without assuming the SU(2)xU(1) preserving
relations. It is a general collection of most possible Lorentz and charge
conserving structures at dimension 6 excluding those not described in the
current incarnation of the Higgs basis. Most importantly, a FeynRules/UFO
implementation of the interactions in this model is associated with Rosetta
and can be found at https://feynrules.irmp.ucl.ac.be/wiki/EFTmassbasis.
'''
name ='mass'
# kinetic terms [Eqn. (3.3)]
MBxMASS = ['dM']
# triple gauge couplings [Eqn. (3.6)]
MBxTGC = ['dKa', 'dKz', 'dG1z', 'La', 'Lz', 'C3g',
'tKa', 'tKz', 'tLa', 'tLz', 'tC3g']
# quartic gauge couplings [Eqn. (3.7)]
MBxQGC = ['dGw4','dGw2z2','dGw2za',
'Lw4', 'Lw2z2', 'Lw2a2', 'Lw2az', 'Lw2za', 'C4g',
'tLw4', 'tLw2z2', 'tLw2a2', 'tLw2az', 'tLw2za', 'tC4g']
# single Higgs couplings [Eqn. (3.8)]
MBxh = ['dCw', 'dCz', 'Cww', 'Cgg', 'Caa', 'Cza', 'Czz',
'Cwbx', 'Czbx', 'Cabx',
'tCww', 'tCgg', 'tCaa', 'tCza', 'tCzz']
# double Higgs couplings [Eqn. (3.13)]
MBxhh = ['dCw2', 'dCz2', 'Cww2', 'Cgg2', 'Caa2', 'Cza2', 'Czz2',
'Cwbx2', 'Czbx2', 'Cabx2',
'tCww2', 'tCgg2', 'tCaa2', 'tCza2', 'tCzz2']
# Higgs self couplings [Eqn. (3.12)]
MBxhself = ['dL3', 'dL4']
# 4-fermion operators
MBx4F = ['cll1122', 'cpuu3333', 'cll1221']
blocks = {'MBxMASS':MBxMASS, 'MBxTGC':MBxTGC, 'MBxQGC':MBxQGC,
'MBxh':MBxh, 'MBxhh':MBxhh, 'MBxhself':MBxhself, 'MBx4F':MBx4F}
- flavoured = {
+ flavored = {
# Z Vertex Corrections [Eqn (3.4)]
'MBxdGLze': {'kind':'hermitian', 'domain':'complex', 'cname':'dGLze'},
'MBxdGRze': {'kind':'hermitian', 'domain':'complex', 'cname':'dGRze'},
'MBxdGLzv': {'kind':'hermitian', 'domain':'complex', 'cname':'dGLzv'},
'MBxdGLzu': {'kind':'hermitian', 'domain':'complex', 'cname':'dGLzu'},
'MBxdGRzu': {'kind':'hermitian', 'domain':'complex', 'cname':'dGRzu'},
'MBxdGLzd': {'kind':'hermitian', 'domain':'complex', 'cname':'dGLzd'},
'MBxdGRzd': {'kind':'hermitian', 'domain':'complex', 'cname':'dGRzd'},
# W Vertex Corrections [Eqn (3.4)]
'MBxdGLwl': {'kind':'hermitian', 'domain':'complex', 'cname':'dGLwl'},
'MBxdGLwq': {'kind':'general', 'domain':'complex', 'cname':'dGLwq'},
'MBxdGRwq': {'kind':'general', 'domain':'complex', 'cname':'dGRwq'},
# Dipole interactions with single gauge bosons [Eqn. (3.5)]
'MBxdgu': {'kind':'hermitian', 'domain':'complex', 'cname':'dgu'},
'MBxdgd': {'kind':'hermitian', 'domain':'complex', 'cname':'dgd'},
'MBxdau': {'kind':'hermitian', 'domain':'complex', 'cname':'dau'},
'MBxdad': {'kind':'hermitian', 'domain':'complex', 'cname':'dad'},
'MBxdae': {'kind':'hermitian', 'domain':'complex', 'cname':'dae'},
'MBxdzu': {'kind':'hermitian', 'domain':'complex', 'cname':'dzu'},
'MBxdzd': {'kind':'hermitian', 'domain':'complex', 'cname':'dzd'},
'MBxdze': {'kind':'hermitian', 'domain':'complex', 'cname':'dze'},
'MBxdwq': {'kind':'general', 'domain':'complex', 'cname':'dwq'},
'MBxdwl': {'kind':'general', 'domain':'complex', 'cname':'dwl'},
'MBxtdgu': {'kind':'hermitian', 'domain':'complex', 'cname':'tdgu'},
'MBxtdgd': {'kind':'hermitian', 'domain':'complex', 'cname':'tdgd'},
'MBxtdau': {'kind':'hermitian', 'domain':'complex', 'cname':'tdau'},
'MBxtdad': {'kind':'hermitian', 'domain':'complex', 'cname':'tdad'},
'MBxtdae': {'kind':'hermitian', 'domain':'complex', 'cname':'tdae'},
'MBxtdzu': {'kind':'hermitian', 'domain':'complex', 'cname':'tdzu'},
'MBxtdzd': {'kind':'hermitian', 'domain':'complex', 'cname':'tdzd'},
'MBxtdze': {'kind':'hermitian', 'domain':'complex', 'cname':'tdze'},
'MBxtdwq': {'kind':'general', 'domain':'complex', 'cname':'tdwq'},
'MBxtdwl': {'kind':'general', 'domain':'complex', 'cname':'tdwl'},
# single Higgs couplings to fermions [Eqn. (3.8)]
'MBxdYu': {'kind':'general', 'domain':'real', 'cname':'dYu'},
'MBxdYd': {'kind':'general', 'domain':'real', 'cname':'dYd'},
'MBxdYe': {'kind':'general', 'domain':'real', 'cname':'dYe'},
'MBxSu': {'kind':'general', 'domain':'real', 'cname':'Su' },
'MBxSd': {'kind':'general', 'domain':'real', 'cname':'Sd' },
'MBxSe': {'kind':'general', 'domain':'real', 'cname':'Se' },
# Higgs contact interactions HVff [Eqn. (3.10)]
'MBxdGLhze': {'kind':'hermitian', 'domain':'complex', 'cname':'dGLhze'},
'MBxdGRhze': {'kind':'hermitian', 'domain':'complex', 'cname':'dGRhze'},
'MBxdGLhzv': {'kind':'hermitian', 'domain':'complex', 'cname':'dGLhzv'},
'MBxdGLhzu': {'kind':'hermitian', 'domain':'complex', 'cname':'dGLhzu'},
'MBxdGRhzu': {'kind':'hermitian', 'domain':'complex', 'cname':'dGRhzu'},
'MBxdGLhzd': {'kind':'hermitian', 'domain':'complex', 'cname':'dGLhzd'},
'MBxdGRhzd': {'kind':'hermitian', 'domain':'complex', 'cname':'dGRhzd'},
'MBxdGLhwl': {'kind':'hermitian', 'domain':'complex', 'cname':'dGLhwl'},
'MBxdGLhwq': {'kind':'general', 'domain':'complex', 'cname':'dGLhwq'},
'MBxdGRhwq': {'kind':'general', 'domain':'complex', 'cname':'dGRhwq'},
# Dipole interactions with single higgs and gauge boson [Eqn. (3.11)]
'MBxdhgu': {'kind':'hermitian', 'domain':'complex', 'cname':'dhgu'},
'MBxdhgd': {'kind':'hermitian', 'domain':'complex', 'cname':'dhgd'},
'MBxdhau': {'kind':'hermitian', 'domain':'complex', 'cname':'dhau'},
'MBxdhad': {'kind':'hermitian', 'domain':'complex', 'cname':'dhad'},
'MBxdhae': {'kind':'hermitian', 'domain':'complex', 'cname':'dhae'},
'MBxdhzu': {'kind':'hermitian', 'domain':'complex', 'cname':'dhzu'},
'MBxdhzd': {'kind':'hermitian', 'domain':'complex', 'cname':'dhzd'},
'MBxdhze': {'kind':'hermitian', 'domain':'complex', 'cname':'dhze'},
'MBxdhwq': {'kind':'general', 'domain':'complex', 'cname':'dhwq'},
'MBxdhwl': {'kind':'general', 'domain':'complex', 'cname':'dhwl'},
'MBxtdhgu': {'kind':'hermitian', 'domain':'complex', 'cname':'tdhgu'},
'MBxtdhgd': {'kind':'hermitian', 'domain':'complex', 'cname':'tdhgd'},
'MBxtdhau': {'kind':'hermitian', 'domain':'complex', 'cname':'tdhau'},
'MBxtdhad': {'kind':'hermitian', 'domain':'complex', 'cname':'tdhad'},
'MBxtdhae': {'kind':'hermitian', 'domain':'complex', 'cname':'tdhae'},
'MBxtdhzu': {'kind':'hermitian', 'domain':'complex', 'cname':'tdhzu'},
'MBxtdhzd': {'kind':'hermitian', 'domain':'complex', 'cname':'tdhzd'},
'MBxtdhze': {'kind':'hermitian', 'domain':'complex', 'cname':'tdhze'},
'MBxtdhwq': {'kind':'general', 'domain':'complex', 'cname':'tdhwq'},
'MBxtdhwl': {'kind':'general', 'domain':'complex', 'cname':'tdhwl'},
# couplings of two Higgs bosons to fermions [Sec. 3.8]
'MBxY2u': {'kind':'general', 'domain':'complex', 'cname':'Y2u'},
'MBxY2d': {'kind':'general', 'domain':'complex', 'cname':'Y2d'},
'MBxY2e': {'kind':'general', 'domain':'complex', 'cname':'Y2e'}
}
# All parameters independent
independent = ( [c for v in blocks.values() for c in v] +
- [c for c in flavoured.keys()] )
+ [c for c in flavored.keys()] )
required_inputs = {1, 2, 4}
# all other undefined behavoiur inherited from Basis.Basis by default
################################################################################
def modify_inputs(self):
'''
W mass modification from dM.
'''
ee2 = 4.*math.pi/self.inputs['aEWM1'] # EM coupling squared
Gf, MZ = self.inputs['Gf'], self.inputs['MZ']
s2w = (1.- sqrt(1. - ee2/(sqrt(2.)*Gf*MZ**2)))/2. # sin^2(theta_W)
c2w = (1.-s2w)
MW = MZ*sqrt(c2w)
if 24 in self.mass:
self.mass[24] = MW + self['dM']
else:
self.mass.new_entry(24, MW + self['dM'], name = 'MW')
################################################################################
diff --git a/Rosetta/SILHBasis.py b/Rosetta/SILHBasis.py
index 1f503d8..4006f89 100644
--- a/Rosetta/SILHBasis.py
+++ b/Rosetta/SILHBasis.py
@@ -1,358 +1,358 @@
from internal import Basis
import math
from math import sqrt
from itertools import combinations_with_replacement as comb
from itertools import product
-from internal import PID
+from internal.constants import PID
from internal.matrices import matrix_mult, matrix_add, matrix_sub, matrix_eq
################################################################################
class SILHBasis(Basis.Basis):
'''
Basis class for Rosetta based on [Giudice et al., JHEP 0706 (2007) 045 ]
and a number of succesive publications. Part of the three intrinsic basis
implementations in Rosetta along with the Higgs and Warsaw bases. The exact
list of operators included as well as the equations for the translation to
the Higgs and Warsaw bases can be found in the HXSWG note, for which all
references to tables and equations are in this implementation. The basis
differs slightly to the versions defined in the original publications.
Please refer to the HXSWG note for further details. Table 1 contains the
majority of the operators included, with the remaining structure described
in section 5.
'''
name = 'silh'
##########################
# declare coefficients
# [Tab. 1]
SBV2H2 = ['sGG','sBB','sW','sB','sHW','sHB','s2W','s2B','s2G',
'tsGG','tsBB','tsHW','tsHB']
SBH4D2 = ['sH','sT']
SBH6 = ['s6H']
SBV3D3 = ['s3W','s3G','ts3W','ts3G']
##########################
# block structure
blocks = {'SBxV2H2':SBV2H2, 'SBxH4D2':SBH4D2,
'SBxH6':SBH6, 'SBxV3D3':SBV3D3}
- flavoured={
+ flavored={
'SBxu': {'cname':'su', 'kind':'general', 'domain':'complex'},
'SBxd': {'cname':'sd', 'kind':'general', 'domain':'complex'},
'SBxe': {'cname':'se', 'kind':'general', 'domain':'complex'},
'SBxHl': {'cname':'sHl' , 'kind':'hermitian', 'domain':'complex'},
'SBxHpl': {'cname':'sHpl', 'kind':'hermitian', 'domain':'complex'},
'SBxHe': {'cname':'sHe' , 'kind':'hermitian', 'domain':'complex'},
'SBxHq': {'cname':'sHq' , 'kind':'hermitian', 'domain':'complex'},
'SBxHpq': {'cname':'sHpq', 'kind':'hermitian', 'domain':'complex'},
'SBxHu': {'cname':'sHu' , 'kind':'hermitian', 'domain':'complex'},
'SBxHd' : {'cname':'sHd' , 'kind':'hermitian', 'domain':'complex'},
'SBxHud' : {'cname':'sHud', 'kind':'general', 'domain':'complex'}
}
- independent = blocks.keys() + flavoured.keys()
+ independent = blocks.keys() + flavored.keys()
# two coefficients are zero by construction (set in calculate_dependent())
dependent = ['CsHl1x1', 'CsHpl1x1']
# required_masses = set([y for x in PID.values() for y in x.values()])
required_masses = {25}
required_inputs = {1, 2, 3, 4, 25} # aEWM1, Gf, aS, MZ, MH
##########################
def calculate_dependent(self):
# These coefficients are implictly set to zero
self['SBxHl'][1,1], self['SBxHpl'][1,1] = 0., 0.
def calculate_inputs(self): # calculate a few required EW params from aEWM1, Gf, MZ
ee2 = 4.*math.pi/self.inputs['aEWM1'] # EM coupling squared
gs2 = 4.*math.pi*self.inputs['aS'] # strong coupling squared
Gf, MZ = self.inputs['Gf'], self.inputs['MZ']
s2w = (1.- sqrt(1. - ee2/(sqrt(2.)*Gf*MZ**2)))/2. # sin^2(theta_W)
c2w = (1.-s2w)
gw2 = ee2/s2w # SU(2) coupling squared
gp2 = gw2*s2w/c2w # Hypercharge coupling squared
vev = 2.*MZ*sqrt(c2w/gw2)
return s2w, c2w, ee2, gw2, gp2, MZ, vev, gs2
def to_MB_or_HB(self, instance, target='mass'):
'''
Translation function to Mass basis or Higgs basis, which differs only in
- the prefix of the flavoured blocks.
+ the prefix of the flavored blocks.
'''
# prefix switch depending on target
if target == 'mass':
XB = 'MB'
elif target == 'higgs':
XB = 'HB'
else:
raise Basis.TranslationError('target must be "mass" or "higgs"')
s2w, c2w, ee2, gw2, gp2, MZ, vev, gs2 = self.calculate_inputs()
MH = self.mass[25]
MW = MZ*sqrt(c2w)
S = self
M = instance
# W mass shift [eqn (5.11)]
M['dM'] = - gw2*gp2/(4.*(gw2-gp2))*(S['sW'] + S['sB'] + S['s2W']
+ S['s2B'] - 4./gp2*S['sT']
+ 2./gw2*S['SBxHpl'][2,2].real)
def f(T3,Q,i,j): # [eqn (5.12)]
Qcoeff = gp2/4./(gw2-gp2)*( -(2.*gw2-gp2)*S['s2B']
- gw2*(S['s2W'] + S['sW'] + S['sB'] )
+ 4.*S['sT'] - 2.*S['SBxHpl'][2,2].real)
T3coeff = ( gw2*S['s2W'] + gp2*S['s2B']
+ 4.*S['sT']-2.*S['SBxHpl'][2,2].real)/4.
return delta(i,j)*(Q*Qcoeff + T3*T3coeff)
def delta(i,j):
return 1. if i==j else 0.
# W/Z chiral coupling deviations
for i,j in S['SBxHpl'].keys():
M[XB+'xdGLzv'][i,j] = (1./2.*S['SBxHpl'][i,j]
- 1./2.*S['SBxHl'][i,j] + f(1./2.,0.,i,j))
M[XB+'xdGLze'][i,j] = (-1./2.*S['SBxHpl'][i,j]
- 1./2.*S['SBxHl'][i,j] + f(-1./2.,-1.,i,j))
M[XB+'xdGRze'][i,j] = (- 1./2.*S['SBxHe'][i,j] + f(0.,-1.,i,j))
M[XB+'xdGLzu'][i,j] = (1./2.*S['SBxHpq'][i,j]
- 1./2.*S['SBxHq'][i,j] + f(1./2.,2./3.,i,j))
M[XB+'xdGLzd'][i,j] = (-1./2.*S['SBxHpq'][i,j]
- 1./2.*S['SBxHq'][i,j] + f(-1./2.,-1./3.,i,j))
M[XB+'xdGRzu'][i,j] = (- 1./2.*S['SBxHu'][i,j] + f(0.,2./3.,i,j))
M[XB+'xdGRzd'][i,j] = (- 1./2.*S['SBxHd'][i,j] + f(0.,-1./3.,i,j))
M[XB+'xdGLwl'][i,j] = (S['SBxHpl'][i,j] + f(1./2.,0.,i,j)
- f(-1./2.,-1.,i,j))
for k,v in S['SBxHud'].iteritems():
M[XB+'xdGRwq'][k] = -v/2.
matrix_sub(matrix_mult(M[XB+'xdGLzu'], S.ckm),
matrix_mult(S.ckm, M[XB+'xdGLzd']),
M[XB+'xdGLwq'])
onames = ['xdGLze', 'xdGRze', 'xdGLzv', 'xdGLzu', 'xdGRzu',
'xdGLzd', 'xdGRzd', 'xdGLwl', 'xdGLwq', 'xdGRwq']
vertex = [XB + o for o in onames]
# HVFF coeffs [Eqns (3.10)]
for dG in vertex:
dGh = dG[:-2]+'h'+dG[-2:]
matrix_eq(M[dG], M[dGh])
# Higgs couplings to W/Z [eqn (4.14)]
M['dCw'] = -S['sH'] - gw2*gp2/(gw2-gp2)*( S['sW'] + S['sB']
+ S['s2W'] + S['s2B'] - 4./gp2*S['sT']
+ (3.*gw2 + gp2)/(2.*gw2*gp2)*S['SBxHpl'][2,2].real)
M['dCz'] = -S['sH'] - 3./2.*S['SBxHpl'][2,2].real
# Two derivative field strength interactions [eqn (4.15)]
M['Cgg'] = S['sGG']
M['Caa'] = S['sBB']
M['Czz'] = -1./(gw2+gp2)*( gw2*S['sHW'] + gp2*S['sHB']
- gp2*s2w*S['sBB'] )
M['Czbx'] = 1./(2.*gw2)*( gw2*(S['sW'] + S['sHW'] +S['s2W'])
+ gp2*(S['sB'] + S['sHB'] +S['s2B'])
- 4.*S['sT'] + 2.*S['SBxHpl'][2,2].real )
M['Cza'] = ( S['sHB'] - S['sHW'])/2. - s2w*S['sBB']
M['Cabx'] = ( S['sHW'] - S['sHB'])/2.+ 1./(gw2-gp2)*(
gw2*(S['sW']+S['s2W']) + gp2*(S['sB']+S['s2B'])
- 4.*S['sT'] + 2.*S['SBxHpl'][2,2].real )
M['Cww'] = -S['sHW']
# factor 2 wrong in note here
M['Cwbx'] = S['sHW']/2. + 1./2./(gw2-gp2)*(
gw2*(S['sW']+S['s2W']) + gp2*(S['sB']+S['s2B'])
- 4.*S['sT'] + 2.*S['SBxHpl'][2,2].real )
M['tCgg'] = S['tsGG']
M['tCaa'] = S['tsBB']
M['tCzz'] = -1./(gw2+gp2)*( gw2*S['tsHW'] + gp2*S['tsHB']
- gp2*s2w*S['tsBB'] )
M['tCza'] = ( S['tsHB'] - S['tsHW'])/2. - s2w*S['tsBB']
M['tCww'] = -S['tsHW']
# solution for [eqn (5.16)]
# dy*cos(phi) == X
# dy*sin(phi) == Y
def dy_sf(X,Y):
R = sqrt(X**2+Y**2)
if R==0:
return 0., 0.
elif Y==0.:
return X, 0.
else:
signY = Y/abs(Y)
if X*Y > 0.:
return R*signY, abs(Y)/R
else:
return -R*signY, -abs(Y)/R
# Yukawa type interaction coefficients [eqns. (5.16) & (4.17)]
for f in ('u','d','e'):
matrix = 'SBx' + f
for i,j in S['SBx'+f].keys():
diag = delta(i,j)*(S['sH'] + S['SBxHpl'][2,2].real/2.)
diag2 = 2.*delta(i,j)*(S['sH'])
s_Re, s_Im = S[matrix][i,j].real, S[matrix][i,j].imag
dy_cosphi = s_Re/sqrt(2.) - diag
dy_sinphi = s_Im/sqrt(2.)
M[XB+'xdY'+f][i,j], M[XB+'xS'+f][i,j] = dy_sf(dy_cosphi,
dy_sinphi)
re = 3.*s_Re/sqrt(2.) - diag2
im = 3.*s_Im/sqrt(2.)
M[XB+'xY2'+f][i,j] = complex(re, im)
# Triple gauge couplings [eqn. (5.18)]
M['dG1z'] = -(gw2+gp2)/(gw2-gp2)/4.*( (gw2-gp2)*S['sHW']
+ gw2*(S['sW'] + S['s2W']) + gp2*(S['sB'] + S['s2B'])
- 4.*S['sT'] + 2.*S['SBxHpl'][2,2].real )
M['dKa'] = - gw2/4.*(S['sHW']+S['sHB'])
M['dKz'] = ( -1./4.*(gw2*S['sHW'] - gp2*S['sHB'])
-(gw2+gp2)/(gw2-gp2)/4.*(
gw2*(S['sW'] + S['s2W'])
+ gp2*(S['sB'] + S['s2B'])
- 4.*S['sT'] + 2.*S['SBxHpl'][2,2].real
)
)
M['La'] = -S['s3W']*3./2.*gw2**2
M['Lz'] = M['La']
M['tKa'] = - gw2/4.*(S['tsHW']+S['tsHB'])
M['tKz'] = gp2/4.*(S['tsHW']+S['tsHB'])
M['tLa'] = -S['ts3W']*3./2.*gw2**2
M['tLz'] = M['tLa']
M['C3g'] = S['s3G']
M['tC3g'] = S['ts3G']
# Quartic gauge couplings [Sec 3.7] [eqn (3.23)]
M['dGw4'] = 2.*c2w*M['dG1z']
M['dGw2z2'] = 2.*M['dG1z']
M['dGw2za'] = M['dG1z']
# two derivative quartic gauge couplings [Sec 3.7] [eqn (3.24)]
M['Lw4'] = -gw2/2./MW**2*M['Lz']
M['tLw4'] = -gw2/2./MW**2*M['tLz']
M['Lw2z2'] = -gw2*c2w/MW**2*M['Lz']
M['tLw2z2'] = -gw2*c2w/MW**2*M['tLz']
M['Lw2za'] = -ee2/MW**2*M['Lz']
M['tLw2za'] = -ee2/MW**2*M['tLz']
M['Lw2a2'] = -sqrt(ee2*gw2*c2w)/MW**2*M['Lz']
M['tLw2a2'] = -sqrt(ee2*gw2*c2w)/MW**2*M['tLz']
M['Lw2az'] = -sqrt(ee2*gw2*c2w)/MW**2*M['Lz']
M['tLw2az'] = -sqrt(ee2*gw2*c2w)/MW**2*M['tLz']
M['C4g'] = 3.*sqrt(gs2)**3/vev**2*M['C3g']
M['tC4g'] = 3.*sqrt(gs2)**3/vev**2*M['tC3g']
# Higgs cubic interaction [eqn. (4.19)]
M['dL3'] = -MH**2/(2.*vev**2)*(3.*S['sH'] + S['SBxHpl'][2,2].real/2.) - S['s6H']
M['dL4'] = 3./2.*M['dL3'] - MH**2/vev**2/6.*M['dCz']
# Couplings of two Higgs bosons to gluons [Sec 3.8]
# [eqn (3.27)] copied from HiggsBasis implemetation
M['Cgg2'], M['tCgg2'] = M['Cgg'], M['tCgg']
M['dCz2'] = M['dCz']
M['dCw2'] = M['dCw'] + 3.*M['dM']
hvv = ['Cww', 'Cwbx', 'Cgg', 'Caa', 'Cza', 'Czz', 'Czbx', 'Cabx',
'tCww', 'tCgg', 'tCaa', 'tCza', 'tCzz']
for cvv in hvv:
cvv2 = cvv +'2'
M[cvv2] = M[cvv]
M['cll1122'] = (gp2*S['s2B'] - gw2*S['s2W'])/2.
M['cll1221'] = gw2*S['s2W']
M['cpuu3333'] = (1./3.)*gs2*S['s2G']
return M
@Basis.translation('mass')
def to_mass(self,instance):
return self.to_MB_or_HB(instance, target = 'mass')
@Basis.translation('higgs')
def to_higgs(self,instance):
return self.to_MB_or_HB(instance, target = 'higgs')
@Basis.translation('warsaw')
def to_warsaw(self, instance):
s2w, c2w, ee2, gw2, gp2, MZ, vev, gs2 = self.calculate_inputs()
MH = self.mass[25]
lam = -MH**2/(2.*vev**2) # Higgs self-coupling
S = self
W = instance
def delta(i,j):
return 1. if i==j else 0.
# [eqn (5.7)]
W['cH'] = S['sH'] - 3./4.*gw2*(S['sW'] + S['sHW'] + S['s2W'])
W['cT'] = S['sT'] - 1./4.*gp2*(S['sB'] + S['sHB'] + S['s2B'])
W['c6H'] = S['s6H'] - 2.*lam*gw2*(S['sW'] + S['sHW'] + S['s2W'])
W['cWB'] = - 1./4.*(S['sHB'] + S['sHW'])
W['cBB'] = S['sBB'] - S['sHB']
W['cWW'] = -S['sHW']
W['tcWB'] = - 1./4.*(S['tsHB'] + S['tsHW'])
W['tcBB'] = S['tsBB'] - S['tsHB']
W['tcWW'] = -S['tsHW']
def cHf(sc, Yf, i, j):
try: # special case for SBxHl[1,1] which is dependent in SILH
ss = S[sc][i,j]
except KeyError:
ss = 0.
return ss + delta(i,j)*gp2*Yf/2.*(S['sB'] + S['sHB'] + 2.*S['s2B'])
def cpHf(sc, i, j):
try: # special case for SBxHpl[1,1] which is dependent in SILH
ss = S[sc][i,j]
except KeyError:
ss = 0.
return ss + delta(i,j)*gw2/4.*(S['sW'] + S['sHW'] + 2.*S['s2W'])
for i,j in S['SBxHq'].keys():
W['WBxHl'][i,j] = cHf('SBxHl', -1./2., i, j)
W['WBxHe'][i,j] = cHf('SBxHe', -1., i, j)
W['WBxHq'][i,j] = cHf('SBxHq', 1./6., i, j)
W['WBxHu'][i,j] = cHf('SBxHu', 2./3., i, j)
W['WBxHd'][i,j] = cHf('SBxHd', -1./3., i, j)
W['WBxHpl'][i,j] = cpHf('sBxHpl', i, j)
W['WBxHpq'][i,j] = cpHf('sBxHpq', i, j)
for k in S['SBxHud'].keys():
W['WBxHud'][k] = S['SBxHud'][k]
def cf(sc, i, j):
return S[sc][i,j] - delta(i,j)*gw2*(S['sW'] +
S['sHW'] + S['s2W'])/sqrt(2.)
# [eqn (5.9)]
for f in ('u','d','e'): # fermion loop
wmatrix, smatrix = 'WBx'+f, 'SBx'+f
- for i,j in S[smatrix].keys(): # flavour loop
+ for i,j in S[smatrix].keys(): # flavor loop
W[wmatrix][i,j] = cf(smatrix, i, j)
# [eqn (5.10)]
W['cll1221'] = gw2*S['s2W'] # cll1221==0 in SILH
# derived from [eqn (5.4)]
W['cll1122']=( gp2*S['s2B'] - gw2*S['s2W'] )/2.
W['cpuu3333'] = (1./3.)*gs2*S['s2G']
# trivial translation, cX==sX
trivial = ['sGG','tsGG','s3W','ts3W','s3G','ts3G']
for coeff in trivial:
wcoeff = coeff.replace('s','c')
W[wcoeff] = S[coeff]
return W
################################################################################
\ No newline at end of file
diff --git a/Rosetta/TemplateBasis.py b/Rosetta/TemplateBasis.py
index 68a7a38..fedd21c 100644
--- a/Rosetta/TemplateBasis.py
+++ b/Rosetta/TemplateBasis.py
@@ -1,115 +1,115 @@
from internal import Basis
-from internal import default_masses, default_inputs, PID
+from internal.constants import default_masses, default_inputs, PID
from internal.matrices import matrix_mult, matrix_add, matrix_sub, matrix_eq
################################################################################
class TemplateBasis(Basis.Basis):
'''
Toy implementation of a user defined basis class. Makes use of the internal
- function flavour_matrix to generate indexed coefficients e11,e12,...,e33. A
+ function flavor_matrix to generate indexed coefficients e11,e12,...,e33. A
template input card can be fond in the Cards directory or can be generated
with write_template_card().
'''
name = 'template'
##########################
# declare coefficients
- # flavoured = flavmat('e', kind='symmetric', domain='real')
+ # flavored = flavmat('e', kind='symmetric', domain='real')
##########################
independent = ['a','b','c','AA']
required_masses = {1,2,3,4,5,6} # quark masses rquired
required_inputs = {1, 4} # aEWM1, MZ
blocks = {'newcoup':['a','b','c'],
'dep':['d']}
- flavoured = {'AA':{'domain':'complex', 'kind':'general', 'cname':'cAA'},
+ flavored = {'AA':{'domain':'complex', 'kind':'general', 'cname':'cAA'},
'BB':{'domain':'complex', 'kind':'general', 'cname':'cBB'},
'CC':{'domain':'complex', 'kind':'general', 'cname':'cCC'}}
##########################
# This can be overridden if you want but is typically unneccesary. Exclude
# it entirely and the class will inherit the constructor from the parent
# class, Basis.Basis.
def __init__(self,*args,**kwargs):
# If you want to add additional behaviour by redefining the
# constructor, ensure a call to the base class constructor is made
# like so:
super(TemplateBasis, self).__init__(*args,**kwargs)
# additional instructions can live here
def calculate_dependent(self):
'''
Calculate dependent parameters here by assigning values to parameters
not listed in self.independent.
'''
p = self
p['d'] = p['a']+ p['b']*p['c']
# element-wise asssignment for matrix BB: BB[i,j] = -A[i,j]/4.
for k, v in p['AA'].iteritems():
p['BB'][k] = -v/4.
# matrix multiplication function assigning CC -> AA.BB
matrix_mult(p['AA'], p['BB'], p['CC'])
@Basis.translation('silh')
def to_silh(self, instance):
'''
Toy translation to the SILH basis setting all coefficients to 1e-3, and
modifying the Z and Higgs masses.
'''
A = self
B = instance
# set all values of silh basis coeffs to 0.01:
# coeff_d*m_top*a_EW
for k in B:
B[k] = 0.001
self.mass[23]=91.19 # MZ in newmass
self.inputs[8]=126. # MH in newinput
return B
@Basis.translation('mass')
def to_mass(self, instance):
'''
Toy translation to the Mass basis setting all coefficients according to
a nonsense formula, myfunc, defined below. Also modifies the Z and
Higgs masses.
'''
A = self
B = instance
# set all values of mass basis coeffs according to nonsense formula
# y = d*m_top*a_EW
for k in B:
B[k] = self.myfunc( A['d'], self.mass[6], self.inputs['aEWM1'] )
return B
def modify_inputs(self):
if 24 in self.mass:
self.mass[24]=91.19 # MW = MZ
else:
self.mass.new_entry(24, 91.19, name='MW')
if 25 in self.inputs:
self.inputs[25]=126. # MH in newinput
else:
self.inputs.new_entry(25, 126., name='MH')
@staticmethod # pure function, no access to class instance
def myfunc(x,y,z):
return x*y/z
def myfunc2(self,x,y,z): # access to class instance, "self"
my_one = self.inputs[4]/self.inputs[4]
return x*y/z*my_one
################################################################################
if __name__=='__main__':
# Testing area which can be executed when running `python TemplateBasis.py`
instance = TemplateBasis(param_card='../Cards/param_card_TemplateBasis.dat')
instance.write_param_card('test_template.dat')
# inputs = instance.eHDECAY_inputs()
# print eHDECAY(inputs)
\ No newline at end of file
diff --git a/Rosetta/WarsawBasis.py b/Rosetta/WarsawBasis.py
index 1c99be8..599d9be 100644
--- a/Rosetta/WarsawBasis.py
+++ b/Rosetta/WarsawBasis.py
@@ -1,323 +1,323 @@
from internal import Basis
import math
from math import sqrt
from itertools import combinations_with_replacement as comb
from itertools import product
-from internal import PID
+from internal.constants import PID
from internal.matrices import matrix_mult, matrix_add, matrix_sub, matrix_eq
################################################################################
class WarsawBasis(Basis.Basis):
'''
Basis class for Rosetta based on [Grzadkowski et al., JHEP 1010 (2010) 085].
Part of the three intrinsic basis implementations in Rosetta along with the
Higgs and SILH bases. The exact list of operators included as well as the
equations for the translation to the Higgs basis can be found in the HXSWG
note, for which all references to tables and equations are in this
implementation. Table 1 of the note shows full list of operators. The block
structure of the basis implementation maps to this table.
'''
name = 'warsaw'
######
# [Tab. 1]
- WBV2H2 = ['cGG','tcGG','cWW','tcWW','cBB','tcBB','cWB','tcWB']
+ WBV2H2 = ['cGG','cWW','cBB','cWB','tcGG','tcWW','tcBB','tcWB']
WBH4D2 = ['cH','cT']
WBH6 = ['c6H']
WBV3D3 = ['c3W','c3G','tc3W','tc3G']
# affects Gf input, Warsaw <-> SILH translation
WB4F = ['cll1221','cll1122','cpuu3333']
######
blocks = {'WBxV2H2':WBV2H2, 'WBxH4D2':WBH4D2, 'WBxH6':WBH6,
'WBxV3D3':WBV3D3, 'WBx4F':WB4F}
- flavoured = {
+ flavored = {
'WBxu': {'cname':'cu', 'kind':'general', 'domain':'complex'},
'WBxd': {'cname':'cd', 'kind':'general', 'domain':'complex'},
'WBxe': {'cname':'ce', 'kind':'general', 'domain':'complex'},
'WBxHl': {'cname':'cHl' , 'kind':'hermitian', 'domain':'complex'},
'WBxHpl': {'cname':'cHpl', 'kind':'hermitian', 'domain':'complex'},
'WBxHe': {'cname':'cHe' , 'kind':'hermitian', 'domain':'complex'},
'WBxHq': {'cname':'cHq' , 'kind':'hermitian', 'domain':'complex'},
'WBxHpq': {'cname':'cHpq', 'kind':'hermitian', 'domain':'complex'},
'WBxHu': {'cname':'cHu' , 'kind':'hermitian', 'domain':'complex'},
'WBxHd' : {'cname':'cHd' , 'kind':'hermitian', 'domain':'complex'},
'WBxHud' : {'cname':'cHud', 'kind':'general', 'domain':'complex'}
}
- independent = [c for c in blocks.keys()] + [c for c in flavoured.keys()]
+ independent = [c for c in blocks.keys()] + [c for c in flavored.keys()]
# required_masses = set([y for x in PID.values() for y in x.values()])
required_masses = {25}
required_inputs = {1, 2, 3, 4, 25} # aEWM1, Gf, MZ, MH, aS(MZ)
def calculate_inputs(self): # calculate a few required EW params from aEWM1, Gf, MZ
ee2 = 4.*math.pi/self.inputs['aEWM1'] # EM coupling squared
gs2 = 4.*math.pi*self.inputs['aS'] # strong coupling squared
Gf, MZ = self.inputs['Gf'], self.inputs['MZ']
s2w = (1.- sqrt(1. - ee2/(sqrt(2.)*Gf*MZ**2)))/2. # sin^2(theta_W)
c2w = (1.-s2w)
gw2 = ee2/s2w # SU(2) coupling squared
gp2 = gw2*s2w/c2w # Hypercharge coupling squared
vev = 2.*MZ*sqrt(c2w/gw2)
return s2w, c2w, ee2, gw2, gp2, MZ, vev, gs2
def to_MB_or_HB(self, instance, target='mass'):
'''
Translation function to Mass basis or Higgs basis, which differs only in
- the prefix of the flavoured blocks.
+ the prefix of the flavored blocks.
'''
# prefix switch depending on target
if target == 'mass':
XB = 'MB'
elif target == 'higgs':
XB = 'HB'
else:
raise Basis.TranslationError('target must be "mass" or "higgs"')
s2w, c2w, ee2, gw2, gp2, MZ, vev, gs2 = self.calculate_inputs()
MH = self.mass[25]
MW = MZ*sqrt(c2w)
W = self
M = instance
def delta(i,j):
return 1. if i==j else 0.
def f(T3,Q,i,j): # [eqn (4.11)]
return delta(i,j)*( -Q*W['cWB']*gw2*gp2/(gw2-gp2)
+ (W['cT']-dv)*(T3 + Q*gp2/(gw2-gp2)))
# Higgs vev shift [eqn (4.8)]
dv = (W['WBxHpl'][1,1].real + W['WBxHpl'][2,2].real)/2.-W['cll1221']/4.
# W mass shift [eqn (4.9)]
M['dM'] = ( gw2*W['cT'] - gp2*gw2*W['cWB']-gp2*dv )/(gw2-gp2)
# W/Z chiral coupling deviations
for i,j in W['WBxHpl'].keys():
M[XB+'xdGLzv'][i,j] = (1./2.*W['WBxHpl'][i,j]
- 1./2.*W['WBxHl'][i,j] + f(1./2.,0.,i,j))
M[XB+'xdGLze'][i,j] = (-1./2.*W['WBxHpl'][i,j]
- 1./2.*W['WBxHl'][i,j] + f(-1./2.,-1.,i,j))
M[XB+'xdGRze'][i,j] = (- 1./2.*W['WBxHe'][i,j] + f(0.,-1.,i,j))
M[XB+'xdGLzu'][i,j] = (1./2.*W['WBxHpq'][i,j]
- 1./2.*W['WBxHq'][i,j] + f(1./2.,2./3.,i,j))
M[XB+'xdGLzd'][i,j] = (-1./2.*W['WBxHpq'][i,j]
- 1./2.*W['WBxHq'][i,j] + f(-1./2.,-1./3.,i,j))
M[XB+'xdGRzu'][i,j] = (- 1./2.*W['WBxHu'][i,j] + f(0.,2./3.,i,j))
M[XB+'xdGRzd'][i,j] = (- 1./2.*W['WBxHd'][i,j] + f(0.,-1./3.,i,j))
M[XB+'xdGLwl'][i,j] = (W['WBxHpl'][i,j] + f(1./2.,0.,i,j)
- f(-1./2.,-1.,i,j))
for k,v in W['WBxHud'].iteritems():
M[XB+'xdGRwq'][k] = -v/2.
matrix_sub(matrix_mult(M[XB+'xdGLzu'], W.ckm),
matrix_mult(W.ckm, M[XB+'xdGLzd']),
M[XB+'xdGLwq'])
onames = ['xdGLze', 'xdGRze', 'xdGLzv', 'xdGLzu', 'xdGRzu',
'xdGLzd', 'xdGRzd', 'xdGLwl', 'xdGLwq', 'xdGRwq']
vertex = [XB + o for o in onames]
# HVFF coeffs [Eqns (3.10)]
for dG in vertex:
dGh = dG[:-2]+'h'+dG[-2:]
matrix_eq(M[dG], M[dGh])
# Higgs couplings to W/Z [eqn (4.14)]
M['dCw'] = ( -W['cH']*(gw2-gp2) - W['cWB']*4.*gw2*gp2
+ W['cT']*4.*gw2 - dv*(3.*gw2+gp2) )/(gw2-gp2)
M['dCz'] = -W['cH'] - 3.*dv
# Two derivative field strength interactions [eqn (4.15)]
M['Cgg'] = W['cGG']
M['Caa'] = W['cWW'] + W['cBB'] - 4.*W['cWB']
M['Czz'] = ( gw2**2*W['cWW'] + gp2**2*W['cBB']
+ 4.*gw2*gp2*W['cWB'] )/(gw2+gp2)**2
M['Czbx'] = -(2./gw2)*(W['cT'] - dv)
M['Cza'] = ( gw2*W['cWW'] - gp2*W['cBB']
- 2.*(gw2-gp2)*W['cWB'] )/(gw2+gp2)
M['Cabx'] = 2./(gw2-gp2)*((gw2+gp2)*W['cWB'] - 2.*W['cT'] + 2.*dv)
M['Cww'] = W['cWW']
M['Cwbx'] = 2./(gw2-gp2)*(gp2*W['cWB'] - W['cT'] + dv)
M['tCgg'] = W['tcGG']
M['tCaa'] = W['tcWW'] + W['tcBB'] - 4.*W['tcWB']
M['tCzz'] = ( gw2**2*W['tcWW'] + gp2**2*W['tcBB']
+ 4.*gw2*gp2*W['tcWB'] )/(gw2+gp2)**2
M['tCza'] = ( gw2*W['tcWW'] - gp2*W['tcBB']
- 2.*(gw2-gp2)*W['tcWB'] )/(gw2+gp2)
M['tCww'] = W['tcWW']
# solution for [eqn (4.16)]
# dy*cos(phi) == X
# dy*sin(phi) == Y
def dy_sf(X,Y):
R = sqrt(X**2+Y**2)
if R==0:
return 0., 0.
elif Y==0.:
return X, 0.
else:
signY = Y/abs(Y)
if X*Y > 0.:
return R*signY, abs(Y)/R
else:
return -R*signY, -abs(Y)/R
# Yukawa type interaction coefficients [eqns. (5.16) & (4.17)]
for f in ('u','d','e'):
matrix = 'WBx' + f
for i,j in W['WBx'+f].keys():
diag = delta(i,j)*(W['cH']+dv)
diag2 = 2.*delta(i,j)*W['cH']
s_Re, s_Im = W[matrix][i,j].real, W[matrix][i,j].imag
dy_cosphi = s_Re/sqrt(2.) - diag
dy_sinphi = s_Im/sqrt(2.)
M[XB+'xdY'+f][i,j], M[XB+'xS'+f][i,j] = dy_sf(dy_cosphi,
dy_sinphi)
re = 3.*s_Re/sqrt(2.) - diag2
im = 3.*s_Im/sqrt(2.)
M[XB+'xY2'+f][i,j] = complex(re, im)
# Triple gauge couplings [eqn. (4.18)]
M['dG1z'] = (gw2+gp2)/(gw2-gp2)*( -W['cWB']*gp2 + W['cT'] - dv )
M['dKa'] = W['cWB']*gw2
M['dKz'] = (-W['cWB']*2.*gw2*gp2 + (gw2+gp2)*(W['cT'] - dv))/(gw2-gp2)
M['La'] = -W['c3W']*3./2.*gw2**2
M['Lz'] = M['La']
M['tKa'] = W['tcWB']*gw2
M['tKz'] = -W['tcWB']*gp2
M['tLa'] = -W['tc3W']*3./2.*gw2**2
M['tLz'] = M['tLa']
M['C3g'] = W['c3G']
M['tC3g'] = W['tc3G']
# Quartic gauge couplings [Sec 3.7] [eqn (3.23)]
M['dGw4'] = 2.*c2w*M['dG1z']
M['dGw2z2'] = 2.*M['dG1z']
M['dGw2za'] = M['dG1z']
# two derivative quartic gauge couplings [Sec 3.7] [eqn (3.24)]
M['Lw4'] = -gw2/2./MW**2*M['Lz']
M['tLw4'] = -gw2/2./MW**2*M['tLz']
M['Lw2z2'] = -gw2*c2w/MW**2*M['Lz']
M['tLw2z2'] = -gw2*c2w/MW**2*M['tLz']
M['Lw2za'] = -ee2/MW**2*M['Lz']
M['tLw2za'] = -ee2/MW**2*M['tLz']
M['Lw2a2'] = -sqrt(ee2*gw2*c2w)/MW**2*M['Lz']
M['tLw2a2'] = -sqrt(ee2*gw2*c2w)/MW**2*M['tLz']
M['Lw2az'] = -sqrt(ee2*gw2*c2w)/MW**2*M['Lz']
M['tLw2az'] = -sqrt(ee2*gw2*c2w)/MW**2*M['tLz']
M['C4g'] = 3.*sqrt(gs2)**3/vev**2*M['C3g']
M['tC4g'] = 3.*sqrt(gs2)**3/vev**2*M['tC3g']
# Higgs cubic interaction [eqn. (4.19)]
M['dL3'] = -MH**2/(2.*vev**2) * (3.*W['cH'] + dv) - W['c6H']
M['dL4'] = 3./2.*M['dL3'] - MH**2/vev**2/6.*M['dCz']
# Couplings of two Higgs bosons to gluons [Sec 3.8]
# [eqn (3.27)] copied from HiggsBasis implemetation
M['Cgg2'], M['tCgg2'] = M['Cgg'], M['tCgg']
M['dCz2'] = M['dCz']
M['dCw2'] = M['dCw'] + 3.*M['dM']
hvv = ['Cww', 'Cwbx', 'Cgg', 'Caa', 'Cza', 'Czz', 'Czbx', 'Cabx',
'tCww', 'tCgg', 'tCaa', 'tCza', 'tCzz']
for cvv in hvv:
cvv2 = cvv +'2'
M[cvv2] = M[cvv]
# 4-fermion
M['cll1122'] = W['cll1122']
M['cpuu3333'] = W['cpuu3333']
M['cll1221'] = W['cll1221']
return M
@Basis.translation('mass')
def to_mass(self,instance):
return self.to_MB_or_HB(instance, target = 'mass')
@Basis.translation('higgs')
def to_higgs(self,instance):
return self.to_MB_or_HB(instance, target = 'higgs')
@Basis.translation('silh')
def to_silh(self, instance):
s2w, c2w, ee2, gw2, gp2, MZ, vev, gs2 = self.calculate_inputs()
MH = self.mass[25]
lam = -MH**2/(2.*vev**2) # Higgs self-coupling
W = self
S = instance
def delta(i,j):
return 1. if i==j else 0.
S['sBB'] = W['cBB'] - 4.*W['cWB'] + W['cWW']
S['tsBB'] = W['tcBB'] - 4.*W['tcWB'] + W['tcWW']
S['s2W'] = W['cll1221']/gw2
S['s2B'] = (2.*W['cll1122'] + W['cll1221'])/gp2
S['s2G'] = 3.*W['cpuu3333']/gs2
S['sB'] = (4.*W['cWB'] - W['cWW'] - (4.*W['WBxHl'][1,1].real
+ 4.*W['cll1122'] + 2.*W['cll1221'])/gp2)
S['sW'] = W['cWW'] - (2.*W['cll1221'] - 4.*W['WBxHpl'][1,1].real)/gw2
S['sHW'] = - W['cWW']
S['tsHW'] = - W['tcWW']
S['sHB'] = W['cWW'] - 4.*W['cWB']
S['tsHB'] = W['tcWW'] - 4.*W['tcWB']
S['sH'] = W['cH'] - 3./4.*W['cll1221'] + 3.*W['WBxHpl'][1,1,].real
S['sT'] = (W['cT'] - W['WBxHl'][1,1,].real - W['cll1122']/2.
- W['cll1221']/4.)
S['s6H'] = W['c6H'] - 2.*lam*(W['cll1221'] - 4.*W['WBxHpl'][1,1,].real)
def sHf(wc, Yf, i, j):
return W[wc][i,j] + delta(i,j)*2.*Yf*W['WBxHl'][1,1,].real
def spHf(wc, i, j):
return W[wc][i,j] - delta(i,j)*W['WBxHpl'][1,1,].real
for i,j in W['WBxHl'].keys():
S['SBxHl'][i,j] = sHf('WBxHl', -1./2., i, j)
S['SBxHe'][i,j] = sHf('WBxHe', -1., i, j)
S['SBxHq'][i,j] = sHf('WBxHq', 1./6., i, j)
S['SBxHu'][i,j] = sHf('WBxHu', 2./3., i, j)
S['SBxHd'][i,j] = sHf('WBxHd', -1./3., i, j)
S['SBxHpl'][i,j] = spHf('WBxHpl', i, j)
S['SBxHpq'][i,j] = spHf('WBxHpq', i, j)
for k in W['WBxHud'].keys():
S['SBxHud'][k] = W['WBxHud'][k]
def sf(wc, i, j):
return W[wc][i,j] - delta(i,j)*(W['cll1221']
- 4.*W['WBxHpl'][1,1,].real)/sqrt(2.)
# [eqn (5.9)]
for f in ('u','d','e'): # fermion loop
wmatrix, smatrix = 'WBx'+f, 'SBx'+f
- for i,j in W[wmatrix].keys(): # flavour loop
+ for i,j in W[wmatrix].keys(): # flavor loop
S[smatrix][i,j] = sf(wmatrix, i, j)
# trivial translation, sX==cX
trivial = ['sGG','tsGG','s3W','ts3W','s3G','ts3G']
for coeff in trivial:
wcoeff = coeff.replace('s','c')
S[coeff] = W[wcoeff]
return S
################################################################################
\ No newline at end of file
diff --git a/Rosetta/internal/Basis.py b/Rosetta/internal/Basis.py
index 5f21b7e..16aa9dc 100644
--- a/Rosetta/internal/Basis.py
+++ b/Rosetta/internal/Basis.py
@@ -1,1375 +1,1380 @@
################################################################################
import StringIO
import re
import sys
import os
import math
import datetime
from collections import namedtuple, OrderedDict, MutableMapping
from itertools import product, combinations
from itertools import combinations_with_replacement as combinations2
################################################################################
import SLHA
from query import query_yes_no as Y_or_N
from decorators import translation
from matrices import (TwoDMatrix, CTwoDMatrix, HermitianMatrix,
SymmetricMatrix, AntisymmetricMatrix)
-from __init__ import (PID, default_inputs, default_masses, input_names, VCKM,
+from constants import (PID, default_inputs, default_masses, input_names, VCKM,
IMVCKM, VCKMele, particle_names, input_to_PID,
- PID_to_input, RosettaError)
+ PID_to_input)
+from __init__ import RosettaError
################################################################################
+__doc__ = '''
+Base class for Rosetta bases as well as some utility functions for defining the
+names of flavor block elements and sorting blocks names for writing SLHA output.
+'''
# Base Basis class
class Basis(MutableMapping):
'''
Base class from which to derive other Higgs EFT basis classes.
Designed to be instantiated with an SLHA format parameter card using
read_param_card(). The contents of the card are stored as an SLHA.Card
object and the special blocks "mass" and "sminputs" are stored as
SLHA.NamedBlock instances in self.mass and self.input respectively.
self.name - Unique basis identifier. This will be compared to the 0th
element of the block basis in the SLHA parameter card to
ensure that right basis class is being instantiated for a
given input card.
self.card - SLHA.Card instance containing SLHA.NamedBlock and SLHA.Decay
instances corresponding to those specified in the parameter
card. Object names taken to be the first non-whitespace
characters after a "#" character in a block or parameter
definition are also stored.
self.mass - SLHA.NamedBlock instance for the "mass" block
self.inputs - SLHA.NamedBlock instance for the "sminputs" block
self.ckm - SLHA.NamedMatrix instance for the VCKM and IMVCKM blocks
self.blocks, self.required_inputs and self.required_masses should be defined
in accordance with block structure of the SLHA parameter card, Blocks
"sminput" and "mass" respectively (the Z ahd Higgs masses are also stored
in self.inputs). Specifically, the block names specified as keys in
self.blocks should match those in the SLHA card as well as the names and
indices of the elements (taken to be the order in which the appear in the
list associated the the block in self.blocks). The blocks "mass" and
"sminputs" should minimally contain the entries specified in required_masses
and required_inputs respectively. A number of checks related to these
definitions are performed by check_param_data(), check_mass() and
check_sminputs() on the data read in from the parameter card. An example is
shown below where the required data members are defined outside the class
construtor so as to instrinsically belong to all instances of the class.
>> from internal import Basis
>> class MyBasis(Basis.Basis):
>> name = 'mybasis'
>> independent = {'A','B','C','1','2','3'}
>> required_inputs = {1,2,4} # a_{EW}^{-1}, Gf and MZ required
>> required_masses = {23,25,6} # Z, Higgs and top masses required
>> blocks = {'letters':['A','B','C','D']
>> 'numbers':['1','2','3','4']} # Expected block structure
The list self.independent stored the basis parameters which should be read
in. Any other parameters declared in self.blocks are assumed to be set by
the user in the calculate_dependent() method. write_param_card() writes the
contents of the self.newcard into a new SLHA formatted file.
Basis and any of its subclasses are designed to work similarly to a
dictionary in that parameter values can be referenced by name (duplicate
names in different blocks are not handled properly so try to avoid them).
A value can be referenced in various ways, see below example where the
parameter named 'D' is stored as entry 3 in the block 'letters' written in
'mycard.dat':
>> instance = MyBasis(param_card='mycard.dat')
>> instance['A'] = 0.5 # set value according to name in SLHA card
>> instance.card['A'] = 0.5 # equivalent to the above
>> instance.card.blocks['letters']['A'] = 0.5 # from block by name
>> instance.card.blocks['letters'][3] = 0.5 # from block by entry
The user can define calculate_dependent() to set any dependent parameters
(those listed in in self.blocks but not in self.independent) and any number
of additional functions, usually to translate the coefficients into a given
basis which sets the SLHA.Card object, self.newcard. Rosetta differentiaties
from general utility functions and translation functions using the
"translation" decorator. Any function designed to take you to another
existing basis implemenation should be decorated with the "translation"
decorator with an argument corresponding to the name of the target basis.
This name should match the unique name of an existing basis implementation
also contained in the Rosetta root directory. Below would be example of a
translation function from our example to the Warsaw Basis.
>> @Basis.translation('warsaw') # identifies as translator to warsaw
>> def mytranslation(self, instance):
>> instance['cWW'] = 10.
>> instance['cpHl11'] = self['myparam']
>> return instance
Any python module saved in the root directory of the Rosetta package is
assumed to be a basis implementation. Furthermore, the class name of the
basis implementation should be the same as the file name of the python
module. In our example above, the class `MyBasis` would have to be saved in
a file named MyBasis.py. This is to help Rosetta automatically identify the
possible translation paths between bases. Any such class can then be used
by the command line script "translate". For example, Rosetta should be able
to figure out all possible multi-step translations.
'''
blocks = dict()
independent = []
dependent = []
- flavoured = dict()
+ flavored = dict()
required_inputs, required_masses = set(),set()
def __init__(self, param_card=None, output_basis='mass',
ehdecay=False, silent=False, translate=True,
- flavour = 'general', dependent=True):
+ flavor = 'general', dependent=True):
'''
Keyword arguments:
param_card - SLHA formatted card conforming to the definitions in
self.blocks, self.required_masses and
self.required_inputs.
output_basis - target basis to which to translate coefficients.
ehdecay - whether to run the eHDECAY interface to calculate the
Higgs width and BRs.
silent - suppress all warnings and take default answers for
all questions.
translate - Whether to call the translate method when reading in
from a parameter card.
- flavour - flavour structure of matrices: 'diagonal, 'universal'
+ flavor - flavor structure of matrices: 'diagonal, 'universal'
, 'MFV' or 'general'.
dependent - when param_card is None, whether or not to include
dependent parameters in the SLHA.Card attribute of
the basis instance.
'''
- self.flavour = flavour
+ self.flavor = flavor
self.param_card = param_card
self.output_basis = output_basis
self.newname = 'Basis'
self.all_coeffs = [c for v in self.blocks.values() for c in v]
# remove overlaps
self.independent = [c for c in self.independent
if c not in self.dependent]
self.dependent.extend([c for c in self.all_coeffs if (c not in
self.independent and c not in self.dependent)])
# check for block names in independent
for k,v in self.blocks.iteritems():
if k in self.independent and k not in self.dependent:
for fld in v:
if fld not in self.independent:
self.independent.append(fld)
try:
self.dependent.remove(fld)
except ValueError:
pass
- self.set_fblocks(self.flavour)
+ self.set_fblocks(self.flavor)
# read param card (sets self.inputs, self.mass, self.name, self.card)
if param_card is not None:
assert os.path.exists(self.param_card), \
'{} does not exist!'.format(self.param_card)
self.read_param_card()
# various input checks
self.check_sminputs(self.required_inputs)
self.check_masses(self.required_masses, silent=silent)
self.check_param_data(silent=silent)
- self.check_flavoured_data(silent=silent)
- # generalises potentially reduced flavour structure
+ self.check_flavored_data(silent=silent)
+ # generalises potentially reduced flavor structure
- self.set_flavour(self.flavour, 'general')
+ self.set_flavor(self.flavor, 'general')
# add dependent coefficients/blocks to self.card
self.init_dependent()
self._gen_thedict()
# user defined function
self.calculate_dependent()
# generate internal OrderedDict() object for __len__, __iter__,
# items() and iteritems() method
if translate:
# translate to new basis (User defined)
# return an instance of a class derived from Basis
newbasis = self.translate()
else:
# do nothing!
newbasis = self
newbasis.modify_inputs()
newbasis.check_modified_inputs()
# set new SLHA card
self.newcard = newbasis.card
self.newname = newbasis.name
preamble = ('###################################\n'
+ '## DECAY INFORMATION\n'
+ '###################################')
for decay in self.card.decays.values():
decay.preamble=preamble
break
try:
if ehdecay:
self.run_eHDECAY()
except TranslationError as e:
print e
print 'Translation to SILH Basis required, skipping eHDECAY.'
# if param_card option not given, instantiate with class name
# and all coeffs set to 0 (used for creating an empty basis
# instance for use in translate() method)
else:
self.card = self.default_card(dependent=dependent)
self._gen_thedict()
# overloaded container (dict) methods for indexing etc.
def __getitem__(self, key):
return self.card.__getitem__(key)
def __setitem__(self, key, value):
if hasattr(self,'_thedict'):
self._thedict[key]=value
return self.card.__setitem__(key, value)
def __contains__(self, key):
return self.card.__contains__(key)
def __delitem__(self, key):
if hasattr(self,'_thedict'):
del self._thedict[key]
return self.card.__delitem__(key)
def __len__(self):
return len(self._thedict)
def __iter__(self):
return iter(self._thedict)
def _gen_thedict(self):
thedict = SLHA.CaseInsensitiveOrderedDict()
for name, blk in self.card.blocks.iteritems():
if name in self.blocks:
for k, v in blk.iteritems():
thedict[blk.get_name(k)] = v
if isinstance(blk, SLHA.CBlock):
thedict[blk._re.get_name(k)] = v.real
thedict[blk._im.get_name(k)] = v.imag
for name, blk in self.card.matrices.iteritems():
if name in self.fblocks:
for k, v in blk.iteritems():
cname = blk.get_name(k)
if cname: thedict[cname] = v
if isinstance(blk, SLHA.CMatrix):
re_name = blk._re.get_name(k)
im_name = blk._im.get_name(k)
if re_name: thedict[re_name] = v.real
if im_name: thedict[im_name] = v.real
self._thedict = thedict
def set_fblocks(self, option='general'):
self.fblocks = dict()
- for name, opt in self.flavoured.iteritems():
- opt['flavour'] = option
- coeffs = flavour_coeffs(name, **opt)
+ for name, opt in self.flavored.iteritems():
+ opt['flavor'] = option
+ coeffs = flavor_coeffs(name, **opt)
self.fblocks[name] = coeffs
if name not in (self.independent + self.dependent):
self.dependent.extend([c for c in coeffs
if (c not in self.independent
and c not in self.dependent)])
def default_card(self, dependent=True):
'''
Create a new default SLHA.Card instance according to the self.blocks
- and self.flavoured structure of the basis class specified in the
+ and self.flavored structure of the basis class specified in the
implementaion. The dependent option allows one to switch on or off the
inclusion of dependent parameters in the default card. By default they
are included.
'''
thecard = SLHA.Card(name=self.name)
thecard.add_entry('basis', 1, self.name, name = 'translated basis')
preamble = ('\n###################################\n'
+ '## INFORMATION FOR {} BASIS\n'.format(self.name.upper())
+ '###################################\n')
thecard.blocks['basis'].preamble=preamble
- # default behaviour: create one 'newcoup' block, ignoring flavoured
+ # default behaviour: create one 'newcoup' block, ignoring flavored
if not self.blocks:
- omit = ([] if not self.flavoured else
+ omit = ([] if not self.flavored else
[c for (k,v) in self.fblocks.items() for c in v+[k]])
all_coeffs = [c for c in self.independent if c not in omit]
self.blocks = {'newcoup':all_coeffs}
# otherwise follow self.blocks structure
for blk, flds in self.blocks.iteritems():
for i,fld in enumerate(flds):
if dependent or (blk not in self.dependent
and fld not in self.dependent):
thecard.add_entry(blk, i+1, 0., name = fld)
- # deal with flavoured
+ # deal with flavored
for blk, flds in self.fblocks.iteritems():
for fld in flds:
index = (int(fld[-3]), int(fld[-1])) # XBcoeff(I)x(J)
if dependent or (blk not in self.dependent
and fld not in self.dependent):
- if self.flavoured[blk]['domain']=='complex':
+ if self.flavored[blk]['domain']=='complex':
thecard.add_entry(blk, index, 0., name = 'R'+fld[1:])
thecard.add_entry('IM'+blk, index, 0., name = 'I'+fld[1:])
else:
thecard.add_entry(blk, index, 0., name = fld)
vckm = self.default_ckm()
thecard.add_block(vckm)
thecard.ckm = vckm
thecard.set_complex()
self.fix_matrices(card = thecard)
return thecard
- def set_flavour(self, _from, to):
+ def set_flavor(self, _from, to):
if _from == to: return
- self.set_fblocks(to) # reset fblocks according to flavour option
+ self.set_fblocks(to) # reset fblocks according to flavor option
newcard = self.default_card(dependent=False)
if (_from, to) in (('general', 'universal'), ('general', 'diagonal')):
blks_to_del = []
for bname, blk in self.card.matrices.iteritems():
- # only consider declared flavour matrices
- if bname not in self.flavoured: continue
+ # only consider declared flavor matrices
+ if bname not in self.flavored: continue
# only consider independent blocks
if not newcard.has_matrix(bname):
blks_to_del.append(bname)
continue
to_del = []
# delete elements not present in default card
for k in blk.keys():
cname = blk.get_name(k)
if k not in newcard.matrices[bname]:
to_del.append(k)
for k in to_del:
del blk[k]
for blk in blks_to_del:
del self.card.matrices[blk]
elif to=='general':
for bname, blk in newcard.matrices.iteritems():
- # only consider declared flavour matrices
- if bname not in self.flavoured: continue
+ # only consider declared flavor matrices
+ if bname not in self.flavored: continue
# Add blocks absent in self.card but present in default card
if not self.card.has_matrix(bname):
self.card.add_block(blk)
continue
oneone = self.card.matrices[bname].get((1,1), 0.)
for k, v in blk.iteritems():
# only add value if element doesn't already exist in block
if k in self.card.matrices[bname]: continue
diag = (k[0] == k[1])
if diag: v = oneone
cname = blk.get_name(k)
self.card.add_entry(bname, k, v, name = cname)
def read_param_card(self):
'''
Call SLHA.read() and set up the Basis instance accordingly.
'''
self.card = SLHA.read(self.param_card, set_cplx=False)
try:
card_name = self.card.blocks.get('basis',[''])[1]
if self.name.lower()!=card_name.lower():
err = ('Rosetta was expecting to read an instance of '
+ '{}, named "{}", '.format(self.__class__.name, self.name)
+ 'but read the name '
+ '"{}" in block "basis" of {}.'.format(card_name,
self.param_card))
raise RosettaError(err)
except KeyError:
raise RosettaError('Formatting error for block basis. '
'Check input card, {}.'.format(self.param_card))
if not self.blocks:
# if self.blocks not defined, default behaviour is to automatically
# create self.blocks structure for independent parameters
for par in self.independent:
block = self.card._parent_block(par)
name = block.name
if name not in self.blocks:
self.blocks[name] = [par]
else:
self.blocks[name].append(par)
to_add = []
for bname, blk in self.card.matrices.iteritems():
- is_cplx = self.flavoured.get(bname,{}).get('domain','')=='complex'
+ is_cplx = self.flavored.get(bname,{}).get('domain','')=='complex'
if is_cplx:
if bname.lower().startswith('im'):
other_part = bname[2:]
else:
other_part ='IM' + bname
if other_part not in self.card.matrices:
to_add.append((bname,other_part))
for part, other_part in to_add:
blk = self.card.matrices[part]
for k, v in blk.iteritems():
if other_part.lower().startswith('im'):
imname = 'R' + blk.get_name(k)[1:]
else:
imname = 'I' + blk.get_name(k)[1:]
self.card.add_entry(other_part, k, 0., name=imname)
self.inputs = self.card.blocks.get('sminputs', None)
self.mass = self.card.blocks.get('mass', None)
self.card.set_complex()
self.fix_matrices()
def check_sminputs(self, required_inputs, message='Rosetta'):
'''
Check consistency of sminputs w.r.t required_inputs. Any inconsistencies
found will raise a warning and a question of whether the user wishes
to continue assuming default values for offending inputs. Higgs and Z
masses will also be stored as SM inputs.
'''
# Check all required inputs have been set
input_list = ', '.join( ['{} ({})'.format(x,input_names[x])
for x in required_inputs] )
if required_inputs:
if self.inputs is None:
repr_default = ['{}={: .5e}'.format(input_names[k],
default_inputs.get(k,0.)) for
k in required_inputs]
print 'Warning: Block "sminputs" not found. '\
'Assume default values for required inputs?'
print 'Required inputs: {}'.format(input_list)
carry_on = Y_or_N('Continue with default values '\
'for unspecified inputs? '\
'({})'.format(', '.join(repr_default)))
if carry_on:
theblock = SLHA.NamedBlock(name='sminputs')
for m in required_inputs:
theblock.new_entry(m, default_inputs[m],
name=input_names[m])
self.card.add_block(theblock)
self.inputs = theblock
else:
print 'Exit'
sys.exit()
else:
if self.mass:
for k,v in [(i,j) for i,j in self.mass.iteritems()
if i in (23,25)]:
i = PID_to_input[k]
if i in self.inputs:
v2 = float(self.inputs[i])
if v!=v2:
print ('Warning: {} '.format(input_names[i])
+ 'specified in block sminput[{}] '.format(i)
+ '({:.5e}) not consistent with '.format(v2)
+ 'value specified in block mass '
+ '[{}] ({:.5e}).\n'.format(k,float(v))
+ 'Rosetta will keep value from sminputs.')
self.mass[k]=v2
else:
mstring = 'M{}'.format(particle_names[k])
self.inputs.new_entry(i, v,name=mstring)
required = set(required_inputs)
inputs = set(self.inputs.keys())
missing_inputs = required.difference(inputs)
missing_values = {k:default_inputs.get(k,0.)
for k in missing_inputs}
repr_default = ['{}={: .5e}'.format(input_names[k],
default_inputs.get(k,0.)) for
k in missing_inputs]
if missing_inputs: # Deal with unassigned SM inputs
print 'Warning: Not all required SM inputs are '\
'defined for {}.'.format(message)
print 'Required inputs: {}'.format(input_list)
missing_list = ', '.join([str(x) for x in missing_inputs])
print 'Missing inputs: {}'.format(missing_list)
carry_on = Y_or_N(
'Continue with default values '\
'for unspecified inputs? '\
'({})'.format(', '.join(repr_default))
)
if carry_on: # sets unspecified inputs
for m in missing_inputs:
self.inputs.new_entry(m, default_inputs[m],
name=input_names[m])
else:
print 'Exit'
sys.exit()
# ensure presence of CKM matrix
vckm = self.card.matrices.get('vckm', None)
if vckm is None:
print 'Block "VCKM" not found, will use default values.\n'
vckm = self.default_ckm()
self.card.add_block(vckm)
self.ckm = vckm
def default_ckm(self):
preamble = ('\n###################################\n'
+ '## CKM INFORMATION\n'
+ '###################################\n')
ckm = SLHA.NamedMatrix(name='VCKM', preamble=preamble)
for i,j in product((1,2,3),(1,2,3)):
cname = 'RV{}{}x{}'.format(VCKMele[(i,j)], i, j)
ckm.new_entry((i,j), VCKM[i][j], name=cname)
imckm = SLHA.NamedMatrix(name='IMVCKM')
for i,j in product((1,2,3),(1,2,3)):
cname = 'IV{}{}x{}'.format(VCKMele[(i,j)], i, j)
imckm.new_entry((i,j), IMVCKM[i][j], name=cname)
vckm = SLHA.CNamedMatrix(ckm, imckm)
return vckm
def check_masses(self, required_masses, silent=False, message='Rosetta'):
'''
Check consistency of particle masses w.r.t required_masses. Any
inconsistencies found will raise a warning and a question of whether
the user wishes to continue assuming default values for masses. Higgs
and Z masses are also stored as SM inputs.
'''
PID_list = ', '.join([str(x) for x in required_masses])
if required_masses:
if self.mass is None:
repr_default = ['{}={: .5e}'.format(particle_names[k],
default_inputs.get(k,0.)) for
k in required_masses]
mass_list = ', '.join( ['{} (M{})'.format(x,particle_names[x])
for x in required_masses] )
if not silent:
print 'Warning: Block "mass" not found. '\
'Assume default values for required masses?'
print 'Required PIDs: {}'.format(mass_list)
carry_on = Y_or_N(
'Continue with default values '\
'for unspecified masses? '\
'({})'.format(', '.join(repr_default))
)
else:
carry_on=True
if carry_on:
theblock = SLHA.NamedBlock(name='mass')
for m in required_masses:
theblock.new_entry(m, default_masses[m],
name='M%s' % particle_names[m])
self.card.add_block(theblock)
self.mass = theblock
else:
print 'Exit'
sys.exit()
else:
if self.inputs:
for k,v in [(i,j) for i,j in self.inputs.iteritems()
if i in (4,25)]:
i = input_to_PID[k]
if i in self.mass:
v2 = float(self.mass[i])
if v!=v2:
if not silent:
print ('Warning: M{} '.format(particle_names[i])
+ 'specified in block sminput[{}] '.format(k)
+ '({:.5e}) not consistent with '.format(v)
+ 'value specified in block mass '
+ '[{}] ({:.5e}).\n'.format(i,float(v2))
+ 'Rosetta will keep value from sminputs.')
self.mass[i]=v
else:
mstring = 'M{}'.format(particle_names[i])
self.mass.new_entry(i, v, name=mstring)
masses = set(self.mass.keys())
required = set(required_masses)
missing_masses = required.difference(masses)
missing_values = {k:default_masses.get(k,0.)
for k in missing_masses}
if missing_masses: # Deal with unassigned fermion masses
repr_default = ['M{}={: .5e} GeV'.format(particle_names[k],v)
for k,v in missing_values.items()]
mass_list = ', '.join(['{} (M{})'.format(x,particle_names[x])
for x in missing_masses])
if not silent:
print 'Warning: Not all required masses are '\
'defined for {}.'.format(message)
print 'Required PIDs: {}'.format(PID_list)
print 'Missing PIDs: {}'.format(mass_list)
carry_on = Y_or_N(
'Continue assuming default values '\
'for unspecified masses? '\
'({})'.format(', '.join(repr_default))
)
else:
carry_on = True
if carry_on:
for m in missing_masses:
self.mass.new_entry(m, default_masses[m],
name='M%s' % particle_names[m])
else:
print 'Exit'
sys.exit()
def check_param_data(self, silent=False):
'''
Cross check of parameter data read in the SLHA formatted card.
Compares lists of coefficients declared in self.independent and
self.dependent to those read in from self.param_card.
1) Deals with unrecognised names by removing them from the block
2) Check consistency of name & numbering for the EFT basis blocks
declared in self.blocks. Renames coefficients according to their
position in each block's list.
2) Prints a warning if coefficients declared as dependent are
assigned values in param_card. The user is asked whether or not
they wish to continue knowing these values could be overwritten
by calculate_dependent().
3) Checks if all coefficients declared as independent are
assigned values. If not, the user is given the option to
continue with them set to 0.
'''
for bname, defined in self.blocks.iteritems():
# collect block info
inputblock = self.card.blocks.get(bname, None)
if inputblock is None:
theblock = SLHA.NamedBlock(name=bname)
self.card.add_block(theblock)
inputblock = theblock
input_eles = set(inputblock.keys())
defined_block = {i+1:v for i,v in enumerate(defined)}
defined_eles = set(defined_block.keys())
independent = {i:v for i,v in defined_block.iteritems()
if v in self.independent}
dependent = {i:v for i,v in defined_block.iteritems()
if v in self.dependent}
# check for unrecognised coefficient numbers
unknown = input_eles.difference(defined_eles)
if unknown:
unknown_names = {i:inputblock.get_name(i,'none')
for i in unknown}
if not silent:
print 'Warning: you have declared coefficients '\
'undefined in {}, block:{}.'.format(self.__class__,
bname)
print 'The following will be ignored - '\
'{}'.format(', '.join(['{}:"{}"'.format(k,v) for k,v
in unknown_names.iteritems()]))
for x in unknown: del inputblock[x]
# check that name, number pairs match
mismatched = []
unnamed = []
for index, name in independent.items():
input_name = inputblock.get_name(index, None)
if input_name is None:
inputblock._names[index] = name
elif input_name.lower()!=name.lower():
mismatched.append((index,name,input_name))
if mismatched:
if not silent:
print 'Warning: Mismatch of coefficient names '\
'in {}, block "{}".'.format(self.__class__,
bname)
for index, name, input_name in mismatched:
if not silent:
print (' Coefficient ' +
'{}, named {} '.format(index, input_name) +
'will be renamed to {}'.format(name))
inputblock._names[index] = name
inputblock._numbers[name] = index
# check if coefficients defined as dependent
# have been assigned values
defined_dependent = set(dependent).intersection(input_eles)
if defined_dependent:
if not silent:
print 'Warning: you have assigned values to some '\
'coefficients defined as dependent '\
'in {}, block "{}".'.format(self.__class__, bname)
print 'Coefficients: {}'.format(', '.join(
['{}:"{}"'.format(k,v)
for k,v in dependent.items()
if k in defined_dependent]
))
print 'These may be overwritten by an implementation of '\
'{}.calculate_dependent()'.format(self.__class__.__name__)
carry_on = Y_or_N('Continue?')
else:
carry_on = True
if carry_on:
pass
else:
print 'Exit'
sys.exit()
# check if all independent coefficients are assigned values
missing = set(independent).difference(input_eles).difference(set(dependent))
if missing: # Deal with unassigned independent coefficients
if not silent:
print 'Warning: some coefficients defined as independent '\
'in {}, block "{}", have not been assigned values'\
'.'.format(self.__class__,bname)
print 'Undefined: {}'.format(', '.join(
['{}:"{}"'.format(k,v)
for k,v in independent.items()
if k in missing]))
carry_on = Y_or_N('Continue assuming unspecified '\
'coefficients are Zero?')
else:
carry_on = True
if carry_on:
for m in missing:
inputblock.new_entry(m, 0., independent[m])
else:
print 'Exit'
sys.exit()
if len(inputblock)==0:
del self.card.blocks[inputblock.name]
- def check_flavoured_data(self, silent=False):
+ def check_flavored_data(self, silent=False):
'''
- Cross check of flavoured part of parameter data read in the SLHA
+ Cross check of flavored part of parameter data read in the SLHA
formatted card. Compares lists of coefficients declared in
self.independent and self.dependent to those read in from self.param_card.
1) Deals with unrecognised names by removing them from the block
2) Check consistency of name & numbering for the EFT basis blocks
declared in self.blocks. Renames coefficients according to their
position in each block's list.
2) Prints a warning if coefficients declared as dependent are
assigned values in param_card. The user is asked whether or not
they wish to continue knowing these values could be overwritten
by calculate_dependent().
3) Checks if all coefficients declared as independent are
assigned values. If not, the user is given the option to
continue with them set to 0.
'''
for bname, defined in self.fblocks.iteritems():
# collect block info
inputblock = self.card.matrices.get(bname, None)
if inputblock is None:
theblock = SLHA.NamedMatrix(name=bname)
self.card.add_block(theblock)
inputblock = theblock
input_eles = set(inputblock.keys())
defined_block = {(int(v[-3]),int(v[-1])):v for
i,v in enumerate(defined)}
defined_eles = set(defined_block.keys())
independent = {k:v for k,v in defined_block.iteritems()
if v in self.independent or bname in self.independent}
dependent = {k:v for k,v in defined_block.iteritems()
if v in self.dependent}
# check for unrecognised coefficient numbers
unknown = input_eles.difference(defined_eles)
if unknown:
unknown_names = {i:inputblock.get_name(i,'none')
for i in unknown}
if not silent:
print 'Warning: you have declared coefficients '\
'undefined in {}, matrix:{}.'.format(self.__class__,
bname)
print 'The following will be ignored - '\
'{}'.format(', '.join(['{}:"{}"'.format(k,v) for k,v
in unknown_names.iteritems()]))
for x in unknown: del inputblock[x]
# check that name, number pairs match
mismatched = []
unnamed = []
for index, name in independent.items():
input_name = inputblock.get_name(index, None)
if input_name is None:
inputblock._names[index] = name
elif input_name.lower()!=name.lower():
mismatched.append((index,name,input_name))
if mismatched:
if not silent:
print 'Warning: Mismatch of coefficient names '\
'in {}, matrix "{}".'.format(self.__class__,
bname)
for index, name, input_name in mismatched:
if not silent:
print (' Coefficient ' +
'{}, named {} '.format(index, input_name) +
'will be renamed to {}'.format(name))
inputblock._names[index] = name
inputblock._numbers[name] = index
# check if coefficients defined as dependent
# have been assigned values
defined_dependent = set(dependent).intersection(input_eles)
if defined_dependent:
if not silent:
print 'Warning: you have assigned values to some '\
'coefficients defined as dependent '\
'in {}, matrix "{}".'.format(self.__class__, bname)
print 'Coefficients: {}'.format(', '.join(
['{}:"{}"'.format(k,v)
for k,v in dependent.items()
if k in defined_dependent]
))
print 'These may be overwritten by an implementation of '\
'{}.calculate_dependent()'.format(self.__class__.__name__)
carry_on = Y_or_N('Continue?')
else:
carry_on = True
if carry_on:
pass
else:
print 'Exit'
sys.exit()
# check if all independent coefficients are assigned values
missing = set(independent).difference(input_eles).difference(set(dependent))
if missing: # Deal with unassigned independent coefficients
if not silent:
print 'Warning: some coefficients defined as independent '\
'in {}, matrix "{}", have not been assigned values'\
'.'.format(self.__class__,bname)
print 'Undefined: {}'.format(', '.join(
['{}:"{}"'.format(k,v)
for k,v in independent.items()
if k in missing]))
carry_on = Y_or_N('Continue assuming unspecified '\
'coefficients are Zero?')
else:
carry_on = True
if carry_on:
for m in missing:
inputblock.new_entry(m, 0., independent[m])
else:
print 'Exit'
sys.exit()
if len(inputblock)==0:
del self.card.matrices[inputblock.name]
def write_param_card(self, filename, overwrite=False):
'''Write contents of self.newcard to filename'''
preamble = ('\n###################################\n'
+ '## INFORMATION FOR {} BASIS\n'.format(self.newname.upper())
+ '###################################\n')
if 'basis' in self.newcard.blocks:
self.newcard.blocks['basis'].preamble = preamble
self.newcard.blocks['basis'][1] = self.newname
dec_preamble = ('\n###################################\n'
+ '## DECAY INFORMATION\n'
+ '###################################\n')
for decay in self.newcard.decays.values():
decay.preamble = dec_preamble
break
mass_preamble = ('\n###################################\n'
+ '## INFORMATION FOR MASS\n'
+ '###################################\n')
if 'mass' in self.newcard.blocks:
self.newcard.blocks['mass'].preamble = mass_preamble
sm_preamble = ('\n###################################\n'
+ '## INFORMATION FOR SMINPUTS\n'
+ '###################################\n')
if 'sminputs' in self.newcard.blocks:
self.newcard.blocks['sminputs'].preamble = sm_preamble
ckm_preamble = ('\n###################################\n'
+ '## CKM INFORMATION\n'
+ '###################################\n')
if 'vckm' in self.newcard.matrices:
self.newcard.matrices['vckm'].preamble = ckm_preamble
card_preamble = ( '################################################'
+'######################\n'
+'############# COEFFICIENTS TRANSLATED BY ROSETTA'
+' MODULE #############\n'
+'########### PARAM CARD GENERATED {} ##########'\
'#\n'.format(datetime.datetime.now().ctime().upper())
+'################################################'
+'######################\n\n')
if os.path.exists(filename) and not overwrite:
print '{} already exists.'.format(filename)
carry_on = Y_or_N('Overwrite?', default='no')
else:
carry_on=True
if carry_on:
special_blocks = ['loop','mass','sminputs','yukawa','vckm','basis']
coefforder = sortblocks(self.newcard, ignore = special_blocks)
self.newcard.write(filename, blockorder=special_blocks + coefforder,
preamble=card_preamble)
print 'Wrote "{}".'.format(filename)
return True
else:
return False
def write_template_card(self, filename, value=0.):
from machinery import bases
try:
val = float(value)
rand = False
except ValueError:
if value.lower() == 'random':
import random
rand = True
else:
print ('In write_template_card: "value" keyword argument '
'must either be a number or the string, "random".')
sys.exit()
- newinstance = bases[self.name](flavour=self.flavour, dependent=False)
+ newinstance = bases[self.name](flavor=self.flavor, dependent=False)
for k in newinstance.keys():
try:
if rand:
newinstance[k] = complex(random.uniform(-1.,1.),
random.uniform(-1.,1.))
else:
newinstance[k] = complex(val, val)
except TypeError as e:
if rand:
newinstance[k] = random.uniform(-1.,1.)
else:
newinstance[k] = val
SLHA_card = newinstance.card
mass_preamble = ('\n###################################\n'
+ '## INFORMATION FOR MASS\n'
+ '###################################\n')
massblock = SLHA.NamedBlock(name='mass', preamble=mass_preamble)
for m in self.required_masses:
massblock.new_entry(m, default_masses[m],
name='M%s' % particle_names[m])
SLHA_card.add_block(massblock)
sm_preamble = ('\n###################################\n'
+ '## INFORMATION FOR SMINPUTS\n'
+ '###################################\n')
inputblock = SLHA.NamedBlock(name='sminputs', preamble=sm_preamble)
for m in self.required_inputs:
inputblock.new_entry(m, default_inputs[m],
name='%s' % input_names[m])
SLHA_card.add_block(inputblock)
title = ' ROSETTA: {} BASIS INPUT CARD '.format(self.name.upper())
time = ' GENERATED {} '.format(datetime.datetime.now().ctime().upper())
nleft = int((80-len(title))/2.)
nright = 80-len(title)-nleft
preamble = ( '#'*80 + '\n'
+'#'*nleft + title + '#'*nright +'\n'
+'#'*22 + time + '#'*22 + '\n'
+'#'*80 +'\n')
special_blocks = ['mass','sminputs','vckm','basis']
theorder = sortblocks(SLHA_card, ignore = special_blocks)
SLHA_card.write(filename, blockorder=special_blocks + theorder,
preamble = preamble, postamble = ('\n'+'#'*80)*2)
print ('wrote {}'.format(filename))
def init_dependent(self):
'''
Adds entries defined as dependent to the corresponding block of
self.card so that they can be assigned values in calculate_dependent().
'''
for bname, fields in self.blocks.iteritems():
theblock = self.card.blocks.get(bname,[])
to_add = [f for f in fields if f in self.dependent
and f not in theblock]
for entry in to_add:
self.card.add_entry(bname, fields.index(entry)+1, 0., name=entry)
for bname, fields in self.fblocks.iteritems():
theblock = self.card.matrices.get(bname,[])
to_add = [f for f in fields if f in self.dependent
and f not in theblock]
for entry in to_add:
index = (int(entry[-3]), int(entry[-1]))
- if self.flavoured[bname]['domain']=='complex':
+ if self.flavored[bname]['domain']=='complex':
theblock = self.card.matrices.get(bname, None)
if not (isinstance(theblock, SLHA.CMatrix)
or isinstance(theblock, SLHA.CNamedMatrix)):
self.card.add_entry(bname, index, 0.,
name='R'+entry[1:])
self.card.add_entry('IM'+bname, index, 0.,
name='I'+entry[1:])
else:
self.card.add_entry(bname, index, complex(0.,0.),
name=entry)
else:
value = 0.
self.card.set_complex()
self.fix_matrices()
# for k,v in self.card.matrices.items():
# print k,type(v)
def check_calculated_data(self):
'''
Compares self.dependent and self.card to see if all dependent
coefficients have been calculated. If not, asks whether the user wants
to continue assuming they are zero.
'''
missing_dependents = set(self.dependent).difference(self.par_dict.keys())
if missing_dependents and self.dependent:
print 'Warning: Set of dependent coefficients calculated '\
'by {0}.calculate_dependent() does not match those '\
'specified in {0}.'.format(self.__class__)
print 'Undefined: {}'.format(', '.join(missing_dependents))
carry_on = Y_or_N('Continue assuming coefficients are Zero?')
if carry_on:
for m in missing_dependents: self.par_dict[m]=0.
else:
print 'Exit'
sys.exit()
print 'Calculated coefficients match those defined '\
'in {}.dependent.'.format(self.__class__.__name__)
def fix_matrices(self, card=None):
if card is None:
card = self.card
for name, matrix in card.matrices.iteritems():
- if name not in self.flavoured:
+ if name not in self.flavored:
continue
else:
- opt = self.flavoured[name]
+ opt = self.flavored[name]
kind, domain = opt['kind'], opt['domain']
if (kind, domain) == ('hermitian', 'complex'):
MatrixType = HermitianMatrix
elif (kind, domain) == ('symmetric', 'complex'):
MatrixType = CSymmetricMatrix
elif ((kind, domain) == ('hermitian', 'real') or
(kind, domain) == ('symmetric', 'real')):
MatrixType = SymmetricMatrix
elif (kind, domain) == ('general', 'real'):
MatrixType = TwoDMatrix
elif (kind, domain) == ('general', 'complex'):
MatrixType = CTwoDMatrix
else:
continue
card.matrices[name] = MatrixType(matrix)
def translate(self, target=None, verbose=True):
'''
Translation function. Makes use of existing translations and attempts to
find a path between the basis instance and the target basis. If a path
exists, successive translations are performed to get from A to B.
Keyword arguments:
target - target basis, must be defined in implemented.bases.
verbose - print some status messages.
'''
from machinery import get_path, relationships, bases
# default target
target = target if target is not None else self.output_basis
if target == self.name: return self
# find the chain of bases and translation functions
# to get from self.name to target
chain = get_path(self.name.lower(), target, relationships)
if not chain: # no translation possible
inputbasis = self.__class__.__name__
outputbasis = bases[target].__name__
err = ('Sorry, Rosetta cannot translate from ' +
'{} to {}'.format(inputbasis, outputbasis))
raise TranslationError(err)
names = [self.name.lower()]+[x[0] for x in chain]
if verbose:
print 'Rosetta will be performing the translation:'
print '\t'+' -> '.join([bases[x].__name__
for x in names])
# perform succesive translations, checking for
# required SM inputs/masses along the way
current = self
required_inputs = current.required_inputs
required_masses = current.required_masses
for target, function in chain:
# new target basis instance
instance = bases[target]()
# ensure required inputs are present
message = 'translation ({} -> {})'.format(current.name,
instance.name)
current.check_sminputs(required_inputs, message=message)
current.check_masses(required_masses, message=message)
# call translation function
new = function(current, instance)
# update new basis instance with non-EFT blocks, decays
- all_coeffs = (current.blocks.keys() + current.flavoured.keys())
+ all_coeffs = (current.blocks.keys() + current.flavored.keys())
new.get_other_blocks(current.card, all_coeffs)
# prepare for next step
required_inputs = set(instance.required_inputs)
required_masses = set(instance.required_masses)
current = new
if verbose:
print 'Translation successful.\n'
if current.name!='mass':
- current.flavour = self.flavour
- current.set_flavour('general', self.flavour)
+ current.flavor = self.flavor
+ current.set_flavor('general', self.flavor)
return current
def get_other_blocks(self, card, ignore):
ignore = [x.lower() for x in ignore]
other_blocks, other_matrices = {}, {}
for k, v in card.blocks.iteritems():
if k.lower() != 'basis' and k.lower() not in ignore:
other_blocks[k]=v
for k, v in card.matrices.iteritems():
if k.lower() != 'basis' and k.lower() not in ignore:
other_matrices[k]=v
for block in other_blocks:
theblock = card.blocks[block]
self.card.add_block(theblock)
for matrix in other_matrices:
theblock = card.matrices[matrix]
self.card.add_block(theblock)
for decay in card.decays.values():
self.card.add_decay(decay, preamble = decay.preamble)
if card.has_block('mass'):
self.mass=self.card.blocks['mass']
if card.has_block('sminputs'):
self.inputs=self.card.blocks['sminputs']
self.ckm = card.matrices['vckm']
def run_eHDECAY(self):
'''
Interface Rosetta with eHDECAY to calculate Higgs widths and branching
fractions.
'''
import eHDECAY
BRs = eHDECAY.run(self, electroweak=True)
sum_BRs = sum([v for k,v in BRs.items() if k is not 'WTOT'])
# sometimes eHDECAY gives a sum of BRs slightly greater than 1.
# for now a hacky global rescaling is implemented to deal with this.
if sum_BRs > 1:
if sum_BRs - 1. > 1e-2: # complain if its too wrong
raise RuntimeError('Sum of branching fractions > 1 by more than 1%')
else:
for channel, BR in BRs.iteritems():
if channel!='WTOT':
BRs[channel] = BR/sum_BRs
totalwidth = BRs.pop('WTOT')
if totalwidth < 0.:
print ('eHDECAY: Negative total Higgs width. Check your EFT inputs.')
return
hdecays = {}
# sometimes eHDECAY gives negative branching fractions.
for channel, BR in BRs.iteritems():
# n1, n2 = particle_names[channel[0]], particle_names[channel[1]]
# comment = 'H -> {}{}'.format(n1,n2)
# if BR < 0.:
# print ('eHDECAY: Negative branching fraction encountered ' +
# 'for {}. Rosetta will ignore it.'.format(comment))
# totalwidth -= BR # adjust total width
# continue
# elif BR == 0.:
# continue
if BR==0.:
continue
else:
hdecays[channel] = BR
# credit
preamble = ('# Higgs widths and branching fractions '
'calculated by eHDECAY.\n# Please cite '
'arXiv:hep-ph/974448 & arXiv:1403.3381.')
# new SLHA.Decay block
decayblock = SLHA.Decay(25, totalwidth, data=hdecays, preamble=preamble)
if 25 not in self.newcard.decays:
self.newcard.add_decay(decayblock)
else:
self.newcard.decays[25] = decayblock
print '#############################\n'
def calculate_dependent(self):
'''
Default behavoiur of calculate_dependent(). Called if a subclass of
Basis has not implemented the function.
'''
print 'Nothing done for {}.calculate_'\
'dependent()\n'.format(self.__class__.__name__)
def modify_inputs(self):
'''
Default behavoiur of calculate_dependent(). Called if a subclass of
Basis has not implemented the function.
'''
print 'Nothing done for {}.modify_'\
'inputs()\n'.format(self.__class__.__name__)
def check_modified_inputs(self, silent=False):
for k,v in [(i,j) for i,j in self.inputs.iteritems()
if i in (4,5,6,7,25)]:
i = input_to_PID[k]
if i in self.mass:
v2 = float(self.mass[i])
if v!=v2:
if not silent:
print ('Warning: M{} '.format(particle_names[i])
+ 'in block sminputs[{}] '.format(k)
+ '({:.5e}) not consistent with '.format(v)
+ 'value specified in block mass'
+ '[{}] ({:.5e}) '.format(i,float(v2))
+ 'after modify_inputs().\n')
keep_from_input = Y_or_N('Keep value from sminputs?')
else:
keep_from_input = True
if keep_from_input:
if not silent:
print ('Modified M{} '.format(particle_names[i]) +
'in block mass[{}]'.format(i))
self.mass[i]=v
else:
if not silent:
print ('Modified M{} '.format(particle_names[i]) +
'in block sminputs[{}]'.format(k))
self.inputs[k]=v2
else:
mstring = 'M{}'.format(particle_names[i])
self.mass.new_entry(i, v,name=mstring)
################################################################################
class TranslationError(Exception):
'''Fancy error name.'''
pass
################################################################################
-def flavour_coeffs(name, kind='hermitian', domain='real', flavour='general',
+def flavor_coeffs(name, kind='hermitian', domain='real', flavor='general',
cname = None):
'''
- Function to create flavour components of a coefficient according to its
+ Function to create flavor components of a coefficient according to its
properties. Takes a parameter name as an arguement and returns a tuple of
lists corresponding to the real and imaginary parts of the matrix elements.
The naming convention for real coefficients is to suffix the coefficient
name with the matrix indices separates by "x".
'''
index = (1, 2, 3)
if cname is None: cname = name
- if flavour.lower() == 'diagonal':
+ if flavor.lower() == 'diagonal':
include = lambda i,j: i == j
- elif flavour.lower() in ('universal','mfv'):
+ elif flavor.lower() in ('universal','mfv'):
include = lambda i,j: i == 1 and j == 1
else:
include = lambda i,j: True
if (kind, domain) == ('hermitian', 'complex'):
real = ['{0}{1}x{1}'.format(cname,i) for i in index if include(i,i)]
cplx = ['{}{}x{}'.format(cname,i,j) for i,j in
combinations(index,2) if include(i,j)]
elif (kind, domain) == ('symmetric', 'complex'):
real = []
cplx = ['{}{}x{}'.format(cname,i,j) for i,j in
combinations2(index,2) if include(i,j)]
elif ((kind, domain) == ('hermitian', 'real') or
(kind, domain) == ('symmetric', 'real')):
real = ['{}{}x{}'.format(cname,i,j) for i,j in
combinations2(index,2) if include(i,j)]
cplx = []
elif (kind, domain) == ('general', 'real'):
real = ['{}{}x{}'.format(cname,i,j) for i,j in
product(index,index) if include(i,j)]
cplx = []
elif (kind, domain) == ('general', 'complex'):
real = []
cplx = ['{}{}x{}'.format(cname,i,j) for i,j in
product(index,index) if include(i,j)]
else:
- print ('flavour_matrix function got and unrecognised combination of '
+ print ('flavor_matrix function got and unrecognised combination of '
'"kind" and "domain" keyword arguments')
return [name]
if (not cplx and domain!='complex'):
return real
else:
return ['C'+c for c in real+cplx]
def sortblocks(card, ignore = []):
normal_blocks = sorted([k for k in card.blocks.keys()
if k.lower() not in ignore],
key=str.lower)
flav_blocks = sorted([k for k in card.matrices.keys()
if k.lower() not in ignore],
key=str.lower)
flav_cplx = []
for im in [fl for fl in flav_blocks if fl.lower().startswith('im')]:
re = im[2:]
flav_cplx.append(re)
flav_cplx.append(im)
flav_blocks.remove(re)
flav_blocks.remove(im)
return normal_blocks + flav_blocks + flav_cplx
################################################################################
if __name__=='__main__':
pass
\ No newline at end of file
diff --git a/Rosetta/internal/SLHA.py b/Rosetta/internal/SLHA.py
index 59bc14b..0b8a61d 100644
--- a/Rosetta/internal/SLHA.py
+++ b/Rosetta/internal/SLHA.py
@@ -1,1128 +1,1132 @@
from collections import OrderedDict, MutableMapping
from operator import itemgetter
import sys
import re
import os
-
+__doc__ = '''
+Module for parsing SLHA style input cards and storing BLOCK and DECAY structures
+into python dict-like objects that can be indexed and iterated over in a case
+insensitive way.
+'''
class CaseInsensitiveDict(MutableMapping):
def __init__(self, data=None, **kwargs):
self._data = {}
if data is None:
data = {}
self.update(data, **kwargs)
def __setitem__(self, key, value):
self._data[key.lower()] = (key, value)
def __getitem__(self, key):
return self._data[key.lower()][1]
def __delitem__(self, key):
del self._data[key.lower()]
def __iter__(self):
return (casedkey for casedkey, mappedvalue in self._data.values())
def __len__(self):
return len(self._data)
def __repr__(self):
return repr([(k,v) for (k,v) in self._data.values()])
class CaseInsensitiveOrderedDict(MutableMapping):
def __init__(self, data=None, **kwargs):
self._data = OrderedDict()
if data is None:
data = {}
self.update(data, **kwargs)
def __setitem__(self, key, value):
self._data[key.lower()] = (key, value)
def __getitem__(self, key):
return self._data[key.lower()][1]
def __delitem__(self, key):
del self._data[key.lower()]
def __iter__(self):
return (casedkey for casedkey, mappedvalue in self._data.values())
def __len__(self):
return len(self._data)
def __repr__(self):
return repr([(k,v) for (k,v) in self._data.values()])
class Block(MutableMapping):
'''
Container class for SLHA block with a single counter. A subclass of
`collections.OrderedDict`with a restriction on integer keys and a modified
__repr__(). Block can't be initialised with any positional arguments but
rather with the 'data' keyword argument. It can optionally be named using
the 'name' keyword argument. The__str__ function are also defined to output
the contained data in an SLHA formatted block.
'''
def __checkkey__(self, key):
'''Forces key to be of integer type.'''
if type(key) is not self.keytype:
raise TypeError("Key: '{}'. ".format(key) + self.__class__.__name__
+ ' only accepts keys of {}.'.format(self.keytype))
else:
return key
def __cast__(self, val):
'''
Attempts to cast values to type specified in 'vtype' keyword argument
of constructor.
'''
try:
return self.cast(val)
except ValueError:
return val
def __init__(self, name=None, decimal=5, ktype=int, vtype=float,
preamble='', data=None):
''' Intialisation keyword arguments:
name - A name for the block that will appear
in the __str__ and __repr__ methods.
data - A dict type object supporting iteritems()
to initialize Block values.
decimal - Number of decimal points with which
to write out parameter values.
vtype - a function to cast parameter values if
read in as strings i.e. int, float.
preamble - Some text to print before the __str__ output.
'''
self._data = OrderedDict()
self.name = name
self.keytype = ktype
self.cast = vtype # value casting function
self.fmt = ':+.{}e'.format(decimal) # format string
self.preamble = preamble
if data is not None:
self._data.update(data)
def __setitem__(self, key,value):
self._data[self.__checkkey__(key)] = self.__cast__(value)
def __getitem__(self, key):
return self._data[self.__checkkey__(key)]
def __contains__(self, key):
return key in self._data
def __delitem__(self, key):
del self._data[self.__checkkey__(key)]
def __iter__(self):
return iter(self._data)
def __len__(self):
return len(self._data)
def __repr__(self):
return ('<{}: "{}"; {} entries.>'.format(self.__class__,
self.name, len(self)))
def __str__(self):
content = []
sortitems = sorted(self.items())
for k,v in sortitems:
try:
val = float(v)
fmt = self.fmt
except ValueError:
fmt = ''
line = (' {{: <4}} {{{}}}\n'.format(fmt)).format
content.append(line(k,val))
string = (self.preamble+'\n'
+'BLOCK {}\n'.format(self.name)
+ ''.join(content))
return string
def dict(self):
'''Return SHLA Block data as a regular python dict.'''
return self._data
class Matrix(Block):
'''
Container class for SLHA block with multiple counters. A subclass of
`collections.OrderedDict`with a restriction on tuple keys and a modified
__repr__(). Block can't be initialised with any positional arguments but
rather with the 'data' keyword argument. It can optionally be named using
the 'name' keyword argument. The__str__ function are also defined to output
the contained data in an SLHA formatted block. The object is indexed
like a numpy multi dimensional array ( x[i,j,k,...] ).
'''
def __init__(self, *args, **kwargs):
kwargs['ktype'] = tuple
super(Matrix, self).__init__(*args, **kwargs)
def __str__(self):
content = []
sortitems = sorted(self.items(), key=itemgetter(0,0))
for k,v in sortitems:
try:
v = float(v)
fmt = self.fmt
except ValueError:
fmt=''
ind = '{: <4}'*len(k)
line = (' {} {{{}}}\n'.format(ind,fmt)).format
args = list(k)+[v]
content.append(line(*args))
string = (self.preamble+'\n'
+'BLOCK {}\n'.format(self.name)
+ ''.join(content) )
return string
def dimension(self):
indx = []
for i,k in enumerate(self.keys()):
if i==0:
indx = [[] for _ in k]
for j, l in enumerate(k):
indx[j].append(l)
isets = [sorted(list(set(x))) for x in indx]
for i,s in enumerate(isets):
smin, smax = min(s), max(s)
if not s == range(smin,smax+1):
strs = [str(x) for x in s]
err = ('subdimension {} of array '.format(i) +
'{}, ({}), is not complete range.'.format(repr(self),
','.join(strs)))
raise SLHAError(err)
return tuple( [len(x) for x in isets] )
def array(self):
array = []
for k,v in self.iteritems():
if isinstance(v,Matrix):
array.append(v.array())
else:
array.append([v for v in v.values()])
return array
class NamedBlock(Block):
'''
Class derived from 'Block' with the added functionality of assigning a name
to each key via the 'names' keyword argument. The values can then also be
referenced by name via a lookup in self._numbers.
'''
def __parse__(self, key):
'''
Allows for elements to additionally be referred to by name.
Looks up self._numbers for an assigned name and returns the
associated key. Rasies KeyError if name is not booked.
Used in overloading __setitem__, __getitem__, __contains__
and __delitem__.
'''
if type(key) is str:
try:
return self._numbers[key]
except KeyError:
err = ('Name "{}" has not been assigned to a '.format(key) +
'key in {} {}._names'.format(self.__class__, self.name))
raise KeyError(err)
else:
return key
def __init__(self, name=None, comment='', decimal=5, data = None,
ktype=int, vtype=float, preamble=''):
'''
Same as the SLHA.Block constructor but additionally checks if the data
keyword argument has a "_names" attribute (i.e. if it is an existing
instance of NamedBlock) and stores it. The "comment" keyword argument
prints a comment to the right of the block declaration in __str__().
'''
if data is not None and hasattr(data, '_names'):
self._names = data._names
try:
self._numbers = CaseInsensitiveOrderedDict({v:k for k,v
in self._names.iteritems()})
except AttributeError:
raise ValueError('"names" keyword argument must be a'
'dictionary or support iteritems() method.')
else:
self._names, self._numbers = {}, CaseInsensitiveDict()
self.comment = comment
return super(NamedBlock, self).__init__(name=name, data=data,
ktype=ktype, vtype=vtype,
decimal=decimal,
preamble = preamble)
def __setitem__(self, key, value):
return super(NamedBlock, self).__setitem__(self.__parse__(key), value)
def __getitem__(self, key):
return super(NamedBlock, self).__getitem__(self.__parse__(key))
def __delitem__(self, key):
super(NamedBlock, self).__delitem__(self.__parse__(key))
# Additional cleanup needed for _names and _numbers lookup dicts.
if type(key) is str:
try:
del self._names[self._numbers[key]]
del self._numbers[key]
except KeyError:
pass
else:
try:
del self._numbers[self._names[key]]
del self._names[key]
except KeyError:
pass
def __contains__(self, key):
try:
return super(NamedBlock, self).__contains__(self.__parse__(key))
except KeyError:
return False
def __repr__(self):
return ('< {}: "{}", {} entries ({} named). >'.format(self.__class__,
self.name,
len(self),
len(self._names)))
def __str__(self):
content = []
sortitems = sorted(self.items(), key=itemgetter(0))
for k,v in sortitems:
try:
strval = ('{{{}}}'.format(self.fmt)).format(float(v))
except ValueError:
strval = v
if k in self._names:
content.append(' {: <4} {} # {}\n'.format(k, strval,
self._names[k]))
else:
content.append(' {: <4} {}\n'.format(k,strval))
string = (self.preamble + '\n'
+ 'BLOCK {} # {}\n'.format(self.name, self.comment)
+ ''.join(content))
return string
def get_name(self, key, default=''):
return self._names.get(key, default)
def get_number(self, name, default=None):
return self._numbers.get(name, default)
def new_entry(self, key, value, name=None):
'''
Add a new named block entry. Ensures that the key hasn't already
been set and the name given hasn't already been booked.
'''
if key in self:
err = ("Key '{}' already belongs to {} ".format(key,
self.__class__)
+ "'{}', mapped to name '{}'.".format(self.name,
self.get_name(key)))
raise KeyError(err)
if name in self._numbers:
err = ("Name '{}' already booked in ".format(name) +
"NamedBlock {}, mapped to key '{}'.".format(
self.name, self._numbers[name]))
raise KeyError(err)
else:
if name is not None:
self._names[key] = name
self._numbers[name] = key
self[key]=value
def namedict(self):
'''Return python dict of name:key pairs.'''
return {self._names[k]:v for k,v in self.iteritems()
if k in self._names }
class NamedMatrix(Matrix, NamedBlock):
'''
Class derived from `Matrix` and `NamedBlock` to add the named indexing
functionality to the multi-counter SLHA block structure.
'''
def __setitem__(self, key, value):
return super(NamedMatrix, self).__setitem__(self.__parse__(key), value)
def __getitem__(self, key):
return super(NamedMatrix, self).__getitem__(self.__parse__(key))
def __str__(self):
content = []
sortitems = sorted(self.items(), key=itemgetter(0,0))
for k,v in sortitems:
try:
v = float(v)
fmt = self.fmt
except ValueError:
fmt=''
vname = self._names.get(k,None)
comment = '' if vname is None else '# {}'.format(vname)
ind = '{: <4}'*len(k)
line = (' {} {{{}}} {{}}\n'.format(ind,fmt)).format
args = list(k)+[v, comment]
content.append(line(*args))
string = (self.preamble+'\n'
+'BLOCK {}\n'.format(self.name)
+ ''.join(content) )
return string
class CBlock(Block):
container = Block
def __init__(self, *args):
if not args:
re, im = self.container(name='_re'), self.container(name='_im')
self.__init__(re,im)
return
else:
try:
real, imag = args
except ValueError:
err = ('{}.__init__() takes 0 '.format(self.__class__)+
'or 2 arguments ({} given)'.format(len(args)))
raise TypeError(err)
assert type(real) is self.container and type(imag) is self.container, (
' Cblock constructor takes 2 {} '.format(self.container)
+ 'objects as arguments')
name, decimal, preamble = real.name, int(real.fmt[-2]), real.preamble
super(CBlock, self).__init__(name=name, decimal=decimal,
preamble=preamble, vtype=complex)
self.fill(real, imag)
def fill(self, real, imag):
'''
Fill a CBlock from two Block instances containing the
real and imaginary parts
'''
self._re, self._im = real, imag
for k, re in real.iteritems():
try:
im = imag[k]
entry = complex(re,im)
except KeyError:
entry = re
self[k] = entry
def __setitem__(self, key, value):
cval = complex(value)
re, im = value.real, value.imag
self._re[key], self._im[key] = re, im
super(CBlock, self).__setitem__(key, cval)
def __str__(self):
return self.preamble + str(self._re) + str(self._im)
class CMatrix(CBlock, Matrix):
container = Matrix
class CNamedBlock(CBlock, NamedBlock):
container = NamedBlock
def _part(self, key):
if key in self._re:
return self._re
elif key in self._im:
return self._im
else:
raise KeyError('Key "{}" not found in {} "{}"'.format(key,
self.__class__,
self.name))
def fill(self, real, imag):
'''
Fill a CBlock from two Block instances containing the
real and imaginary parts
'''
self._re, self._im = real, imag
for k, re in real.iteritems():
try:
im = imag[k]
entry = complex(re,im)
except KeyError:
entry = re
try:
cname = real._names[k]
cname = 'C'+cname[1:] if cname.startswith('R') else 'C'+cname
except (AttributeError, KeyError):
index = 'x'.join(map(str,k))
cname = 'C{}{}'.format(real.name, index)
self.new_entry(k, entry, name=cname)
for k, im in imag.iteritems():
if k not in real:
try:
cname = imag._names[k]
cname = 'C'+cname[1:] if cname.startswith('I') else 'C'+cname
except (AttributeError, KeyError):
index = 'x'.join(map(str,k))
cname = 'C{}{}'.format(imag.name, index)
self.new_entry(k, entry, name=cname)
def __setitem__(self, key, value):
if type(key) is str and (key in self._re or key in self._im):
part = self._part(key)
key = part.__parse__(key)
part.__setitem__(key, value)
if part is self._re:
self[key] = complex(value, self[key].imag)
elif part is self._im:
self[key] = complex(self[key].real, value)
else:
key = self.__parse__(key)
cval = complex(value)
re, im = value.real, value.imag
self._re[key], self._im[key] = re, im
super(CBlock, self).__setitem__(key, cval)
def __getitem__(self, key):
if type(key) is str and (key in self._re or key in self._im):
part = self._part(key)
return part.__getitem__(key)
else:
return super(CNamedBlock, self).__getitem__(key)
def __delitem__(self, key):
if type(key) is str and (key in self._re or key in self._im):
part = self._part(key)
key = part.__parse__(key)
if part is self._re:
self[key] = complex(0., self[key].imag)
elif part is self._im:
self[key] = complex(self[key].real, 0.)
part.__delitem__(key)
else:
key = self.__parse__(key)
try:
del self._re[key]
except KeyError:
pass
try:
del self._im[key]
except KeyError:
pass
super(CNamedBlock, self).__delitem__(key)
def __contains__(self, key):
if type(key) is str:
return (key in self._re or key in self._im or
super(CNamedBlock, self).__contains__(key))
else:
return super(CNamedBlock, self).__contains__(key)
def get_number(self, name, default=None):
if (name in self._re or name in self._im):
part = self._part(name)
else:
part = self
return part._numbers.get(name, default)
class CNamedMatrix(CNamedBlock, NamedMatrix):
container = NamedMatrix
class Decay(MutableMapping):
'''
Container class for SLHA Decay blocks. A subclass of `collections.OrderedDict`
with a restriction on tuple keys and float values less than 1. A modified
__repr__() function is implemented for easy writing to file. Decay is
initialised with a PID argument to specify the particle to which it refers
as well as its total width. The sum of branching ratios is kept and a
ValueError will be raised if the total exceeds 1. It can optionally be
named using the 'name' keyword argument. Finally a __str__() function is
also defined to output the SLHA formatted block.
'''
def __checkkey__(self, key):
''' Forces key to be a tuple and casts the elements to integers.'''
if type(key) is not tuple:
raise TypeError( self.__class__.__name__ +
' only accepts tuple keys: (PID1, PID2,...).' )
else:
return tuple(map(int,key))
def __checkval__(self, val):
''' Forces values (i.e. branching ratios) to be a float less than 1.'''
try:
fval = float(val)
except ValueError:
raise TypeError( self.__class__.__name__ +
' only accepts floats or values castable via float()' )
if fval > 1.:
raise TypeError("SLHA Decay object for PID = {}. ".format(self.PID)+
"Branching ratio > 1 encountered : {}".format(fval))
return fval
def __init__(self, PID, total,
data=None, comment='', decimal=5, preamble= ''):
''' Positional arguments:
PID - integer to denote particle whose decay is being described
total - total width
Keyword arguments:
data - A dict type object supporting iteritems()
to initialize Decay values.
comment - prints a comment to the right of the block
declaration in __str__().
decimal - Number of decimal points with which
to write out width and BRs.
preamble - Some text to print before the __str__ output.'''
try:
self.PID=int(PID)
except ValueError:
err = ("SLHA Decay object for PID = {}. ".format(PID) +
"'PID' argument must be an integer or be castable via int()")
raise TypeError(err)
try:
self.total=float(total)
except ValueError:
err = ("SLHA Decay object for PID = {}. ".format(PID) +
"'total' argument must be a float or be castable via float()")
raise TypeError(err)
self._BRtot = 0.
self._fmt = ':+.{}e'.format(decimal)
self._comment = comment
self._decimal = decimal
self._comments = {}
self.preamble = preamble
self._data = OrderedDict()
if data is not None:
self._data.update(data)
def __setitem__(self, key, value):
self._data[self.__checkkey__(key)] = self.__checkval__(value)
self._BRtot+=self.__checkval__(value)
if self._BRtot > 1.:
print '!!! ERROR !!!'
print self
raise ValueError("SLHA Decay object for PID = {}. ".format(self.PID)
+ "Sum of branching ratios > 1!")
def __getitem__(self, key):
return self._data[self.__checkkey__(key)]
def __delitem__(self, key):
del self._data[self.__checkkey__( key )]
self._BRtot-=self.__checkval__(self[key])
def __iter__(self):
return iter(self._data)
def __len__(self):
return len(self._data)
def __repr__(self):
return ( '<SHLA Decay: PID={}; {} entries.>'.format(self.PID,
len(self)) )
def __str__(self):
above = '# PDG Width\n'
title = ('DECAY {{:<10}} {{{}}} # {{}}\n'.format(self._fmt)).format
below = '# BR{} NDA ID1 ID2...\n'.format(' '*self._decimal)
if len(self)==0: below=''
content = []
for k,v in self.iteritems():
nparts = len(k)
idfmt = nparts*'{: <10}'
line = ('{{{}}} {{: <10}}{}'.format(self._fmt,idfmt)).format
cmnt = ('# {}'.format(self._comments[k])
if k in self._comments else '')
content.append(line(v, nparts, *k) + cmnt)
string = (self.preamble + '\n' + above
+ title(self.PID, self.total, self._comment)
+ below + '\n'.join(content) )
return string
def new_channel(self, PIDs, BR, comment=None):
'''
Add a new decay channel.
PIDs - tuple of integers.
BR - the branching ratio into that channel.
comment - optional comment to be written to the
right of that channel in __str__().
'''
self[PIDs]=BR
if comment is not None: self._comments[PIDs]=comment
class Card(object):
'''
SLHA card object: a container for storing multiple SLHA.Block,
SLHA.NamedBlock and SLHA.Decay objects. Blocks and decays are stored in
OrderedDicts self.blocks and self.decays respectively.
Index syntax mycard[key] can be used to get or set elements of blocks or
decays possessed by the Card instance. If passed a string key, the card
instance will look up the first block in self.blocks possessing a parameter
with the given name while an int key will return the SLHA.Decay object for
that PID.
'''
def _parent_block(self, key):
'''
Returns the parent of a given string key. First searches for a Matrix
object with that name, then searches in self.matrices for a Matrix
containing that name and finally searches in self.blocks for a block
containing that name. Otherwise raises Key error.
'''
if self.has_matrix(key): return self.matrices
for block in self.matrices.values():
if key in block: return block
try:
if key in block._re:
return block._re
if key in block._im:
return block._im
except AttributeError:
pass
for block in self.blocks.values():
if key in block: return block
return None
def _container(self, key):
'''
Returns the container containing the indexed key. Used in overloading
__setitem__, __getitem__, __contains__ and __delitem__.
'''
if type(key) is int:
return self.decays
elif type(key) is str:
return self._parent_block(key.lower())
else:
err = ('SLHA Card has integer keys for '
'DECAY and string keys for BLOCK.')
raise ValueError(err)
def __init__(self, blocks=None, decays=None, name=None):
''' Keyword arguments:
blocks - a dictionary of items with which to initialise
individual blocks in the card instance i.e.
name:block pairs with block an SLHA.NamedBlock.
decays - a dictionary of SLHA.Decay objects.
matrices - a dictionary of SLHA.NamedMatrix objects.
name - card name'''
self.blocks = CaseInsensitiveOrderedDict()
self.decays = OrderedDict()
self.matrices = CaseInsensitiveOrderedDict()
self.name = name if name is not None else ''
if blocks is not None:
for bname, block in blocks.iteritems():
self.blocks[bname] = NamedBlock(name=bname, data=block)
if decays is not None:
for PID, decay in decays.iteritems():
self.decays[PID]= Decay(PID,decay.total, data=decay)
def __repr__(self):
return ('<SHLA Card "{}": {} blocks, {} decays.>'.format(self.name,
len(self.matrices)+ len(self.blocks), len(self.decays)))
def __contains__(self, key):
container = self._container(key)
return True if container is not None else False
def __getitem__(self, key):
container = self._container(key)
if container is not None:
return container[key.lower()]
else:
err = 'Key/Matrix "{}" not found in {}'.format(key, self)
raise KeyError(err)
def __delitem__(self, key):
container = self._container(key)
if container is not None:
del container[key.lower()]
else:
err = 'Key/Matrix "{}" not found in {}'.format(key, self)
raise KeyError(err)
def __setitem__(self, key, value):
container = self._container(key)
if container is not None:
return container.__setitem__(key.lower(), value)
else:
err = 'Key/Matrix "{}" not found in {}'.format(key, self)
raise KeyError(err)
def add_block(self, block, preamble=''):
'''
Append an SLHA.Block, NamedBlock, Matrix or NamedMatrix to
self.blocks or self.matrices depending on the type.
'''
block.preamble = preamble
if isinstance(block,Matrix):
self.matrices[block.name] = block
else:
self.blocks[block.name] = block
def add_decay(self, decay, preamble=''):
'''Append an SLHA.Decay to self.decays.'''
decay.preamble = preamble
self.decays[decay.PID] = decay
def add_entry(self, blockname, key, value, name=None):
'''
Add a new field in a given block. If the Card instance already
has such a block, a new field is appended. If the Card doesn't, a new
block is created.
'''
if self.has_block(blockname):
self.blocks[blockname].new_entry(key, value, name=name)
elif self.has_matrix(blockname):
self.matrices[blockname].new_entry(key, value, name=name)
else:
if type(key) is tuple:
container = Matrix if name is None else NamedMatrix
cplxcontainer = CMatrix if name is None else NamedMatrix
else:
container = Block if name is None else NamedBlock
cplxcontainer = CBlock if name is None else NamedBlock
if type(value) is complex:
reblock = container(name=blockname)
imblock = container(name='IM'+blockname)
theblock = cplxcontainer(reblock, imblock)
else:
theblock = container(name=blockname)
if name is None:
theblock.new_entry(key, value)
else:
theblock.new_entry(key, value, name=name)
self.add_block(theblock)
def add_channel(self, PID, channel, partial, comment=None):
'''
Add a new channel in a given decay. The Decay for the given PID
must already exist in the Card instance.
'''
assert(self.has_decay(PID)),('Tried adding a decay channel '
'for non existent decay PID')
self.decays[PID].new_channel(channel, partial, comment=comment)
def new_channel(self, PIDs, BR, comment=None):
'''Append a new channel to a given Decay block.'''
self[PIDs]=BR
if comment is not None: self._comments[PIDs]=comment
def has_block(self, name):
return name.lower() in self.blocks
def has_matrix(self, name):
return name.lower() in self.matrices
def has_decay(self, PID):
return PID in self.decays
def write(self, filename, blockorder = [], preamble='',postamble=''):
'''
Write contents of Card in SLHA formatted style to "filename".
Makes use of the __str__ methods written for the SLHA elements.
Keyword arguments:
blockorder - Specify an ordering for printing the block names.
Names given in blockorder will be printed first in the
order specified and others will be printed as ordered
in self.blocks
preamble - Some text to write before the Block and Decay information
postamble - Some text to write after the Block and Decay information
'''
with open(filename,'w') as out:
out.write(preamble)
blockorder = [x.lower() for x in blockorder]
allblocks = self.blocks.keys() + self.matrices.keys()
other_blocks = [b for b in allblocks if b.lower() not in blockorder]
for block in blockorder:
if self.has_block(block):
out.write(str(self.blocks[block]))
elif self.has_matrix(block):
out.write(str(self.matrices[block]))
for block in other_blocks:
if self.has_block(block):
out.write(str(self.blocks[block]))
elif self.has_matrix(block):
out.write(str(self.matrices[block]))
for decay in self.decays.values():
out.write(str(decay))
out.write(postamble)
def set_complex(self):
'''
Processes self.blocks and self.matrices to find real and imaginary
pairs, upgrading them to a single complex version.
'''
cplx = []
for imkey in self.blocks.keys():
if imkey.lower().startswith('im'):
rekey = imkey[2:]
if rekey in self.blocks:
if not isinstance(self.blocks[rekey], CBlock):
cplx.append((rekey,imkey))
for rekey, imkey in cplx:
reblk = self.blocks.get(rekey, None)
imblk = self.blocks.pop(imkey, None)
container = type(reblk)
if container is Block:
ctype = CBlock
elif container is NamedBlock:
ctype = CNamedBlock
cblk = ctype(reblk, imblk)
self.blocks[rekey] = cblk
cplx = []
for imkey in self.matrices.keys():
if imkey.lower().startswith('im'):
rekey = imkey[2:]
if rekey in self.matrices:
if not isinstance(self.matrices[rekey], CBlock):
cplx.append((rekey,imkey))
for rekey, imkey in cplx:
reblk = self.matrices.get(rekey, None)
imblk = self.matrices.pop(imkey, None)
container = type(reblk)
if container is Matrix:
ctype = CMatrix
elif container is NamedMatrix:
ctype = CNamedMatrix
cblk = ctype(reblk, imblk)
self.matrices[rekey] = cblk
class SLHAError(Exception): # Custom error name
pass
def read(card, set_cplx=True):
'''
SLHA formatted card reader. Blocks and Decay structures are read
into an SLHA.Card object which is returned. Comments are specified by the #
character. Comments to the right of the structures as wel as the individual
fields are stored.
'''
def get_comment(line):
'''
Returns characters following a "#" in line.
returns empty string if match is not found.
'''
match = re.match(r'.*#\s*(.*)\s*', line)
if match: return match.group(1).strip()
else: return ''
thecard = Card()
pcard = open(card,'r')
lines = iter(pcard)
counter = 0
try:
while True:
counter+=1 # keep track of line number
stop=False
try: ll=(last_line.strip())
except NameError: ll = (lines.next()).strip()
if not ll: continue
first_chars = re.match(r'\s*(\S+).*',ll).group(1).lower()
if first_chars=='block':
try:
block_details = re.match(r'\s*block\s+([^\n]+)',ll,
re.IGNORECASE).group(1)
except AttributeError:
err = ('Invalid block format encountered ' +
'in line {} of {}.'.format(counter, card) )
raise SLHAError(err)
bname = block_details.split('#')[0].strip()
comment = get_comment(ll)
block_data, last_line, stop = read_until(lines,'block','decay')
elements = []
for datum in block_data:
counter +=1
is_comment = re.match(r'\s*#.*',datum)
if (not datum.strip() or is_comment): continue
info = re.match(r'\s*((?:\d+\s+)+)\s*(\S+).*',
datum)
if not info:
print datum
print ('Ignored datum in block '+
'{},'.format(theblock.name) +
' (line {} of {})'.format(counter, card))
continue
key, value = info.group(1), info.group(2)
try:
key = int(key)
except ValueError:
key = tuple( map(int, key.split()) )
dname = get_comment(datum)
try:
entry = float(value)
except ValueError:
entry = value
finally:
elements.append((key,value,dname))
if type(elements[0][0]) is tuple:
theblock = NamedMatrix(name=bname, comment=comment)
else:
theblock = NamedBlock(name=bname, comment=comment)
for ele in elements:
theblock.new_entry(*ele)
thecard.add_block(theblock)
elif first_chars=='decay':
try:
decay_details = re.match(r'\s*decay\s+(.+)',ll,
re.IGNORECASE).group(1)
except AttributeError:
err = ('Invalid decay format encountered' +
'in line {} of {}.'.format(counter, card) )
raise SHLAReadError(err)
info = re.match(r'\s*(\d+)\s+(\S+)\s+.*', decay_details)
PID, total = info.group(1), info.group(2)
comment = get_comment(decay_details)
thedecay = Decay(PID=int(PID), total=float(total),
comment=comment)
decay_data, last_line, stop = read_until(lines,'block','decay')
for datum in decay_data:
counter +=1
is_comment = re.match(r'\s*#.*',datum)
if ((not datum.strip()) or (is_comment)): continue
info = re.match(r'\s*(\S+)\s+(\d+)\s+(.+)',datum)
if not info:
print datum
print ('Ignored above datum in decay '+
'{},'.format(thedecay.PID) +
' (line {} of {})'.format(counter, card))
continue
BR, nout = info.group(1), info.group(2)
PIDinfo = info.group(3).split('#')[0]
PIDs = tuple( map(int, PIDinfo.split()) )
if len(PIDs)!=int(nout):
print ("Number of external particles in column 2 doesn't "
"match number of subsequent columns:")
print datum
print ('Ignored above datum in decay '+
'{},'.format(thedecay.PID) +
' (line {} of {})'.format(counter, card))
continue
comment = get_comment(datum)
thedecay.new_channel(PIDs, float(BR), comment=comment)
thecard.add_decay(thedecay)
if stop: raise StopIteration
except StopIteration:
pcard.close()
if set_cplx:
thecard.set_complex()
return thecard
def read_until(lines, here, *args):
'''
Loops through an iterator of strings by calling next() until
it reaches a line starting with a particular string.
Case insensitive.
Args:
lines - iterator of strings
here - string (plus any further argumnts).
Reading will end if the line matches any of these.
Return:
lines_read - list of lines read
line - last line that was read (containing string "here")
'''
end_strings = [here.lower()]+[a.lower() for a in args]
lines_read = []
line = ''
stopiter = False
while not any([line.strip().lower().startswith(x) for x in end_strings]):
try:
line = lines.next()
lines_read.append(line.strip('\n'))
except StopIteration:
stopiter=True
break
try:
if stopiter:
return lines_read, '', stopiter
else:
return lines_read[:-1], lines_read[-1], stopiter
except IndexError:
return [],'',stopiter
if __name__=='__main__':
pass
diff --git a/Rosetta/internal/__init__.py b/Rosetta/internal/__init__.py
index 6ff7032..8b5c365 100644
--- a/Rosetta/internal/__init__.py
+++ b/Rosetta/internal/__init__.py
@@ -1,50 +1,8 @@
-from math import sqrt
-################################################################################
-# PDG ID dictionary
-PID = {'u':{1:1 ,2:4, 3:6},'d':{1:2, 2:3, 3:5},
- 'e':{1:11, 2:13, 3:15},'v':{1:12, 2:14, 3:16}}
-# PID:name dictionary for particles
-particle_names = {1:'u', 2:'d', 3:'s', 4:'c', 5:'b', 6:'t',
- 11:'e', 12:'ve', 13:'mu', 14:'vmu', 15:'ta', 16:'vta',
- 21:'a', 22:'g', 23:'Z', 24:'W', 25:'H'}
-# ID:name dictionary for SLHA inputs
-input_names = {1:'aEWM1', 2:'Gf', 3:'aS', 4:'MZ',
- 5:'MB', 6:'MT', 7:'MTAU', 25:'MH'}
-# ID:PID dictionary for SLHA inputs that are particle masses
-input_to_PID = {4:23, 5:5, 6:6, 7:15, 25:25}
-PID_to_input = {v:k for k,v in input_to_PID.items()}
-# PID:value dictionary for default particle masses when undefined
-default_masses = {1:0.0048, 2:0.0023, 3:0.095, 4:1.42, 5:4.7, 6:173.,
- 11:0.000511, 12:0., 13:0.105658367, 14:0., 15:1.7768, 16:0.,
- 23:9.118800e+01, 24:7.982400e+01, 25:125.}
-# ID:value dictionary for default SHLA inputs when undefined
-default_inputs = {1: 1.325070e+02, 2: 1.166390e-05, 3: 1.180000e-01,
- 4: default_masses[23], 5: default_masses[5],
- 6: default_masses[6], 7: default_masses[15],
- 25:default_masses[25], 9:default_masses[24] }
-
-# CKM matrix
-# Wolfenstein parameterisation (PDG best fit)
-lam, A, rho, eta = 0.22535, 0.811, 0.131, 0.345
-# CKM mixing angles and CP phase
-s12, s23 = lam, A*lam**2
-s13cd, s13sd = A*lam**3*rho, A*lam**3*eta
-s13 = sqrt(s13sd**2+s13cd**2)
-c12, c23, c13 = map(lambda x: sqrt(1.-x**2), (s12, s23, s13 ))
-# real and imaginary parts
-VCKM = {1:{1:c12*c13, 2:s12*c13, 3:s13cd },
- 2:{1:-s12*c23-c12*s23*s13cd, 2:c12*c23-s12*s23*s13cd, 3:s23*c13},
- 3:{1:s12*s23-c12*c23*s13cd, 2:-c12*s23-s12*c23*s13cd, 3:c23*c13}}
-IMVCKM = {1:{1:0., 2:0., 3:-s13sd},
- 2:{1:-c12*s23*s13sd, 2:-s12*s23*s13sd, 3:0. },
- 3:{1:-c12*c23*s13sd, 2:-s12*c23*s13sd, 3:0. }}
-VCKMele = {(1,1):'ud',(1,2):'us',(1,3):'ub',(2,1):'cd',
- (2,2):'cs',(2,3):'cb',(3,1):'td',(3,2):'ts',(3,3):'tb'}
################################################################################
class RosettaError(Exception):
'''Fancy error name.'''
pass
################################################################################
if __name__=='__main__':
pass
diff --git a/Rosetta/internal/__init__.py b/Rosetta/internal/constants.py
similarity index 92%
copy from Rosetta/internal/__init__.py
copy to Rosetta/internal/constants.py
index 6ff7032..6112b8d 100644
--- a/Rosetta/internal/__init__.py
+++ b/Rosetta/internal/constants.py
@@ -1,50 +1,53 @@
from math import sqrt
################################################################################
+__doc__ = '''
+Some useful lookup dictionaries and default values for particle masses, SM
+inputs and the CKM matrix.
+'''
# PDG ID dictionary
PID = {'u':{1:1 ,2:4, 3:6},'d':{1:2, 2:3, 3:5},
'e':{1:11, 2:13, 3:15},'v':{1:12, 2:14, 3:16}}
+
# PID:name dictionary for particles
particle_names = {1:'u', 2:'d', 3:'s', 4:'c', 5:'b', 6:'t',
11:'e', 12:'ve', 13:'mu', 14:'vmu', 15:'ta', 16:'vta',
21:'a', 22:'g', 23:'Z', 24:'W', 25:'H'}
+
# ID:name dictionary for SLHA inputs
input_names = {1:'aEWM1', 2:'Gf', 3:'aS', 4:'MZ',
5:'MB', 6:'MT', 7:'MTAU', 25:'MH'}
+
# ID:PID dictionary for SLHA inputs that are particle masses
input_to_PID = {4:23, 5:5, 6:6, 7:15, 25:25}
PID_to_input = {v:k for k,v in input_to_PID.items()}
+
# PID:value dictionary for default particle masses when undefined
default_masses = {1:0.0048, 2:0.0023, 3:0.095, 4:1.42, 5:4.7, 6:173.,
11:0.000511, 12:0., 13:0.105658367, 14:0., 15:1.7768, 16:0.,
23:9.118800e+01, 24:7.982400e+01, 25:125.}
+
# ID:value dictionary for default SHLA inputs when undefined
default_inputs = {1: 1.325070e+02, 2: 1.166390e-05, 3: 1.180000e-01,
4: default_masses[23], 5: default_masses[5],
6: default_masses[6], 7: default_masses[15],
25:default_masses[25], 9:default_masses[24] }
# CKM matrix
# Wolfenstein parameterisation (PDG best fit)
lam, A, rho, eta = 0.22535, 0.811, 0.131, 0.345
# CKM mixing angles and CP phase
s12, s23 = lam, A*lam**2
s13cd, s13sd = A*lam**3*rho, A*lam**3*eta
s13 = sqrt(s13sd**2+s13cd**2)
c12, c23, c13 = map(lambda x: sqrt(1.-x**2), (s12, s23, s13 ))
# real and imaginary parts
VCKM = {1:{1:c12*c13, 2:s12*c13, 3:s13cd },
2:{1:-s12*c23-c12*s23*s13cd, 2:c12*c23-s12*s23*s13cd, 3:s23*c13},
3:{1:s12*s23-c12*c23*s13cd, 2:-c12*s23-s12*c23*s13cd, 3:c23*c13}}
IMVCKM = {1:{1:0., 2:0., 3:-s13sd},
2:{1:-c12*s23*s13sd, 2:-s12*s23*s13sd, 3:0. },
3:{1:-c12*c23*s13sd, 2:-s12*c23*s13sd, 3:0. }}
VCKMele = {(1,1):'ud',(1,2):'us',(1,3):'ub',(2,1):'cd',
(2,2):'cs',(2,3):'cb',(3,1):'td',(3,2):'ts',(3,3):'tb'}
################################################################################
-class RosettaError(Exception):
- '''Fancy error name.'''
- pass
-################################################################################
-if __name__=='__main__':
- pass
-
+
\ No newline at end of file
diff --git a/Rosetta/internal/decorators.py b/Rosetta/internal/decorators.py
index 5fae502..a556814 100644
--- a/Rosetta/internal/decorators.py
+++ b/Rosetta/internal/decorators.py
@@ -1,18 +1,28 @@
+__doc__ = '''
+The translation decorator used to tag a translation function in a Rosetta basis
+implementation.
+'''
################################################################################
-# decorator for a decorator to allow it to take an argument
def parametrised(dec):
+ '''
+ Decorator for a decorator allowing it to take arguments
+ '''
def layer(*args, **kwargs):
def repl(f):
return dec(f, *args, **kwargs)
return repl
return layer
# translation decorator to identify translation functions and their target
@parametrised
def translation(func, target):
+ '''
+ translation decorator for Rosetta to identify translation functions and
+ their target basis
+ '''
def labelled(*args,**kwargs):
# print func.__dict__
return func(*args,**kwargs)
labelled._target = target
return labelled
################################################################################
diff --git a/Rosetta/internal/eHDECAY.py b/Rosetta/internal/eHDECAY.py
index 4d358fc..c910341 100644
--- a/Rosetta/internal/eHDECAY.py
+++ b/Rosetta/internal/eHDECAY.py
@@ -1,285 +1,285 @@
import __init__ as Rosetta
from math import sqrt
from .. import SILHBasis as SB
import os
from tempfile import mkdtemp
import subprocess as sub
from collections import namedtuple
from settings import eHDECAY_dir
################################################################################
# required info
masses = {25,3,4,5,6,15,13,24,23} # H, c, b, t, tau, mu, Z, W masses
inputs = {1,2,3} # aEWM1, Gf, aS@MZ
# eHDECAY executable
executable = '{}/run'.format(eHDECAY_dir)
################################################################################
__doc__='''
Interface with eHDECAY program (arXiv:1403.3381) to calculate new Higgs width
and branching ratio to SM particles. Relies on the eixtence of a translation of
ones basis to the SILH basis. The minimal set of SILH coefficients that should
be translated to are:
'sH','sT','sW','sB','sHW','sHB','sBB','sGG',
'se33Re','se22Re','su33Re','su22Re','sd33Re','sd22Re'
The values of the SILH coefficients are then
rescaled from the convention of the LHXSWG draft to match those of eHDECAY.
Required SM inputs are:
'MH','aSMZ','MC','MB','MT','MTAU','MMU','aEWM1','Gf','MZ', 'MW'.
The widths of the W and Z are also looked for in the Decay blocks of the silh
instance and are set to default PDG values if not found.
The absolute path to the local eHDECAY directory containing the executable
should be specified in config.txt as:
eHDECAY_dir /PATH/TO/eHDECAY
'''
################################################################################
def run(basis, electroweak=True):
'''
Run local installation of eHDECAY and return the resulting Higgs width
and branching fraction information.
Keyword arguments:
electroweak - switch for electroweak corrections, IELW
'''
if not os.path.exists(executable):
print ('Rosetta: could not find eHDECAY executable in {}'.format(
eHDECAY_dir
))
print ('########## eHDECAY ##########\n'
'If you use this feature, please cite:\n'
'R. Contino et al., Comput.Phys.Commun. 185 (2014) 3412\n'
'A. Djouadi, J. Kalinowski, M. Spira et al., '
'Comput.Phys.Commun. 108 (1998) 56 \n')
# ensure required masses & inputs
basis.check_masses(masses, message='eHDECAY interface')
basis.check_sminputs(inputs, message='eHDECAY interface')
# translate to silh instance
thesilh = basis.translate(target='silh',verbose=False)
- thesilh.set_flavour(thesilh.flavour, 'general')
+ thesilh.set_flavor(thesilh.flavor, 'general')
inp = from_silh(thesilh, ew = electroweak)
# create temporary directory
tmpdir = mkdtemp(prefix='eHDECAY_',dir = os.getcwd())
# write out eHDECAY input file
with open('{}/ehdecay.in'.format(tmpdir),'w') as infile:
infile.write( create_input(inp) )
process = sub.Popen(executable, stdout = sub.PIPE,
stderr = sub.PIPE, cwd = tmpdir)
out, err = process.communicate()
if err:
raise RuntimeError('eHDECAY error: {}'.format(err))
print 'eHDECAY output:\n{}'.format(out)
# read BRs and total width
result = read_output(tmpdir)
# clean up temp directory
sub.call(['cp','{}/ehdecay.in'.format(tmpdir),'.'])
sub.call(['rm','-r',tmpdir])
return result
def from_silh(silh_instance, ew=True):
'''
Rescaling of the relevant SILH parameters in the LHCXSWG convention to that
of the eHDECAY publication (arXiv:1403.3381).
'''
si = silh_instance
s2w, c2w, ee2, gw2, gp2, MZ, vev, gs2 = silh_instance.calculate_inputs()
g=sqrt(gw2)
SILH = {}
mass = {k:nonzero_mass(si,k) for k in masses}
# EW option
SILH['IELW'] = 1 if ew else 0
# SM inputs & masses
SILH['MH'] = mass[25]
SILH['aSMZ'] = si.inputs[3]
SILH['MC'] = mass[4]
SILH['MB'] = mass[5]
SILH['MT'] = mass[6]
SILH['MTAU'] = mass[15]
SILH['MMU'] = mass[13]
SILH['aEWM1'] = si.inputs[1]
SILH['Gf'] = si.inputs[2]
SILH['MZ'] = mass[23]
SILH['MW'] = mass[24]
if si.card.has_decay(23):
SILH['GAMZ'] = si.card.decays[23].total
else:
SILH['GAMZ'] = 2.4952 # default
if si.card.has_decay(24):
SILH['GAMW'] = si.card.decays[24].total
else:
SILH['GAMW'] = 2.085 # default
# gauge & Higgs coefficients
SILH['CHbar'] = 2.*si['sH']
SILH['CTbar'] = 2.*si['sT']
SILH['CWbar'] = gw2/4.*si['sW']
SILH['CBbar'] = gw2/4.*si['sB']
SILH['CHWbar'] = gw2/4.*si['sHW']
SILH['CHBbar'] = gw2/4.*si['sHB']
SILH['Cgambar'] = gw2/16.*si['sBB']
SILH['Cgbar'] = gw2/16.*si['sGG']
SILH['Ctaubar'] = sqrt(2.)*si['SBxe'][3,3].real
SILH['Cmubar'] = sqrt(2.)*si['SBxe'][2,2].real
SILH['Ctbar'] = sqrt(2.)*si['SBxu'][3,3].real
SILH['Ccbar'] = sqrt(2.)*si['SBxu'][2,2].real
SILH['Cbbar'] = sqrt(2.)*si['SBxd'][3,3].real
SILH['Csbar'] = sqrt(2.)*si['SBxd'][2,2].real
return SILH
def nonzero_mass(basis,PID):
'''
Force non-zero values for all relevant masses. eHDECAY gives nan otherwise.
'''
themass = basis.mass[PID]
if themass == 0.:
name = Rosetta.particle_names[PID]
default = Rosetta.default_masses[PID]
print ('eHDECAY requires nonzero mass for {}. '.format(name) +
'Default value of {} GeV used.'.format(default))
return default
else:
return themass
def read_output(workdir):
'''
Read eHDECAY output files br.eff1 and br.eff2
'''
with open('{}/br.eff1'.format(workdir),'r') as br1, open('{}/br.eff2'.format(workdir),'r') as br2:
br1_dat, br2_dat = br1.readlines()[3], br2.readlines()[3]
MH, BB, TATA, MUMU, SS, CC, TT = tuple(map(float, br1_dat.split()))
__, GG, AA, ZA, WW, ZZ, WTOT = tuple(map(float, br2_dat.split()))
BR = { (5,5):BB, (15,15):TATA, (13,13):MUMU,
(3,3):SS, (4,4):CC, (6,6):TT , (21,21):GG,
(22,22):AA, (23,22):ZA, (24,24):WW, (23,23):ZZ,
'WTOT':WTOT}
return BR
def create_input(inp):
'''
Write out input file for eHDECAY.
'''
return \
'''SLHAIN = 0
SLHAOUT = 0
COUPVAR = 1
HIGGS = 0
SM4 = 0
FERMPHOB = 0
MODEL = 1
TGBET = 1.D0
MABEG = {MH}
MAEND = 1000.D0
NMA = 1
ALS(MZ) = {aSMZ}
MSBAR(2) = 0.100D0
MC = {MC}
MB = {MB}
MT = {MT}
MTAU = {MTAU}
MMUON = {MMU}
1/ALPHA = {aEWM1}
GF = {Gf}
GAMW = {GAMW}
GAMZ = {GAMZ}
MZ = {MZ}
MW = {MW}
VUS = 0.2253D0
VCB = 0.0410D0
VUB/VCB = 0.0846D0
********************* 4TH GENERATION *************************************
SCENARIO FOR ELW. CORRECTIONS TO H -> GG (EVERYTHING IN GEV):
GG_ELW = 1: MTP = 500 MBP = 450 MNUP = 375 MEP = 450
GG_ELW = 2: MBP = MNUP = MEP = 600 MTP = MBP+50*(1+LOG(M_H/115)/5)
GG_ELW = 1
MTP = 500.D0
MBP = 450.D0
MNUP = 375.D0
MEP = 450.D0
**************************************************************************
SUSYSCALE= 1000.D0
MU = 1000.D0
M2 = 1000.D0
MGLUINO = 1000.D0
MSL1 = 1000.D0
MER1 = 1000.D0
MQL1 = 1000.D0
MUR1 = 1000.D0
MDR1 = 1000.D0
MSL = 1000.D0
MER = 1000.D0
MSQ = 1000.D0
MUR = 1000.D0
MDR = 1000.D0
AL = 1000.D0
AU = 1000.D0
AD = 1000.D0
NNLO (M) = 0
ON-SHELL = 0
ON-SH-WZ = 0
IPOLE = 0
OFF-SUSY = 0
INDIDEC = 0
NF-GG = 5
IGOLD = 0
MPLANCK = 2.4D18
MGOLD = 1.D-13
************** LAGRANGIAN 0 - chiral 1 - SILH 2 - MCHM4/5 **************
LAGPARAM = 1
**** Turn off (0) or on (1) the elw corrections for LAGPARAM = 1 or 2 ****
IELW = {IELW}
******************* VARIATION OF HIGGS COUPLINGS *************************
CW = 0D0
CZ = 0D0
Ctau = 0D0
Cmu = 0D0
Ct = 0D0
Cb = 0D0
Cc = 0D0
Cs = 0D0
Cgaga = 0D0
Cgg = 0D0
CZga = 0D0
CWW = 0D0
CZZ = 0D0
CWdW = 0D0
CZdZ = 0D0
**************************** SILH Lagrangian *****************************
CHbar = {CHbar}
CTbar = {CTbar}
Ctaubar = {Ctaubar}
Cmubar = {Cmubar}
Ctbar = {Ctbar}
Cbbar = {Cbbar}
Ccbar = {Ccbar}
Csbar = {Csbar}
CWbar = {CWbar}
CBbar = {CBbar}
CHWbar = {CHWbar}
CHBbar = {CHBbar}
Cgambar = {Cgambar}
Cgbar = {Cgbar}
******** MCHM4 (fermrepr=1), MCHM5 (fermrepr=2) parametrisation ********
fermrepr = 2
xi = 0.D0
'''.format(**inp)
diff --git a/Rosetta/internal/machinery.py b/Rosetta/internal/machinery.py
index 634f214..7b0e80a 100644
--- a/Rosetta/internal/machinery.py
+++ b/Rosetta/internal/machinery.py
@@ -1,86 +1,96 @@
# Imports all modules in the Rosetta base directory
from Rosetta import __all__ as basisnames
from Rosetta import *
import inspect
################################################################################
+__doc__ = '''
+Rosetta's machinery for generating the translation paths available for the set
+of Basis implementations contained in its root directory. relate() builds
+the possible translation paths from one basis to all of the others by looking
+for translation functions belonging to the class tagged by the translation
+decorator. The relationships dictionary contains all of this information and
+is used in the translate() function of the class Basis.
+'''
+
def relate(mydict):
- '''build the relations tree for implemented.py'''
+ '''recursively build the relations tree for implemented.py'''
def traverse(base, state={}, chain=[]):
subset = [(x,f) for x,f in mydict[base].iteritems()
if (x!=k and x not in state)]
for ele in subset:
state[ele[0]] = chain
for ele in subset:
subchain = chain[:]
subchain.append(ele)
return traverse(ele[0], chain=subchain, state=state)
return state
relations = {}
for k in mydict.keys():
relations[k] = traverse(k, state={}, chain=[])
for k,v in mydict.iteritems():
for kk,vv in v.iteritems():
relations[k][kk] = [(kk,vv)]
return relations
def get_path(start,end,rels):
'''traverse relations tree and return the path needed'''
avail = rels[start]
try:
path = avail[end]
except KeyError:
return []
step = path[-1][0]
while step!=end:
intermediate = rels[step][end]
path += intermediate
step = intermediate[-1][0]
return path
+
################################################################################
# Constructs the relationship dictionary from all .py files in
modules = {b:v for b,v in globals().iteritems() if b in basisnames}
bases = {}
for bname, module in modules.iteritems():
try:
bclass = module.__dict__[bname]
if not inspect.isclass(bclass):
raise KeyError
bases[bclass.name] = bclass
except KeyError:
print ('Warning: Rosetta did not find a class named ' +
'{0} in {0}.py. File ignored.'.format(bname) )
translations = {}
for bas,inst in bases.iteritems():
functions = [i for i in inst.__dict__.values() if hasattr(i,'_target')]
tmap = {f._target:f for f in functions}
translations[bas] = tmap
relationships = relate(translations)
################################################################################
if __name__=='__main__':
pass
# mydict = {
# 'A':{'B':'A.Bfunc','C':'A.Cfunc'},
# 'B':{'C':'B.Cfunc','D':'B.Dfunc'},
# 'C':{'A':'C.Afunc','D':'C.Dfunc','B':'CBfunc'},
# 'D':{'A':'D.Afunc'},
# 'E':{'D':'E.Dfunc'},
# 'F':{'C':'F.Cfunc','E':'F.Efunc'},
# 'G':{'E':'G.Efunc'}
# }
#
# relations = relate(mydict)
# for k,v in relations.items():
# print k,v
# print '\n\n'
# print get_path('A','C',relations)
\ No newline at end of file
diff --git a/Rosetta/internal/matrices.py b/Rosetta/internal/matrices.py
index df01431..ab18d88 100644
--- a/Rosetta/internal/matrices.py
+++ b/Rosetta/internal/matrices.py
@@ -1,351 +1,358 @@
import SLHA
from itertools import product
from collections import OrderedDict
import re
+
+__doc__ = '''
+Module implementing special cases of 2D matrices inheriting from the
+SLHA.Matrix structures in SLHA.py e.g. Hermitian, Symmetric etc. Some basic
+operations are also defined here for matrix multiplication, addition
+subtraction and element-wise assignment.
+'''
################################################################################
# Special 2D Matrices
class TwoDMatrix(SLHA.NamedMatrix):
mask = tuple()
def __strkeymap__(self, key):
if not re.match(r'.*\dx\d$', key):
err = ('{}.__strkeymap__: Key {} '.format(self.__class__, key)
+'does not have format NAMEixj.')
raise KeyError(err)
intkeys = self.__parse__(key)
i, j = self.__keymap__(intkeys)
try:
return self._names[(j,i)]
except KeyError:
return key[:-3]+'{}x{}'.format(j,i)
def __keymap__(self, key):
'''
Returns the modified key according to the properties of the matrix i.e.
if it is symmetric etc.
'''
return key
def __valuemap__(self, key, value):
return value
def __init__(self, *args):
if not args:
matrix = SLHA.NamedMatrix()
elif len(args)>1:
raise TypeError('TwoDMatrix constructor takes at most one argument.')
else:
matrix=args[0]
self.name = matrix.name
self.fmt = matrix.fmt
self.keytype = matrix.keytype
self.cast = matrix.cast
self._data = OrderedDict(matrix._data.items())
self.preamble = matrix.preamble
self._names = {k:v for k,v in matrix._names.items()}
self._numbers = SLHA.CaseInsensitiveDict({k:v for k,v in
matrix._numbers.items()})
for k,v in self.items()[::-1]:
self[k] = v
def __setitem__(self, key, value):
intkey = self.get_number(key) if type(key) is str else key
if intkey in self.mask:
if type(key) is str:
newkey = self.__strkeymap__(key)
else:
newkey = self.__keymap__(intkey)
else:
newkey = key
super(TwoDMatrix, self).__setitem__(newkey,
self.__valuemap__(intkey, value))
def __getitem__(self, key):
intkey = self.get_number(key) if type(key) is str else key
if intkey in self.mask:
if type(key) is str:
newkey = self.__strkeymap__(key)
else:
newkey = self.__keymap__(key)
else:
newkey = key
value = super(TwoDMatrix, self).__getitem__(newkey)
return self.__valuemap__(intkey, value)
def __contains__(self, key):
try:
intkey = self.get_number(key) if type(key) is str else key
if intkey in self.mask:
if type(key) is str:
newkey = self.__strkeymap__(key)
else:
newkey = self.__keymap__(key)
else:
newkey = key
return super(TwoDMatrix, self).__contains__(newkey)
except (ValueError, KeyError) as e:
return False
def __delitem__(self, key):
key = self.get_number(key) if type(key) is str else key
return super(TwoDMatrix, self).__delitem__(key)
class CTwoDMatrix(TwoDMatrix, SLHA.CNamedMatrix):
mask = tuple()
def __strkeymap__(self, key):
if not re.match(r'.*\dx\d$', key):
err = ('{}.__strkeymap__: Key {} '.format(self.__class__, key)
+'does not have format NAMEixj.')
raise KeyError(err)
if key in self._re or key in self._im:
part = self._part(key)
else:
part = self
intkeys = part.__parse__(key)
i, j = self.__keymap__(intkeys)
try:
return part._names[(j,i)]
except KeyError:
return key[:-3]+'{}x{}'.format(i,j)
def __keymap__(self, key):
return key
def __setreal__(self, real):
return TwoDMatrix(real)
def __setimag__(self, imag):
return TwoDMatrix(imag)
def __init__(self, *args):
if not args:
matrix = SLHA.CNamedMatrix()
elif len(args)>1:
raise TypeError('CTwoDMatrix constructor takes at most one argument.')
else:
matrix=args[0]
self._re = self.__setreal__(matrix._re)
self._im = self.__setimag__(matrix._im)
super(CTwoDMatrix, self).__init__(matrix)
def __setitem__(self, key, value):
return super(CTwoDMatrix, self).__setitem__(key, value)
def __getitem__(self, key):
if type(key) is str and (key in self._re or key in self._im):
return self._part(key).__getitem__(key)
else:
return super(CTwoDMatrix, self).__getitem__(key)
def __delitem__(self, key):
return super(CTwoDMatrix, self).__delitem__(key)
def __contains__(self, key):
return super(CTwoDMatrix, self).__contains__(key)
class SymmetricMatrix(TwoDMatrix):
mask = ((2,1),(3,1),(3,2))
def __keymap__(self, key):
key = super(SymmetricMatrix, self).__keymap__(key)
i, j = key
return (i, j) if i <= j else (j, i)
def __valuemap__(self, key, value):
return value
class AntisymmetricMatrix(TwoDMatrix):
mask = ((2,1),(3,1),(3,2))
def __keymap__(self, key):
key = super(AntisymmetricMatrix, self).__keymap__(key)
i, j = key
return (i, j) if i <= j else (j, i)
def __valuemap__(self, key, value):
i, j = key
return 0. if i==j else -value if i > j else value
class CSymmetricMatrix(SymmetricMatrix, CTwoDMatrix):
def __setreal__(self, real):
return SymmetricMatrix(real)
def __setimag__(self, imag):
return SymmetricMatrix(imag)
class CAntisymmetricMatrix(CTwoDMatrix, AntisymmetricMatrix):
def __setreal__(self, real):
return AntisymmetricMatrix(real)
def __setimag__(self, imag):
return AntisymmetricMatrix(imag)
class HermitianMatrix(CTwoDMatrix):
mask = ((2,1),(3,1),(3,2))
def __setreal__(self, real):
return SymmetricMatrix(real)
def __setimag__(self, imag):
return AntisymmetricMatrix(imag)
def __keymap__(self, key):
i, j = key
return (i, j) if i <= j else (j, i)
def __valuemap__(self, key, value):
i, j = key
if i==j:
return complex(value.real, 0.)
elif i > j:
return value.conjugate()
else:
return value
################################################################################
# Matrix operations
def matrix_mult(A, B, assign=None):
'''
Matrix operation A.B:
Perform matrix multiplication of A and B. If the assign option is given, the
result will be assigned to its elements, otherwise, an object of identical
type to A will be returned.
Objects should be SLHA.Matrix instances or be indexable as [i,j,..] and
posess the dimension() method which returns a tuple of array dimensions.
Assumes indexing from 1.
'''
dimA, dimB = A.dimension(), B.dimension()
# matrix shape checks
if dimA[-1] != dimB[0]:
err = ("Size of last dimension of array A doesn't "
"match the first of array B ")
raise IndexError(err)
if assign is None:
dimC = dimA[:-1] + dimB[1:]
if isinstance(A, SLHA.CBlock) or isinstance(B, SLHA.CBlock):
C = CTwoDMatrix()
else:
C = TwoDMatrix()
else:
C = assign
dimC = C.dimension()
if dimC != dimA[:-1] + dimB[1:]:
err = ("A.B -> C: Shape of array C doesn't match "
"the dimension of the result of A.B")
raise IndexError(err)
dim = dimA[-1]
for k in product(*[range(1,x+1) for x in dimC]):
C[k] = sum( [ A[k[:-1]+(x,)]*B[(x,)+k[1:]]
for x in range(1,dim+1) ] )
return C
def matrix_add(A, B, assign=None):
'''
Matrix operation A + B:
Perform element-wise matrix addition of A and B. If a third argument is
given, the result will be assigned to its elements, otherwise, an object of
identical type to A will be returned.
Objects should be SLHA.Matrix instances or be indexable as [i,j,..] and
posess the dimension() method which returns a tuple of array dimensions.
Assumes indexing from 1.
'''
dimA, dimB = A.dimension(), B.dimension()
# matrix shape checks
if dimA != dimB:
err = ("Dimension of array A doesn't "
"match that of array B")
raise IndexError(err)
if assign is None:
dimC = dimA[:-1] + dimB[1:]
if isinstance(A, SLHA.CBlock) or isinstance(B, SLHA.CBlock):
C = CTwoDMatrix()
else:
C = TwoDMatrix()
else:
C = assign
dimC = C.dimension()
if dimC != dimA:
err = ("A + B -> C: Shape of array C doesn't match "
"the dimension of the result of A + B")
raise IndexError(err)
dim = dimA[-1]
for k in product(*[range(1,x+1) for x in dimC]):
C[k] = A[k] + B[k]
return C
def matrix_sub(A, B, assign=None):
'''
Matrix operation A - B:
Perform element-wise matrix subtraction of A and B. If a third argument is
given, the result will be assigned to its elements, otherwise, an object of
identical type to A will be returned.
Objects should be SLHA.Matrix instances or be indexable as [i,j,..] and
posess the dimension() method which returns a tuple of array dimensions.
Assumes indexing from 1.
'''
dimA, dimB = A.dimension(), B.dimension()
# matrix shape checks
if dimA != dimB:
err = ("Dimension of array A doesn't "
"match that of array B")
raise IndexError(err)
if assign is None:
if isinstance(A, SLHA.CBlock) or isinstance(B, SLHA.CBlock):
C = CTwoDMatrix()
else:
C = TwoDMatrix()
else:
C = assign
dimC = C.dimension()
if dimC != dimA:
err = ("A - B -> C: Shape of array C doesn't match "
"the dimension of the result of A + B")
raise IndexError(err)
dim = dimA[-1]
for k in product(*[range(1,x+1) for x in dimC]):
C[k] = A[k] - B[k]
return C
def matrix_eq(A, B):
'''
Matrix operation B -> A:
Assigns the values of A element-wise to B.
Objects should be SLHA.Matrix instances or be indexable as [i,j,..] and
posess the dimension() method which returns a tuple of array dimensions.
Assumes indexing from 1.
'''
dimA, dimB = A.dimension(), B.dimension()
# matrix shape checks
if dimA != dimB:
err = ("Dimension of array A doesn't "
"match that of array B")
raise IndexError(err)
for k in product(*[range(1,x+1) for x in dimA]):
B[k] = A[k]
if __name__=='__main__':
pass
\ No newline at end of file
diff --git a/Rosetta/internal/query.py b/Rosetta/internal/query.py
index 9c8fd81..58a1fdd 100644
--- a/Rosetta/internal/query.py
+++ b/Rosetta/internal/query.py
@@ -1,33 +1,36 @@
import sys
-
+__doc__ = '''
+Yes/No question asking function taken from
+http://code.activestate.com/recipes/577058/
+'''
def query_yes_no(question, default="yes"):
"""Ask a yes/no question via raw_input() and return their answer.
"question" is a string that is presented to the user.
"default" is the presumed answer if the user just hits <Enter>.
It must be "yes" (the default), "no" or None (meaning
an answer is required of the user).
The "answer" return value is one of "yes" or "no".
"""
valid = {"yes":True, "y":True, "ye":True,
"no":False, "n":False}
if default == None:
prompt = " [y/n] "
elif default == "yes":
prompt = " [Y/n] "
elif default == "no":
prompt = " [y/N] "
else:
raise ValueError("invalid default answer: '%s'" % default)
while True:
sys.stdout.write(question + prompt)
choice = raw_input().lower()
if default is not None and choice == '':
return valid[default]
elif choice in valid:
return valid[choice]
else:
sys.stdout.write("Please respond with 'yes' or 'no' "\
"(or 'y' or 'n').\n")
\ No newline at end of file
diff --git a/Rosetta/internal/tester.py b/Rosetta/internal/tester.py
index 473e254..e318f47 100755
--- a/Rosetta/internal/tester.py
+++ b/Rosetta/internal/tester.py
@@ -1,273 +1,277 @@
#!/usr/bin/env python
from Rosetta import HiggsBasis as HB
from Rosetta import WarsawBasis as WB
from Rosetta import SILHBasis as SB
from Rosetta import MassBasis as MB
from Rosetta import TemplateBasis as TB
from Rosetta import MufBasis as MUF
import SLHA
import tempfile
import os
import sys
import re
import random
+__doc__'''
+Some tester functions to validate translations, generate sample input cards etc.
+'''
+
def compare_inputs(basis1, basis2, tolerance=1e-4):
wrong_inputs = []
for _input,value in basis1.inputs.items():
other_value = basis2.inputs[_input]
if abs(value - other_value) > tolerance*abs(value):
wrong_inputs.append([basis1.inputs._names[_input],
('{}:'.format(basis1.__class__.__name__),
other_value,
'{}:'.format(basis2.__class__.__name__),
value)
])
if wrong_inputs:
print 'Some inconsistent SM inputs detected:'
for w in wrong_inputs:
print w[0]
print w[1]
else:
print 'Inputs are OK!'
def compare_coeffs(basis1, basis2, tolerance=1e-4):
wrong_coeffs = []
for coeff in basis1.all_coeffs:
c1, c2 = basis1[coeff], basis2[coeff]
if abs(c1 - c2) > tolerance*abs(c1) and abs(c1 - c2) > 1e-15:
wrong_coeffs.append([coeff,
('{}:'.format(basis1.__class__.__name__), c1,
'{}:'.format(basis2.__class__.__name__), c2)
])
- for matrix in basis1.flavoured:
+ for matrix in basis1.flavored:
if matrix not in basis1.card: continue
b1, b2 = basis1.card.matrices[matrix], basis2.card.matrices[matrix]
for k,c1 in b1.iteritems():
c2 = b2[k]
coeff = b1._names[k]
if abs(c1 - c2) > tolerance*abs(c1) and abs(c1 - c2) > 1e-15:
wrong_coeffs.append([coeff,
('{}:'.format(basis1.__class__.__name__), c1,
'{}:'.format(basis2.__class__.__name__), c2)
])
if wrong_coeffs:
print 'Some inconsistent coefficients detected:'
for w in wrong_coeffs:
print w[0]
print w[1]
else:
print 'Coeffs are OK!'
def higgs_basis_check(MyBasis,param_card,tolerance=1e-4):
tmpdir = tempfile.mkdtemp(prefix = 'rosetta_temp_', dir=os.getcwd())
out_card = '{}/output_card.dat'.format(tmpdir)
myinstance = MyBasis(param_card=param_card,
output_basis='mass',silent=True)
myinstance.write_param_card(out_card)
HB_instance = HB.HiggsBasis(param_card=out_card, silent=True,
translate=False)
MB_instance = MB.MassBasis(param_card=out_card, silent=True)
compare_inputs(HB_instance, MB_instance, tolerance=tolerance)
compare_coeffs(HB_instance, MB_instance, tolerance=tolerance)
os.remove(out_card)
os.rmdir(tmpdir)
-def two_way_test(basis, card ,target, tolerance=1e-4, flavour='general'):
+def two_way_test(basis, card ,target, tolerance=1e-4, flavor='general'):
first = basis(param_card=card, silent=True, translate=False,
- flavour=flavour)
+ flavor=flavor)
intermediate = first.translate(target=target)
- intermediate.set_flavour(intermediate.flavour, 'general')
- intermediate.flavour='general'
+ intermediate.set_flavor(intermediate.flavor, 'general')
+ intermediate.flavor='general'
second = intermediate.translate(target=basis.name)
- first.set_flavour('general', flavour)
- second.set_flavour('general', flavour)
+ first.set_flavor('general', flavor)
+ second.set_flavor('general', flavor)
compare_coeffs(first , second, tolerance=tolerance)
compare_inputs(first , second, tolerance=tolerance)
-def circle_test(basis, card, tolerance=1e-4, reverse=False, flavour='general'):
+def circle_test(basis, card, tolerance=1e-4, reverse=False, flavor='general'):
others = [x for x in ('silh','warsaw', 'higgs') if x is not basis.name]
- one = basis(param_card=card, silent=True, translate=False, flavour=flavour)
+ one = basis(param_card=card, silent=True, translate=False, flavor=flavor)
if not reverse:
two = one.translate(target=others[0])
- two.set_flavour(two.flavour, 'general')
+ two.set_flavor(two.flavor, 'general')
three = two.translate(target=others[1])
else:
two = one.translate(target=others[1])
- two.set_flavour(two.flavour, 'general')
+ two.set_flavor(two.flavor, 'general')
three = two.translate(target=others[0])
- three.set_flavour(three.flavour, 'general')
+ three.set_flavor(three.flavor, 'general')
four = three.translate(target=basis.name)
- four.set_flavour('general',flavour)
+ four.set_flavor('general',flavor)
compare_inputs(one , four, tolerance=tolerance)
compare_coeffs(one , four, tolerance=tolerance)
def triangle_test(basis, card, target, tolerance=1e-4):
other = [x for x in ('silh','warsaw', 'higgs')
if x not in (basis.name,target)][0]
one = basis(param_card=card, silent=True, translate=False)
two = one.translate(target=target)
three = one.translate(target=other)
- three.set_flavour(three.flavour, 'general')
+ three.set_flavor(three.flavor, 'general')
four = three.translate(target=target)
- four.set_flavour(four.flavour, 'general')
+ four.set_flavor(four.flavor, 'general')
compare_coeffs(two , four, tolerance=tolerance)
def generate_coeffs(basis_class, val, rand=False):
myinstance = basis_class()
SLHA_card = myinstance.card
# print myinstance.independent
for name, blk in SLHA_card.blocks.iteritems():
for coeff in blk:
if blk.get_name(coeff) not in myinstance.independent:
del blk[coeff]
else:
blk[coeff]=val if not rand else random.uniform(-1.,1.)
for name, blk in SLHA_card.blocks.iteritems():
if len(blk)==0:
del SLHA_card.blocks[name]
for name, blk in myinstance.card.blocks.iteritems():
print blk
def generate_frdef(basis_class,filename):
myinstance = basis_class()
SLHA_card = myinstance.card
for name, blk in SLHA_card.blocks.iteritems():
for coeff in blk:
if blk.get_name(coeff) not in myinstance.independent:
del blk[coeff]
with open(filename,'w') as out:
for name, blk in myinstance.card.blocks.iteritems():
bname = blk.name
for index, value in blk.iteritems():
cname = blk.get_name(index)
is_sin = re.match(r'S[ude]\d\d',cname)
out.write('{} == {{ ParameterType -> External,\n'.format(cname))
out.write(' Value -> {},\n'.format(value))
if not is_sin:
out.write(' InteractionOrder -> {QNP, 1},\n')
# out.write(' TeX -> {},\n'.format(cname))
out.write(' BlockName -> {},\n'.format(bname))
out.write(' OrderBlock -> {},\n'.format(index))
out.write(' Description -> "{} coupling parameter"}},\n'.format(cname))
out.write('\n')
if is_sin:
cos = cname.replace('S','C')
out.write('{} == {{ ParameterType -> Internal,\n'.format(cos))
out.write(' Value -> Sqrt[1-{}^2],\n'.format(cname))
out.write(' Description -> "{} coupling parameter"}},\n'.format(cos))
out.write('\n')
for real in [blk.get_name(x) for x in blk.keys()
if blk.get_name(x)[-2:]=='Re' ]:
name = real.replace('Re','')
imag = real.replace('Re','Im')
out.write('{} == {{ ParameterType -> Internal,\n'.format(name))
out.write(' ComplexParamter -> True,\n')
out.write(' Value -> {{{}+I*{}}},\n'.format(real,imag))
out.write(' InteractionOrder -> {QNP, 1},\n')
out.write(' Description -> "{} coupling parameter"}},\n'.format(name))
out.write('\n')
print 'wrote ',filename
if __name__=='__main__':
pass
################################################################################
# # card writers
-# # for flav in ('general',):
+# for flav in ('general',):
# # for flav in ('universal',):
-# for flav in ('diagonal',):
+# # for flav in ('diagonal',):
# if flav =='general':
# tail = ''
# else:
# tail = '_%s' % flav
#
-# instance = TB.TemplateBasis(flavour=flav)
+# instance = TB.TemplateBasis(flavor=flav)
# instance.write_template_card('Cards/TemplateBasis{}.dat'.format(tail))
#
#
-# instance = HB.HiggsBasis(flavour=flav)
+# instance = HB.HiggsBasis(flavor=flav)
# instance.write_template_card('Cards/HiggsBasis{}.dat'.format(tail))
-# instance.write_template_card('HiggsBasis{}_rand.dat'.format(tail), value='random')
-# instance.write_template_card('HiggsBasis{}_1e-3.dat'.format(tail), value=0.001)
+# # instance.write_template_card('HiggsBasis{}_rand.dat'.format(tail), value='random')
+# # instance.write_template_card('HiggsBasis{}_1e-3.dat'.format(tail), value=0.001)
#
-# instance = WB.WarsawBasis(flavour=flav)
+# instance = WB.WarsawBasis(flavor=flav)
# instance.write_template_card('Cards/WarsawBasis{}.dat'.format(tail))
-# instance.write_template_card('WarsawBasis{}_rand.dat'.format(tail), value='random')
-# instance.write_template_card('WarsawBasis{}_1e-3.dat'.format(tail), value=0.001)
+# # instance.write_template_card('WarsawBasis{}_rand.dat'.format(tail), value='random')
+# # instance.write_template_card('WarsawBasis{}_1e-3.dat'.format(tail), value=0.001)
# #
-# instance = SB.SILHBasis(flavour=flav)
+# instance = SB.SILHBasis(flavor=flav)
# instance.write_template_card('Cards/SILHBasis{}.dat'.format(tail))
-# instance.write_template_card('SILHBasis{}_rand.dat'.format(tail), value='random')
-# instance.write_template_card('SILHBasis{}_1e-3.dat'.format(tail), value=0.001)
+# # instance.write_template_card('SILHBasis{}_rand.dat'.format(tail), value='random')
+# # instance.write_template_card('SILHBasis{}_1e-3.dat'.format(tail), value=0.001)
# # instance = MB.MassBasis()
# # instance.write_template_card('MassBasis.dat')
# # #
################################################################################
# translation testers
# two_way_test(WB.WarsawBasis,'WarsawBasis_rand.dat','higgs',tolerance=1e-14)
#
- # two_way_test(WB.WarsawBasis,'WarsawBasis_diagonal_rand.dat','higgs',tolerance=1e-10,flavour='diagonal')
- # two_way_test(WB.WarsawBasis,'WarsawBasis_universal_rand.dat','higgs',tolerance=1e-14,flavour='universal')
+ # two_way_test(WB.WarsawBasis,'WarsawBasis_diagonal_rand.dat','higgs',tolerance=1e-10,flavor='diagonal')
+ # two_way_test(WB.WarsawBasis,'WarsawBasis_universal_rand.dat','higgs',tolerance=1e-14,flavor='universal')
# two_way_test(HB.HiggsBasis,'HiggsBasis_rand.dat','warsaw')
#
# two_way_test(WB.WarsawBasis,'WarsawBasis_rand.dat','silh')
- # two_way_test(WB.WarsawBasis,'WarsawBasis_diagonal_rand.dat','silh',flavour='diagonal')
- # two_way_test(WB.WarsawBasis,'WarsawBasis_universal_rand.dat','silh',flavour='universal')
+ # two_way_test(WB.WarsawBasis,'WarsawBasis_diagonal_rand.dat','silh',flavor='diagonal')
+ # two_way_test(WB.WarsawBasis,'WarsawBasis_universal_rand.dat','silh',flavor='universal')
# two_way_test(SB.SILHBasis,'SILHBasis_rand.dat','warsaw')
#
- # two_way_test(SB.SILHBasis,'SILHBasis_rand.dat','higgs',flavour='general')
- # two_way_test(SB.SILHBasis,'SILHBasis_diagonal_rand.dat','higgs',flavour='diagonal')
- # two_way_test(SB.SILHBasis,'SILHBasis_universal_rand.dat','higgs',flavour='universal')
+ # two_way_test(SB.SILHBasis,'SILHBasis_rand.dat','higgs',flavor='general')
+ # two_way_test(SB.SILHBasis,'SILHBasis_diagonal_rand.dat','higgs',flavor='diagonal')
+ # two_way_test(SB.SILHBasis,'SILHBasis_universal_rand.dat','higgs',flavor='universal')
# two_way_test(HB.HiggsBasis,'HiggsBasis_rand.dat','silh')
# circle_test(HB.HiggsBasis,'HiggsBasis_rand.dat')
# circle_test(SB.SILHBasis,'SILHBasis_rand.dat')
# circle_test(WB.WarsawBasis,'WarsawBasis_rand.dat')
# circle_test(HB.HiggsBasis,'HiggsBasis_rand.dat',reverse=True)
# circle_test(SB.SILHBasis,'SILHBasis_rand.dat',reverse=True)
# circle_test(WB.WarsawBasis,'WarsawBasis_rand.dat',reverse=True)
# circle_test(HB.HiggsBasis,'Cards/param_card_HiggsBasis.dat',reverse=True)
# circle_test(SB.SILHBasis,'Cards/param_card_SILHBasis.dat')
# circle_test(SB.SILHBasis,'Cards/param_card_SILHBasis.dat',reverse=True)
# circle_test(WB.WarsawBasis,'Cards/param_card_WarsawBasis.dat')
# circle_test(WB.WarsawBasis,'Cards/param_card_WarsawBasis.dat',reverse=True)
# triangle_test(HB.HiggsBasis,'HiggsBasis_rand.dat','silh')
# triangle_test(HB.HiggsBasis,'HiggsBasis_rand.dat','warsaw')
# triangle_test(SB.SILHBasis,'Cards/param_card_SILHBasis.dat','higgs')
# triangle_test(SB.SILHBasis,'Cards/param_card_SILHBasis.dat','warsaw')
# triangle_test(WB.WarsawBasis,'Cards/param_card_WarsawBasis.dat','higgs')
# triangle_test(WB.WarsawBasis,'Cards/param_card_WarsawBasis.dat','silh')
################################################################################
# generate_coeffs(WB.WarsawBasis,0.,rand=True)
# generate_coeffs(SB.SILHBasis,0.,rand=True)
# generate_coeffs(HB.HiggsBasis,0.,rand=True)
# generate_coeffs(TB.TemplateBasis,0.,rand=True)
# generate_coeffs(MassBasis,1.,rand=True)
# generate_frdef(HiggsBasis,'HB_definitions.fr')
# generate_frdef(MB.MassBasis,'MB_definitions.fr')
# higgs_basis_check(SB.SILHBasis,'Cards/param_card_SILHBasis.dat',tolerance=1e-3)
# higgs_basis_check(SILHBasis,'../Cards/param_card_SILHBasis.dat')
# SILH_Warsaw_triangle('Cards/param_card_SILHBasis.dat', tolerance=1e-4)

File Metadata

Mime Type
text/x-diff
Expires
Wed, May 14, 12:05 PM (1 h, 32 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
5111602
Default Alt Text
(326 KB)

Event Timeline