From 3813b36b05244343a7cde8a9a4ec481060c772cf Mon Sep 17 00:00:00 2001 From: Jacky Kumar Date: Thu, 10 Feb 2022 00:29:53 +0100 Subject: [PATCH 1/9] adapt to left betafunctions --- .DS_Store | Bin 0 -> 6148 bytes wilson/.DS_Store | Bin 0 -> 6148 bytes wilson/classes.py | 67 +++++++----- wilson/run/smeft/__init__.py | 2 + wilson/run/smeft/classes.py | 82 ++++++++++++-- wilson/run/smeft/rgeleft.py | 21 ++++ wilson/util/leftutil.py | 205 +++++++++++++++++++++++++++++++++++ wilson/wcxf/.DS_Store | Bin 0 -> 6148 bytes 8 files changed, 342 insertions(+), 35 deletions(-) create mode 100644 .DS_Store create mode 100644 wilson/.DS_Store create mode 100644 wilson/run/smeft/rgeleft.py create mode 100644 wilson/util/leftutil.py create mode 100644 wilson/wcxf/.DS_Store diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..5c32bc83297d13710e6b04a5e21993d5dd04353f GIT binary patch literal 6148 zcmeHKPm9w)9Q{pOx9OI}9u&O@0k5^TENH$RxNFU-8j%zK&4n`Wj%L~OA1dqgcFvXBJU_K{r?qFtn|sOTD@ zWAYgZ%_*P=S7(cDDvSfhfxpcG@$DYaDRJ`gXL0t3*g~N%ga&YS1y*M>K+Z48;ZcMMdST zq_8lKfKpmwHR>RJEb+gW`1|0Bv8NORv#T`KVM((GUWj!rfpeu1;9ZL@6}VoO%(bK6 zym=HRX}9}>RjRdXdv&XBHLcg~JD$1eEL|pp+2WWw0F+lR!r158fG=Y|ky=+ZSPiQ&ZQWX}`n|S&_;B5}SH0eYe%tPM57+C4b@T51 zN5|9i=pyEy@cIabC0)jW#!L8&LSabn-9;SnSWJV^T;H??W(IVI>z>bayC7qa~(B#Ge<3Q1Ys=957 z{eS%D^M6rf?u-M*f&a<@RvWpa0fwaa)~&&bz1Bv0gCs)ma)nZYOmD}sAhzP$NHWl7 YivrNmm@7mL!u%1CHkiyfuu}(q1NW4+-v9sr literal 0 HcmV?d00001 diff --git a/wilson/.DS_Store b/wilson/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..69c3acbb5b489d6059a03a0d451fe57c9981caee GIT binary patch literal 6148 zcmeHK!EVz)5S>k2>NIMV0|+iimbgYGQ6-4PC8XuRl^{3(3U*_th3k!Cr>2S``3n34 zzkoRLCGant;LYwvik;+!5JfxD?pv?t&CEX4yImp@gW0%C)FL7mjnUadx54;5w>7Jo znFF9uF(S%ngx?`e*1YY6Rlq9nuPMOaZc}};5hb+x{a!wfc_ytU&_=X zG;2babV@$j8HF6D%%X=ISQqe|Qi^O6IeD+B=K5M;?IC`QEGd2=+6Iow^m(N|hsI!J zZ5WWj1ZCaDmK-^IaX__gEgb168}>r{(*{_sy#G^ zIx$wdMIlw&YK8__Tv-ARD~0MR*?v~CIjAV(EM>pi+cm!&>c6Kq6~FJ>{DM54n7^BE z!6c5-tkd}+YISGl+OE6nHr-dlGno%FKbxfkfBJ%-o=O=9%dsCki^6==x_&H^%#V_A zstD0Igv-n4Q8JeKK+ckJs<=b_!fm*XQS0V>-s`r#qx*}tH}7`u_1a#qbF^4A+#7f9 zK6o;E7oR8c14@Sp99qiu4KCp$1`e5JUks;7EEASx>A&>5;%JuRHm~?PZ249JtH7UE zfcFOvjj?aA(5SW!bm|HKbTF+9W4=o;$1~VBSZKr>n9x+9rV4Y#5Sos8&-nEX78*63 zgt>eOlUbM>icr}R-&5`+`WkI-6|f4F6{zdS7N7r*w%`BDB>Q9)unPQF3JB+9crw6} z%-OoOI6iAVwAW~C>{n=16m;e|Rs%kYZ=or}JC6szzQIBxW?=Ro0VRX&tO9>kf!`t% B=<)yn literal 0 HcmV?d00001 diff --git a/wilson/classes.py b/wilson/classes.py index 189830c..c818948 100644 --- a/wilson/classes.py +++ b/wilson/classes.py @@ -9,6 +9,7 @@ from wilson.run.smeft import SMEFT +from wilson.run.smeft import LEFT from wilson.run.wet import WETrunner from wilson import parameters import numpy as np @@ -90,12 +91,14 @@ class Wilson(ConfigurableClass): 'mb_matchingscale': 4.2, 'mc_matchingscale': 1.3, 'parameters': {}, + 'wet_method': 'adms' } # option schema: # Voluptuous schema defining allowed option values/types _option_schema = vol.Schema({ 'smeft_accuracy': vol.In(['integrate','leadinglog']), + 'wet_method': vol.In(['betafunctions','adms']), 'qed_order': vol.In([0,1]), 'qcd_order': vol.In([0,1]), 'smeft_matching_order': vol.In([0,1]), @@ -226,35 +229,45 @@ def match_run(self, scale, eft, basis, sectors='all'): self._set_cache('all', scale_ew, wc_ew.eft, wc_ew.basis, wc_ew) wet = WETrunner(wc_ew, **self._wetrun_opt()) elif self.wc.eft in ['WET', 'WET-4', 'WET-3']: - wet = WETrunner(self.wc.translate('JMS', parameters=self.parameters, sectors=translate_sectors), **self._wetrun_opt()) + wet_method = self.get_option('wet_method') + if wet_method == 'adms': + wet = WETrunner(self.wc.translate('JMS', parameters=self.parameters, sectors=translate_sectors), **self._wetrun_opt()) + if eft == wet.eft: # just run + wc_out = wet.run(scale, sectors=sectors).translate(basis, sectors=translate_sectors, parameters=self.parameters) + self._set_cache(sectors, scale, eft, basis, wc_out) + return wc_out + elif eft == 'WET-4' and wet.eft == 'WET': # match at mb + wc_mb = wet.run(mb, sectors=sectors).match('WET-4', 'JMS', parameters=self.matching_parameters) + wet4 = WETrunner(wc_mb, **self._wetrun_opt()) + wc_out = wet4.run(scale, sectors=sectors).translate(basis, sectors=translate_sectors, parameters=self.parameters) + self._set_cache(sectors, scale, 'WET-4', basis, wc_out) + return wc_out + elif eft == 'WET-3' and wet.eft == 'WET-4': # match at mc + wc_mc = wet.run(mc, sectors=sectors).match('WET-3', 'JMS', parameters=self.matching_parameters) + wet3 = WETrunner(wc_mc, **self._wetrun_opt()) + wc_out = wet3.run(scale, sectors=sectors).translate(basis, sectors=translate_sectors, parameters=self.parameters) + return wc_out + self._set_cache(sectors, scale, 'WET-3', basis, wc_out) + elif eft == 'WET-3' and wet.eft == 'WET': # match at mb and mc + wc_mb = wet.run(mb, sectors=sectors).match('WET-4', 'JMS', parameters=self.matching_parameters) + wet4 = WETrunner(wc_mb, **self._wetrun_opt()) + wc_mc = wet4.run(mc, sectors=sectors).match('WET-3', 'JMS', parameters=self.matching_parameters) + wet3 = WETrunner(wc_mc, **self._wetrun_opt()) + wc_out = wet3.run(scale, sectors=sectors).translate(basis, sectors=translate_sectors, parameters=self.parameters) + self._set_cache(sectors, scale, 'WET-3', basis, wc_out) + return wc_out + else: + raise ValueError(f"Running from {wet.eft} to {eft} not implemented") + + elif wet_method == 'betafunctions': + left = LEFT(self.wc.translate('JMS', parameters=self.parameters, sectors=translate_sectors)) + if eft == left.eft: # just run + wc_out = left.run(scale) + return wc_out + else: + raise ValueError(f"Running from {wet.eft} to {eft} not implemented") else: raise ValueError(f"Input EFT {self.wc.eft} unknown or not supported") - if eft == wet.eft: # just run - wc_out = wet.run(scale, sectors=sectors).translate(basis, sectors=translate_sectors, parameters=self.parameters) - self._set_cache(sectors, scale, eft, basis, wc_out) - return wc_out - elif eft == 'WET-4' and wet.eft == 'WET': # match at mb - wc_mb = wet.run(mb, sectors=sectors).match('WET-4', 'JMS', parameters=self.matching_parameters) - wet4 = WETrunner(wc_mb, **self._wetrun_opt()) - wc_out = wet4.run(scale, sectors=sectors).translate(basis, sectors=translate_sectors, parameters=self.parameters) - self._set_cache(sectors, scale, 'WET-4', basis, wc_out) - return wc_out - elif eft == 'WET-3' and wet.eft == 'WET-4': # match at mc - wc_mc = wet.run(mc, sectors=sectors).match('WET-3', 'JMS', parameters=self.matching_parameters) - wet3 = WETrunner(wc_mc, **self._wetrun_opt()) - wc_out = wet3.run(scale, sectors=sectors).translate(basis, sectors=translate_sectors, parameters=self.parameters) - return wc_out - self._set_cache(sectors, scale, 'WET-3', basis, wc_out) - elif eft == 'WET-3' and wet.eft == 'WET': # match at mb and mc - wc_mb = wet.run(mb, sectors=sectors).match('WET-4', 'JMS', parameters=self.matching_parameters) - wet4 = WETrunner(wc_mb, **self._wetrun_opt()) - wc_mc = wet4.run(mc, sectors=sectors).match('WET-3', 'JMS', parameters=self.matching_parameters) - wet3 = WETrunner(wc_mc, **self._wetrun_opt()) - wc_out = wet3.run(scale, sectors=sectors).translate(basis, sectors=translate_sectors, parameters=self.parameters) - self._set_cache(sectors, scale, 'WET-3', basis, wc_out) - return wc_out - else: - raise ValueError(f"Running from {wet.eft} to {eft} not implemented") def clear_cache(self): self._cache = {} diff --git a/wilson/run/smeft/__init__.py b/wilson/run/smeft/__init__.py index b2a6600..97bf3b7 100644 --- a/wilson/run/smeft/__init__.py +++ b/wilson/run/smeft/__init__.py @@ -6,7 +6,9 @@ """ from . import beta +from . import betaleft from . import definitions from . import classes from . import rge from .classes import SMEFT +from .classes import LEFT diff --git a/wilson/run/smeft/classes.py b/wilson/run/smeft/classes.py index 9abc5dc..8e26827 100644 --- a/wilson/run/smeft/classes.py +++ b/wilson/run/smeft/classes.py @@ -9,10 +9,25 @@ import wilson from wilson.util import smeftutil from wilson import wcxf +from . import rgeleft +from wilson.util import leftutil -class SMEFT: - """Class representing a parameter point in the Standard Model Effective +class EFT: + """Class representing a parameter point in the Effective + Field Theory and allowing the evolution of the Wilson Coefficients. + + Methods: + - __init__: Initialize, given a wcxf.WC instance + """ + def __init__(self, wc): + """Initialize the EFT instance. + Parameters: 'wc' : Wilson coefficients as `wcxf.WC` instance. + """ + self.wc=wc + +class LEFT(EFT): + """Class representing a parameter point in the Low Energy Effective Field Theory and allowing the evolution of the Wilson Coefficients. Methods: @@ -22,15 +37,66 @@ class SMEFT: """ def __init__(self, wc, get_smpar=True): - """Initialize the SMEFT instance. + super().__init__(wc) + self.eft= wc.eft + self.wc = wc + self.scale_in = wc.scale + self.C_in = None - Parameters: + C = wilson.util.leftutil.wcxf2arrays_symmetrized(wc.dict) - - `wc`: the Wilson coefficients as `wcxf.WC` instance. + for k, s in leftutil.C_keys_shape.items(): + if k not in C and k not in leftutil.SM_keys: + if s == 1: + C[k] = 0 + else: + C[k] = np.zeros(s) + if self.C_in is None: + self.C_in = C + else: + self.C_in.update(C) + def _leftevolve_leadinglog(self, scale_out): + """Compute the leading logarithmic approximation to the solution + of the LEFT RGEs from the initial scale to `scale_out`. + Returns a dictionary with parameters and Wilson coefficients. """ - self.wc = wc - self.scale_in = None - self.C_in = None + return rgeleft.left_evolve_leadinglog(C_in=self.C_in, + scale_in=self.scale_in, + scale_out=scale_out) + + def _to_wcxf(self, C_out, scale_out): + """Return the Wilson coefficients `C_out` as a wcxf.WC instance. + """ + C = C_out + d = wilson.util.leftutil.arrays2wcxf(C) + d = wcxf.WC.dict2values(d) + wc = wcxf.WC('WET', 'JMS', scale_out, d) + return wc + + def run(self, scale): + """Return the Wilson coefficients (as wcxf.WC instance) evolved to the + scale `scale`. + Parameters: + - `scale`: scale in GeV + """ + C_out = self._leftevolve_leadinglog(scale) + return self._to_wcxf(C_out, scale) + + +class SMEFT(EFT): + """Class representing a parameter point in the Standard Model Effective + Field Theory and allowing the evolution of the Wilson Coefficients. + + Methods: + + - __init__: Initialize, given a wcxf.WC instance + - run: solve the RGE and return a wcxf.WC instance + """ + def __init__(self, wc, get_smpar=True): + super().__init__(wc) + self.scale_in=None + self.C_in= None + if wc is not None: self._set_initial_wcxf(wc, get_smpar=get_smpar) diff --git a/wilson/run/smeft/rgeleft.py b/wilson/run/smeft/rgeleft.py new file mode 100644 index 0000000..eb0f3bc --- /dev/null +++ b/wilson/run/smeft/rgeleft.py @@ -0,0 +1,21 @@ +"""Solving the LEFT RGEs.""" +from . import betaleft +from copy import deepcopy +from math import pi, log +from scipy.integrate import solve_ivp +import numpy as np +# +# +def left_evolve_leadinglog(C_in, scale_in, scale_out): + """Solve the LEFT RGEs in the leading log approximation. + Input C_in and output C_out are dictionaries of arrays.""" + C_out = deepcopy(C_in) + + b = betaleft.betaLEFT(C_out) + for k, C in C_out.items(): + C_out[k] = C + b[k] / (16 * pi**2) * log(scale_out / scale_in) + return C_out + + + + diff --git a/wilson/util/leftutil.py b/wilson/util/leftutil.py new file mode 100644 index 0000000..58f44c4 --- /dev/null +++ b/wilson/util/leftutil.py @@ -0,0 +1,205 @@ +import numpy as np + +SM_keys = ['e', 'g', 'Md', 'Mu', 'Me', 'Mnu'] + +WC_keys_0f= ['G', 'Gtilde'] + +WC_keys_2f = ['egamma', 'ugamma', 'dgamma', 'nugamma', 'uG', 'dG', 'delta'] + +WC_keys_4f= ['S1udRR', 'S1udduRR', 'S8udRR', 'S8udduRR', 'SedRL', 'SedRR', 'SeuRL', 'SeuRR', \ +'SnueduRL', 'SnueduRR', 'TedRR', 'TeuRR', 'TnueduRR', 'V1udduLR', 'V8udduLR', 'VnueduLL', 'VnueduLR', \ +'SuddLL', 'SduuLL', 'SduuLR', 'SduuRL', 'SdudRL', 'SduuRR', 'VuuRR', 'VddRR', 'VuuLL', 'VddLL', 'S1ddRR',\ + 'S1uuRR', 'S8uuRR', 'SeeRR', 'S8ddRR', 'VnueLL', 'VnuuLL', 'VnudLL', 'VeuLL', 'VedLL', 'V1udLL', 'V8udLL',\ + 'VeuRR', 'VedRR', 'V1udRR', 'V8udRR', 'VnueLR', 'VeeLR', 'VnuuLR', 'VnudLR', 'VeuLR', 'VedLR', 'VueLR',\ + 'VdeLR', 'V1uuLR', 'V8uuLR', 'V1udLR', 'V8udLR', 'V1duLR', 'V8duLR', 'V1ddLR', 'V8ddLR', 'VeeLL', 'VeeRR',\ + 'VnunuLL', 'SuudLR', 'SuudRL', 'SdduRL', 'SnudLL', 'SnudLR', 'SnueLL', 'SnueLR', 'SnuuLL', 'SnuuLR', \ +'SnunuLL', 'TnueLL', 'TnuuLL', 'TnudLL', 'SnueduLL', 'TnueduLL', 'SnueduLR', 'VnueduRL', 'VnueduRR',\ + 'SdddLL', 'SuddLR', 'SdduLR', 'SdddLR', 'SdddRL', 'SuddRR', 'SdddRR'] + +C_keys = SM_keys + WC_keys_0f + WC_keys_2f + WC_keys_4f +WC_keys = WC_keys_0f + WC_keys_2f + WC_keys_4f + +#FIXME remove third flavour +C_keys_shape = { + 'delta': (3,3), + 'G': 1, + 'Gtilde': 1, + 'egamma': (3, 3), + 'uG': (3, 3), + 'dG': (3, 3), + 'ugamma': (3, 3), + 'dgamma': (3, 3), + 'S1udRR': (3, 3, 3, 3), + 'S1udduRR': (3, 3, 3, 3), + 'S8udRR': (3, 3, 3, 3), + 'S8udduRR': (3, 3, 3, 3), + 'SedRL': (3, 3, 3, 3), + 'SedRR': (3, 3, 3, 3), + 'SeuRL': (3, 3, 3, 3), + 'SeuRR': (3, 3, 3, 3), + 'SnueduRL': (3, 3, 3, 3), + 'SnueduRR': (3, 3, 3, 3), + 'TedRR': (3, 3, 3, 3), + 'TeuRR': (3, 3, 3, 3), + 'TnueduRR': (3, 3, 3, 3), + 'V1udduLR': (3, 3, 3, 3), + 'V8udduLR': (3, 3, 3, 3), + 'VnueduLL': (3, 3, 3, 3), + 'VnueduLR': (3, 3, 3, 3), + 'SuddLL': (3, 3, 3, 3), + 'SduuLL': (3, 3, 3, 3), + 'SduuLR': (3, 3, 3, 3), + 'SduuRL': (3, 3, 3, 3), + 'SdudRL': (3, 3, 3, 3), + 'SduuRR': (3, 3, 3, 3), + 'VuuRR': (3, 3, 3, 3), + 'VddRR': (3, 3, 3, 3), + 'VuuLL': (3, 3, 3, 3), + 'VddLL': (3, 3, 3, 3), + 'S1ddRR': (3, 3, 3, 3), + 'S1uuRR': (3, 3, 3, 3), + 'S8uuRR': (3, 3, 3, 3), + 'SeeRR': (3, 3, 3, 3), + 'S8ddRR': (3, 3, 3, 3), + 'VnueLL': (3, 3, 3, 3), + 'VnuuLL': (3, 3, 3, 3), + 'VnudLL': (3, 3, 3, 3), + 'VeuLL': (3, 3, 3, 3), + 'VedLL': (3, 3, 3, 3), + 'V1udLL': (3, 3, 3, 3), + 'V8udLL': (3, 3, 3, 3), + 'VeuRR': (3, 3, 3, 3), + 'VedRR': (3, 3, 3, 3), + 'V1udRR': (3, 3, 3, 3), + 'V8udRR': (3, 3, 3, 3), + 'VnueLR': (3, 3, 3, 3), + 'VeeLR': (3, 3, 3, 3), + 'VnuuLR': (3, 3, 3, 3), + 'VnudLR': (3, 3, 3, 3), + 'VeuLR': (3, 3, 3, 3), + 'VedLR': (3, 3, 3, 3), + 'VueLR': (3, 3, 3, 3), + 'VdeLR': (3, 3, 3, 3), + 'V1uuLR': (3, 3, 3, 3), + 'V8uuLR': (3, 3, 3, 3), + 'V1udLR': (3, 3, 3, 3), + 'V8udLR': (3, 3, 3, 3), + 'V1duLR': (3, 3, 3, 3), + 'V8duLR': (3, 3, 3, 3), + 'V1ddLR': (3, 3, 3, 3), + 'V8ddLR': (3, 3, 3, 3), + 'VeeLL': (3, 3, 3, 3), + 'VeeRR': (3, 3, 3, 3), + 'VnunuLL': (3, 3, 3, 3), + 'SuudLR': (3, 3, 3, 3), + 'SuudRL': (3, 3, 3, 3), + 'SdduRL': (3, 3, 3, 3), +} + +C_keys_shape_missing = { + 'e': 1, + 'g': 1, + 'Md': (3,3), + 'Me': (3,3), + 'Mu': (3,3), + 'Mnu': (3,3), + 'nugamma': (3,3), + 'SnudLL': (3,3,3,3), + 'SnudLR': (3,3,3,3), + 'SnueLL': (3,3,3,3), + 'SnueLR': (3,3,3,3), + 'SnuuLL': (3,3,3,3), + 'SnuuLR': (3,3,3,3), + 'SnunuLL': (3,3,3,3), + 'TnueLL': (3,3,3,3), + 'TnuuLL': (3,3,3,3), + 'TnudLL': (3,3,3,3), + 'SnueduLL': (3,3,3,3), + 'TnueduLL': (3,3,3,3), + 'SnueduLR': (3,3,3,3), + 'VnueduRL': (3,3,3,3), + 'VnueduRR': (3,3,3,3), + 'SdddLL': (3,3,3,3), + 'SuddLR': (3,3,3,3), + 'SdduLR': (3,3,3,3), + 'SdddLR': (3,3,3,3), + 'SdddRL': (3,3,3,3), + 'SuddRR': (3,3,3,3), + 'SdddRR': (3,3,3,3), +} + +C_keys_shape.update(C_keys_shape_missing) + + +def wcxf2arrays(d): + """Convert a dictionary with a Wilson coefficient + name followed by underscore and numeric indices as keys and numbers as + values to a dictionary with Wilson coefficient names as keys and + numbers or numpy arrays as values. This is needed for the parsing + of input in WCxf format.""" + C = {} + for k, v in d.items(): + name = k.split('_')[0] + s = C_keys_shape[name] + if s == 1: + C[k] = v + else: + ind = k.split('_')[-1] + if name not in C: + C[name] = np.zeros(s, dtype=complex) + C[name][tuple([int(i) - 1 for i in ind])] = v + return C + +def add_missing(C): + """Add arrays with zeros for missing Wilson coefficient keys""" + C_out = C.copy() + for k in (set(C_keys) - set(C.keys())): # FIXME + s = C_keys_shape[k] + if s == 1: + C_out[k] = 0 + else: + C_out[k] = np.zeros(C_keys_shape[k]) + return C_out + +def wcxf2arrays_symmetrized(d): + """Convert a LEFT dictionary with a Wilson coefficient + name followed by underscore and numeric indices as keys and numbers as + values to a dictionary with Wilson coefficient names as keys and + numbers or numpy arrays as values. + + + In contrast to `wcxf2arrays`, here the numpy arrays fulfill the same + symmetry relations as the operators (i.e. they contain redundant entries) + and they do not contain undefined indices. + + Zero arrays are added for missing coefficients.""" + C = wcxf2arrays(d) +# C = symmetrize_nonred(C) + C = add_missing(C) + return C + + +def arrays2wcxf(C): + """Convert a dictionary with Wilson coefficient names as keys and + numbers or numpy arrays as values to a dictionary with a Wilson coefficient + name followed by underscore and numeric indices as keys and numbers as + values. This is needed for the output in WCxf format.""" + d = {} + for k, v in C.items(): + if np.shape(v) == () or np.shape(v) == (1,): + d[k] = v + else: + ind = np.indices(v.shape).reshape(v.ndim, v.size).T + for i in ind: + name = k + '_' + ''.join([str(int(j) + 1) for j in i]) + d[name] = v[tuple(i)] + return d + + + + + + + + + diff --git a/wilson/wcxf/.DS_Store b/wilson/wcxf/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..337dc3366310a5fd2b57c948ef491dd007e58ac7 GIT binary patch literal 6148 zcmeHKO>fgc5S>lZ)@i7e0|+iimbgYGQ6-4fOGwLsD?xAo6zs-O3)hZfr=f}>yy9&utO8bn|4jk@b{q1|h7?o&`@MJ)B`1EA`0#*NnkB#HdXvgbb!gW0fo^C*ckFN}kU5W-Oamsc;sc$Ccg$uu6N z!X4-ar|#5;&D-;Nx6^VD9xht$ywiEmZMog{!D3N&Zr!_o_;mO_I*XH!A_*yMgJOFI zFX0mkxuu^ECUKO+?@-H(UC0-SEFz3-pC$RLNASzbzb%|_t?##zFZZ9|^`1la3ASj? zOY*C`B~Fb-m{CSv@inQ>B|nGG#7_snYQMiq{(CZhDhI{iP*}GL37s#6fa95KChN6! z?Zjb}XXVFBG1q|JVr)L3N(zetdFGAWOlMH=1DNZ0tVo{MDDZ*}qp>b!)&xq%SRuzk zhBvmNW`!dr9|d^4x|v{g8dvYaGOYquforM&?+-2#W6$7Hqih|>`!QX^VmN>hQFs>~HbX*%j%b67yW&o&r_ttC0joe! zfvSFN^7;RG^Zma_vQJh4tH8BVK-G>1$9*ixoUJR1KjKfrbk@&Et; literal 0 HcmV?d00001 From b7e21609a9516007bc40b26649a16e2b8d1b241c Mon Sep 17 00:00:00 2001 From: Jacky Kumar Date: Sat, 12 Feb 2022 00:10:20 +0100 Subject: [PATCH 2/9] Adapting to new changes from PR#92 --- wilson/run/smeft/__init__.py | 1 - wilson/run/smeft/classes.py | 2 +- wilson/run/smeft/rgeleft.py | 4 ++-- 3 files changed, 3 insertions(+), 4 deletions(-) diff --git a/wilson/run/smeft/__init__.py b/wilson/run/smeft/__init__.py index 97bf3b7..c66dbeb 100644 --- a/wilson/run/smeft/__init__.py +++ b/wilson/run/smeft/__init__.py @@ -6,7 +6,6 @@ """ from . import beta -from . import betaleft from . import definitions from . import classes from . import rge diff --git a/wilson/run/smeft/classes.py b/wilson/run/smeft/classes.py index 8e26827..14e0cef 100644 --- a/wilson/run/smeft/classes.py +++ b/wilson/run/smeft/classes.py @@ -15,7 +15,7 @@ class EFT: """Class representing a parameter point in the Effective - Field Theory and allowing the evolution of the Wilson Coefficients. + Field Theory. Methods: - __init__: Initialize, given a wcxf.WC instance diff --git a/wilson/run/smeft/rgeleft.py b/wilson/run/smeft/rgeleft.py index eb0f3bc..b84dd25 100644 --- a/wilson/run/smeft/rgeleft.py +++ b/wilson/run/smeft/rgeleft.py @@ -1,5 +1,5 @@ """Solving the LEFT RGEs.""" -from . import betaleft +from wilson.run.wet import beta from copy import deepcopy from math import pi, log from scipy.integrate import solve_ivp @@ -11,7 +11,7 @@ def left_evolve_leadinglog(C_in, scale_in, scale_out): Input C_in and output C_out are dictionaries of arrays.""" C_out = deepcopy(C_in) - b = betaleft.betaLEFT(C_out) + b = beta.beta(C_out) for k, C in C_out.items(): C_out[k] = C + b[k] / (16 * pi**2) * log(scale_out / scale_in) return C_out From 953a63e7eeecc331be18ec10c30cf058a80b82dd Mon Sep 17 00:00:00 2001 From: Jacky Kumar Date: Sat, 12 Feb 2022 09:48:56 +0100 Subject: [PATCH 3/9] adapt to PR#92 --- wilson/run/smeft/classes.py | 56 ++++++++++++++++++++++++++++++++----- wilson/run/wet/beta.py | 10 +++---- 2 files changed, 54 insertions(+), 12 deletions(-) diff --git a/wilson/run/smeft/classes.py b/wilson/run/smeft/classes.py index 14e0cef..fcfe9c4 100644 --- a/wilson/run/smeft/classes.py +++ b/wilson/run/smeft/classes.py @@ -1,5 +1,9 @@ -"""Defines the SMEFT class that provides the main API to smeft.""" +"""Defines the EFT class that provides the main API to smeft and wet.""" +from numpy import pi, sqrt +import numpy as np +from wilson.util import qcd +from wilson.parameters import p as default_parameters from . import rge from . import definitions from . import smpar @@ -10,7 +14,7 @@ from wilson.util import smeftutil from wilson import wcxf from . import rgeleft -from wilson.util import leftutil +from wilson.util import wetutil class EFT: @@ -36,25 +40,36 @@ class LEFT(EFT): - run: solve the RGE and return a wcxf.WC instance """ - def __init__(self, wc, get_smpar=True): + def __init__(self, wc, dim4_left=True): super().__init__(wc) self.eft= wc.eft self.wc = wc self.scale_in = wc.scale self.C_in = None - C = wilson.util.leftutil.wcxf2arrays_symmetrized(wc.dict) + if self.eft == 'WET': + self.f = 5 + elif self.eft == 'WET-4': + self.f = 4 + elif self.eft == 'WET-3': + self.f = 3 - for k, s in leftutil.C_keys_shape.items(): - if k not in C and k not in leftutil.SM_keys: + C = wilson.util.wetutil.wcxf2arrays_symmetrized(wc.dict) + for k, s in wetutil.C_keys_shape.items(): + if k not in C and k not in wetutil.dim4_keys: if s == 1: C[k] = 0 else: C[k] = np.zeros(s) + if self.C_in is None: self.C_in = C else: self.C_in.update(C) + + if dim4_left: + self.C_in.update(self._get_sm_left(self.scale_in, self.f)) + def _leftevolve_leadinglog(self, scale_out): """Compute the leading logarithmic approximation to the solution of the LEFT RGEs from the initial scale to `scale_out`. @@ -64,11 +79,38 @@ def _leftevolve_leadinglog(self, scale_out): scale_in=self.scale_in, scale_out=scale_out) + def _get_sm_left(self, scale, f, loop=3): + + C_in_SM={} + parameters= default_parameters.copy() + + m_d = qcd.m_s(parameters['m_d'], scale, self.f, parameters['alpha_s'], loop=loop) + m_s = qcd.m_s(parameters['m_s'], scale, self.f, parameters['alpha_s'], loop=loop) + m_b = qcd.m_b(parameters['m_b'], scale, self.f, parameters['alpha_s'], loop=loop) + + m_u = qcd.m_s(parameters['m_u'], scale, self.f, parameters['alpha_s'], loop=loop) + m_c = qcd.m_c(parameters['m_c'], scale, self.f, parameters['alpha_s'], loop=loop) + + # running ignored for alpha_e and lepton mass + m_e = parameters['m_e'] + m_mu = parameters['m_mu'] + m_tau = parameters['m_tau'] + + C_in_SM['gs'] = sqrt(4*pi*qcd.alpha_s(scale, self.f, parameters['alpha_s'], loop=loop)) + C_in_SM['e'] = sqrt(4*pi*parameters['alpha_e']) + + C_in_SM['Me'] = np.array([[m_e,0,0],[0,m_mu,0],[0,0,m_tau]]) + C_in_SM['Md'] = np.array([[m_d,0,0],[0,m_s,0],[0,0,m_b]]) + C_in_SM['Mu'] = np.array([[m_u,0],[0,m_c]]) + + C_in_SM['Mnu'] = np.array([[0,0,0],[0,0,0],[0,0,0]]) # update + return C_in_SM + def _to_wcxf(self, C_out, scale_out): """Return the Wilson coefficients `C_out` as a wcxf.WC instance. """ C = C_out - d = wilson.util.leftutil.arrays2wcxf(C) + d = wilson.util.wetutil.arrays2wcxf(C) d = wcxf.WC.dict2values(d) wc = wcxf.WC('WET', 'JMS', scale_out, d) return wc diff --git a/wilson/run/wet/beta.py b/wilson/run/wet/beta.py index 9ad06d4..aa8597b 100644 --- a/wilson/run/wet/beta.py +++ b/wilson/run/wet/beta.py @@ -51,14 +51,14 @@ def beta(C, n_gen=3): # Dimension 3: Masses + + Beta["Mnu"] = zeros_2F#24*my_einsum("vwrs,wv",C["SnunuLL"],C["Mnu"].conj().T @ C["Mnu"] @ C["Mnu"].conj().T) + 16*my_einsum("wrvs,wv",C["VnunuLL"],C["Mnu"] @ C["Mnu"].conj().T @ C["Mnu"]) + 8*my_einsum("rsvw,wv",C["SnueLL"],C["Me"].conj().T @ C["Me"] @ C["Me"].conj().T) + 8*my_einsum("rsvw,wv",C["SnueLR"],C["Me"] @ C["Me"].conj().T @ C["Me"]) + 8*Nc*my_einsum("rsvw,wv",C["SnuuLL"],C["Mu"].conj().T @ C["Mu"] @ C["Mu"].conj().T) + 8*Nc*my_einsum("rsvw,wv",C["SnuuLR"],C["Mu"] @ C["Mu"].conj().T @ C["Mu"]) + 8*Nc*my_einsum("rsvw,wv",C["SnudLL"],C["Md"].conj().T @ C["Md"] @ C["Md"].conj().T) + 8*Nc*my_einsum("rsvw,wv",C["SnudLR"],C["Md"] @ C["Md"].conj().T @ C["Md"]) - 48*my_einsum("rw,uv,wv,us",C["nugamma"],C["nugamma"].conj(),C["Mnu"].conj().T @ C["Mnu"],C["Mnu"]) + 16*my_einsum("rw,vw,vs",C["nugamma"],C["nugamma"].conj(),C["Mnu"] @ C["Mnu"].conj().T @ C["Mnu"]) - 48*my_einsum("wu,vs,wv,ru",C["nugamma"].conj(),C["nugamma"],C["Mnu"] @ C["Mnu"].conj().T,C["Mnu"]) + 16*my_einsum("wv,ws,rv",C["nugamma"].conj(),C["nugamma"],C["Mnu"] @ C["Mnu"].conj().T @ C["Mnu"]) - 96*my_einsum("rv,ws,vw",C["nugamma"],C["nugamma"],C["Mnu"].conj().T @ C["Mnu"] @ C["Mnu"].conj().T) - Beta["Mnu"] = 24*my_einsum("vwrs,wv",C["SnunuLL"],C["Mnu"].conj().T @ C["Mnu"] @ C["Mnu"].conj().T) + 16*my_einsum("wrvs,wv",C["VnunuLL"],C["Mnu"] @ C["Mnu"].conj().T @ C["Mnu"]) + 8*my_einsum("rsvw,wv",C["SnueLL"],C["Me"].conj().T @ C["Me"] @ C["Me"].conj().T) + 8*my_einsum("rsvw,wv",C["SnueLR"],C["Me"] @ C["Me"].conj().T @ C["Me"]) + 8*Nc*my_einsum("rsvw,wv",C["SnuuLL"],C["Mu"].conj().T @ C["Mu"] @ C["Mu"].conj().T) + 8*Nc*my_einsum("rsvw,wv",C["SnuuLR"],C["Mu"] @ C["Mu"].conj().T @ C["Mu"]) + 8*Nc*my_einsum("rsvw,wv",C["SnudLL"],C["Md"].conj().T @ C["Md"] @ C["Md"].conj().T) + 8*Nc*my_einsum("rsvw,wv",C["SnudLR"],C["Md"] @ C["Md"].conj().T @ C["Md"]) - 48*my_einsum("rw,uv,wv,us",C["nugamma"],C["nugamma"].conj(),C["Mnu"].conj().T @ C["Mnu"],C["Mnu"]) + 16*my_einsum("rw,vw,vs",C["nugamma"],C["nugamma"].conj(),C["Mnu"] @ C["Mnu"].conj().T @ C["Mnu"]) - 48*my_einsum("wu,vs,wv,ru",C["nugamma"].conj(),C["nugamma"],C["Mnu"] @ C["Mnu"].conj().T,C["Mnu"]) + 16*my_einsum("wv,ws,rv",C["nugamma"].conj(),C["nugamma"],C["Mnu"] @ C["Mnu"].conj().T @ C["Mnu"]) - 96*my_einsum("rv,ws,vw",C["nugamma"],C["nugamma"],C["Mnu"].conj().T @ C["Mnu"] @ C["Mnu"].conj().T) + Beta["Me"] = - 6*qe**2*e**2*my_einsum("rs",C["Me"]) #+ 12*qe*e*my_einsum("vr,vs",C["egamma"].conj(),C["Me"].conj().T @ C["Me"]) + 12*qe*e*my_einsum("sv,rv",C["egamma"].conj(),C["Me"] @ C["Me"].conj().T) + 4*my_einsum("vwrs,wv",C["SnueLL"],C["Mnu"].conj().T @ C["Mnu"] @ C["Mnu"].conj().T) + 4*my_einsum("wvsr,wv",C["SnueLR"].conj(),C["Mnu"] @ C["Mnu"].conj().T @ C["Mnu"]) + (8*my_einsum("srwv,wv",C["SeeRR"].conj(),C["Me"].conj().T @ C["Me"] @ C["Me"].conj().T) - 4*my_einsum("wrsv,wv",C["SeeRR"].conj(),C["Me"].conj().T @ C["Me"] @ C["Me"].conj().T)) - 8*my_einsum("vsrw,wv",C["VeeLR"],C["Me"] @ C["Me"].conj().T @ C["Me"]) + 4*Nc*my_einsum("srwv,wv",C["SeuRR"].conj(),C["Mu"].conj().T @ C["Mu"] @ C["Mu"].conj().T) + 4*Nc*my_einsum("srwv,wv",C["SeuRL"].conj(),C["Mu"] @ C["Mu"].conj().T @ C["Mu"]) + 4*Nc*my_einsum("srwv,wv",C["SedRR"].conj(),C["Md"].conj().T @ C["Md"] @ C["Md"].conj().T) + 4*Nc*my_einsum("srwv,wv",C["SedRL"].conj(),C["Md"] @ C["Md"].conj().T @ C["Md"]) - 12*my_einsum("wr,vu,wv,us",C["egamma"].conj(),C["egamma"],C["Me"].conj().T @ C["Me"],C["Me"]) + 4*my_einsum("wr,wv,vs",C["egamma"].conj(),C["egamma"],C["Me"] @ C["Me"].conj().T @ C["Me"]) - 12*my_einsum("uw,sv,wv,ru",C["egamma"],C["egamma"].conj(),C["Me"] @ C["Me"].conj().T,C["Me"]) + 4*my_einsum("vw,sw,rv",C["egamma"],C["egamma"].conj(),C["Me"] @ C["Me"].conj().T @ C["Me"]) - 24*my_einsum("vr,sw,vw",C["egamma"].conj(),C["egamma"].conj(),C["Me"].conj().T @ C["Me"] @ C["Me"].conj().T) - Beta["Me"] = - 6*qe**2*e**2*my_einsum("rs",C["Me"]) + 12*qe*e*my_einsum("vr,vs",C["egamma"].conj(),C["Me"].conj().T @ C["Me"]) + 12*qe*e*my_einsum("sv,rv",C["egamma"].conj(),C["Me"] @ C["Me"].conj().T) + 4*my_einsum("vwrs,wv",C["SnueLL"],C["Mnu"].conj().T @ C["Mnu"] @ C["Mnu"].conj().T) + 4*my_einsum("wvsr,wv",C["SnueLR"].conj(),C["Mnu"] @ C["Mnu"].conj().T @ C["Mnu"]) + (8*my_einsum("srwv,wv",C["SeeRR"].conj(),C["Me"].conj().T @ C["Me"] @ C["Me"].conj().T) - 4*my_einsum("wrsv,wv",C["SeeRR"].conj(),C["Me"].conj().T @ C["Me"] @ C["Me"].conj().T)) - 8*my_einsum("vsrw,wv",C["VeeLR"],C["Me"] @ C["Me"].conj().T @ C["Me"]) + 4*Nc*my_einsum("srwv,wv",C["SeuRR"].conj(),C["Mu"].conj().T @ C["Mu"] @ C["Mu"].conj().T) + 4*Nc*my_einsum("srwv,wv",C["SeuRL"].conj(),C["Mu"] @ C["Mu"].conj().T @ C["Mu"]) + 4*Nc*my_einsum("srwv,wv",C["SedRR"].conj(),C["Md"].conj().T @ C["Md"] @ C["Md"].conj().T) + 4*Nc*my_einsum("srwv,wv",C["SedRL"].conj(),C["Md"] @ C["Md"].conj().T @ C["Md"]) - 12*my_einsum("wr,vu,wv,us",C["egamma"].conj(),C["egamma"],C["Me"].conj().T @ C["Me"],C["Me"]) + 4*my_einsum("wr,wv,vs",C["egamma"].conj(),C["egamma"],C["Me"] @ C["Me"].conj().T @ C["Me"]) - 12*my_einsum("uw,sv,wv,ru",C["egamma"],C["egamma"].conj(),C["Me"] @ C["Me"].conj().T,C["Me"]) + 4*my_einsum("vw,sw,rv",C["egamma"],C["egamma"].conj(),C["Me"] @ C["Me"].conj().T @ C["Me"]) - 24*my_einsum("vr,sw,vw",C["egamma"].conj(),C["egamma"].conj(),C["Me"].conj().T @ C["Me"] @ C["Me"].conj().T) + Beta["Mu"] = - 6*(CF*g**2 + qu**2*e**2)*my_einsum("rs",C["Mu"]) #+ 12*(CF*g*my_einsum("vr,vs",C["uG"].conj(),C["Mu"].conj().T @ C["Mu"]) + qu*e*my_einsum("vr,vs",C["ugamma"].conj(),C["Mu"].conj().T @ C["Mu"])) + 12*(CF*g*my_einsum("sv,rv",C["uG"].conj(),C["Mu"] @ C["Mu"].conj().T) + qu*e*my_einsum("sv,rv",C["ugamma"].conj(),C["Mu"] @ C["Mu"].conj().T)) + 4*my_einsum("vwrs,wv",C["SnuuLL"],C["Mnu"].conj().T @ C["Mnu"] @ C["Mnu"].conj().T) + 4*my_einsum("wvsr,wv",C["SnuuLR"].conj(),C["Mnu"] @ C["Mnu"].conj().T @ C["Mnu"]) + 4*my_einsum("wvsr,wv",C["SeuRR"].conj(),C["Me"].conj().T @ C["Me"] @ C["Me"].conj().T) + 4*my_einsum("vwrs,wv",C["SeuRL"],C["Me"] @ C["Me"].conj().T @ C["Me"]) + (8*Nc*my_einsum("srwv,wv",C["S1uuRR"].conj(),C["Mu"].conj().T @ C["Mu"] @ C["Mu"].conj().T) - 4*my_einsum("svwr,wv",C["S1uuRR"].conj(),C["Mu"].conj().T @ C["Mu"] @ C["Mu"].conj().T) - 4*CF*my_einsum("svwr,wv",C["S8uuRR"].conj(),C["Mu"].conj().T @ C["Mu"] @ C["Mu"].conj().T)) - 8*(my_einsum("vsrw,wv",C["V1uuLR"],C["Mu"] @ C["Mu"].conj().T @ C["Mu"]) + CF*my_einsum("vsrw,wv",C["V8uuLR"],C["Mu"] @ C["Mu"].conj().T @ C["Mu"])) + (4*Nc*my_einsum("srwv,wv",C["S1udRR"].conj(),C["Md"].conj().T @ C["Md"] @ C["Md"].conj().T) - 2*my_einsum("svwr,wv",C["S1udduRR"].conj(),C["Md"].conj().T @ C["Md"] @ C["Md"].conj().T) - 2*CF*my_einsum("svwr,wv",C["S8udduRR"].conj(),C["Md"].conj().T @ C["Md"] @ C["Md"].conj().T)) - 8*(my_einsum("svwr,wv",C["V1udduLR"].conj(),C["Md"] @ C["Md"].conj().T @ C["Md"]) + CF*my_einsum("svwr,wv",C["V8udduLR"].conj(),C["Md"] @ C["Md"].conj().T @ C["Md"])) - 12*my_einsum("wr,vu,wv,us",C["ugamma"].conj(),C["ugamma"],C["Mu"].conj().T @ C["Mu"],C["Mu"]) + 4*my_einsum("wr,wv,vs",C["ugamma"].conj(),C["ugamma"],C["Mu"] @ C["Mu"].conj().T @ C["Mu"]) - 12*my_einsum("uw,sv,wv,ru",C["ugamma"],C["ugamma"].conj(),C["Mu"] @ C["Mu"].conj().T,C["Mu"]) + 4*my_einsum("vw,sw,rv",C["ugamma"],C["ugamma"].conj(),C["Mu"] @ C["Mu"].conj().T @ C["Mu"]) - 12*CF*my_einsum("wr,vu,wv,us",C["uG"].conj(),C["uG"],C["Mu"].conj().T @ C["Mu"],C["Mu"]) + 4*CF*my_einsum("wr,wv,vs",C["uG"].conj(),C["uG"],C["Mu"] @ C["Mu"].conj().T @ C["Mu"]) - 12*CF*my_einsum("uw,sv,wv,ru",C["uG"],C["uG"].conj(),C["Mu"] @ C["Mu"].conj().T,C["Mu"]) + 4*CF*my_einsum("vw,sw,rv",C["uG"],C["uG"].conj(),C["Mu"] @ C["Mu"].conj().T @ C["Mu"]) - 24*my_einsum("vr,sw,vw",C["ugamma"].conj(),C["ugamma"].conj(),C["Mu"].conj().T @ C["Mu"] @ C["Mu"].conj().T) - 24*CF*my_einsum("vr,sw,vw",C["uG"].conj(),C["uG"].conj(),C["Mu"].conj().T @ C["Mu"] @ C["Mu"].conj().T) - Beta["Mu"] = - 6*(CF*g**2 + qu**2*e**2)*my_einsum("rs",C["Mu"]) + 12*(CF*g*my_einsum("vr,vs",C["uG"].conj(),C["Mu"].conj().T @ C["Mu"]) + qu*e*my_einsum("vr,vs",C["ugamma"].conj(),C["Mu"].conj().T @ C["Mu"])) + 12*(CF*g*my_einsum("sv,rv",C["uG"].conj(),C["Mu"] @ C["Mu"].conj().T) + qu*e*my_einsum("sv,rv",C["ugamma"].conj(),C["Mu"] @ C["Mu"].conj().T)) + 4*my_einsum("vwrs,wv",C["SnuuLL"],C["Mnu"].conj().T @ C["Mnu"] @ C["Mnu"].conj().T) + 4*my_einsum("wvsr,wv",C["SnuuLR"].conj(),C["Mnu"] @ C["Mnu"].conj().T @ C["Mnu"]) + 4*my_einsum("wvsr,wv",C["SeuRR"].conj(),C["Me"].conj().T @ C["Me"] @ C["Me"].conj().T) + 4*my_einsum("vwrs,wv",C["SeuRL"],C["Me"] @ C["Me"].conj().T @ C["Me"]) + (8*Nc*my_einsum("srwv,wv",C["S1uuRR"].conj(),C["Mu"].conj().T @ C["Mu"] @ C["Mu"].conj().T) - 4*my_einsum("svwr,wv",C["S1uuRR"].conj(),C["Mu"].conj().T @ C["Mu"] @ C["Mu"].conj().T) - 4*CF*my_einsum("svwr,wv",C["S8uuRR"].conj(),C["Mu"].conj().T @ C["Mu"] @ C["Mu"].conj().T)) - 8*(my_einsum("vsrw,wv",C["V1uuLR"],C["Mu"] @ C["Mu"].conj().T @ C["Mu"]) + CF*my_einsum("vsrw,wv",C["V8uuLR"],C["Mu"] @ C["Mu"].conj().T @ C["Mu"])) + (4*Nc*my_einsum("srwv,wv",C["S1udRR"].conj(),C["Md"].conj().T @ C["Md"] @ C["Md"].conj().T) - 2*my_einsum("svwr,wv",C["S1udduRR"].conj(),C["Md"].conj().T @ C["Md"] @ C["Md"].conj().T) - 2*CF*my_einsum("svwr,wv",C["S8udduRR"].conj(),C["Md"].conj().T @ C["Md"] @ C["Md"].conj().T)) - 8*(my_einsum("svwr,wv",C["V1udduLR"].conj(),C["Md"] @ C["Md"].conj().T @ C["Md"]) + CF*my_einsum("svwr,wv",C["V8udduLR"].conj(),C["Md"] @ C["Md"].conj().T @ C["Md"])) - 12*my_einsum("wr,vu,wv,us",C["ugamma"].conj(),C["ugamma"],C["Mu"].conj().T @ C["Mu"],C["Mu"]) + 4*my_einsum("wr,wv,vs",C["ugamma"].conj(),C["ugamma"],C["Mu"] @ C["Mu"].conj().T @ C["Mu"]) - 12*my_einsum("uw,sv,wv,ru",C["ugamma"],C["ugamma"].conj(),C["Mu"] @ C["Mu"].conj().T,C["Mu"]) + 4*my_einsum("vw,sw,rv",C["ugamma"],C["ugamma"].conj(),C["Mu"] @ C["Mu"].conj().T @ C["Mu"]) - 12*CF*my_einsum("wr,vu,wv,us",C["uG"].conj(),C["uG"],C["Mu"].conj().T @ C["Mu"],C["Mu"]) + 4*CF*my_einsum("wr,wv,vs",C["uG"].conj(),C["uG"],C["Mu"] @ C["Mu"].conj().T @ C["Mu"]) - 12*CF*my_einsum("uw,sv,wv,ru",C["uG"],C["uG"].conj(),C["Mu"] @ C["Mu"].conj().T,C["Mu"]) + 4*CF*my_einsum("vw,sw,rv",C["uG"],C["uG"].conj(),C["Mu"] @ C["Mu"].conj().T @ C["Mu"]) - 24*my_einsum("vr,sw,vw",C["ugamma"].conj(),C["ugamma"].conj(),C["Mu"].conj().T @ C["Mu"] @ C["Mu"].conj().T) - 24*CF*my_einsum("vr,sw,vw",C["uG"].conj(),C["uG"].conj(),C["Mu"].conj().T @ C["Mu"] @ C["Mu"].conj().T) - - Beta["Md"] = - 6*(CF*g**2 + qd**2*e**2)*my_einsum("rs",C["Md"]) + 12*(CF*g*my_einsum("vr,vs",C["dG"].conj(),C["Md"].conj().T @ C["Md"]) + qd*e*my_einsum("vr,vs",C["dgamma"].conj(),C["Md"].conj().T @ C["Md"])) + 12*(CF*g*my_einsum("sv,rv",C["dG"].conj(),C["Md"] @ C["Md"].conj().T) + qd*e*my_einsum("sv,rv",C["dgamma"].conj(),C["Md"] @ C["Md"].conj().T)) + 4*my_einsum("vwrs,wv",C["SnudLL"],C["Mnu"].conj().T @ C["Mnu"] @ C["Mnu"].conj().T) + 4*my_einsum("wvsr,wv",C["SnudLR"].conj(),C["Mnu"] @ C["Mnu"].conj().T @ C["Mnu"]) + 4*my_einsum("wvsr,wv",C["SedRR"].conj(),C["Me"].conj().T @ C["Me"] @ C["Me"].conj().T) + 4*my_einsum("vwrs,wv",C["SedRL"],C["Me"] @ C["Me"].conj().T @ C["Me"]) + (4*Nc*my_einsum("wvsr,wv",C["S1udRR"].conj(),C["Mu"].conj().T @ C["Mu"] @ C["Mu"].conj().T) - 2*my_einsum("wrsv,wv",C["S1udduRR"].conj(),C["Mu"].conj().T @ C["Mu"] @ C["Mu"].conj().T) - 2*CF*my_einsum("wrsv,wv",C["S8udduRR"].conj(),C["Mu"].conj().T @ C["Mu"] @ C["Mu"].conj().T)) - 8*(my_einsum("vsrw,wv",C["V1udduLR"],C["Mu"] @ C["Mu"].conj().T @ C["Mu"]) + CF*my_einsum("vsrw,wv",C["V8udduLR"],C["Mu"] @ C["Mu"].conj().T @ C["Mu"])) + (8*Nc*my_einsum("wvsr,wv",C["S1ddRR"].conj(),C["Md"].conj().T @ C["Md"] @ C["Md"].conj().T) - 4*my_einsum("wrsv,wv",C["S1ddRR"].conj(),C["Md"].conj().T @ C["Md"] @ C["Md"].conj().T) - 4*CF*my_einsum("wrsv,wv",C["S8ddRR"].conj(),C["Md"].conj().T @ C["Md"] @ C["Md"].conj().T)) - 8*(my_einsum("vsrw,wv",C["V1ddLR"],C["Md"] @ C["Md"].conj().T @ C["Md"]) + CF*my_einsum("vsrw,wv",C["V8ddLR"],C["Md"] @ C["Md"].conj().T @ C["Md"])) - 12*my_einsum("wr,vu,wv,us",C["dgamma"].conj(),C["dgamma"],C["Md"].conj().T @ C["Md"],C["Md"]) + 4*my_einsum("wr,wv,vs",C["dgamma"].conj(),C["dgamma"],C["Md"] @ C["Md"].conj().T @ C["Md"]) - 12*my_einsum("uw,sv,wv,ru",C["dgamma"],C["dgamma"].conj(),C["Md"] @ C["Md"].conj().T,C["Md"]) + 4*my_einsum("vw,sw,rv",C["dgamma"],C["dgamma"].conj(),C["Md"] @ C["Md"].conj().T @ C["Md"]) - 12*CF*my_einsum("wr,vu,wv,us",C["dG"].conj(),C["dG"],C["Md"].conj().T @ C["Md"],C["Md"]) + 4*CF*my_einsum("wr,wv,vs",C["dG"].conj(),C["dG"],C["Md"] @ C["Md"].conj().T @ C["Md"]) - 12*CF*my_einsum("uw,sv,wv,ru",C["dG"],C["dG"].conj(),C["Md"] @ C["Md"].conj().T,C["Md"]) + 4*CF*my_einsum("vw,sw,rv",C["dG"],C["dG"].conj(),C["Md"] @ C["Md"].conj().T @ C["Md"]) - 24*my_einsum("vr,sw,vw",C["dgamma"].conj(),C["dgamma"].conj(),C["Md"].conj().T @ C["Md"] @ C["Md"].conj().T) - 24*CF*my_einsum("vr,sw,vw",C["dG"].conj(),C["dG"].conj(),C["Md"].conj().T @ C["Md"] @ C["Md"].conj().T) + Beta["Md"] = - 6*(CF*g**2 + qd**2*e**2)*my_einsum("rs",C["Md"]) #+ 12*(CF*g*my_einsum("vr,vs",C["dG"].conj(),C["Md"].conj().T @ C["Md"]) + qd*e*my_einsum("vr,vs",C["dgamma"].conj(),C["Md"].conj().T @ C["Md"])) + 12*(CF*g*my_einsum("sv,rv",C["dG"].conj(),C["Md"] @ C["Md"].conj().T) + qd*e*my_einsum("sv,rv",C["dgamma"].conj(),C["Md"] @ C["Md"].conj().T)) + 4*my_einsum("vwrs,wv",C["SnudLL"],C["Mnu"].conj().T @ C["Mnu"] @ C["Mnu"].conj().T) + 4*my_einsum("wvsr,wv",C["SnudLR"].conj(),C["Mnu"] @ C["Mnu"].conj().T @ C["Mnu"]) + 4*my_einsum("wvsr,wv",C["SedRR"].conj(),C["Me"].conj().T @ C["Me"] @ C["Me"].conj().T) + 4*my_einsum("vwrs,wv",C["SedRL"],C["Me"] @ C["Me"].conj().T @ C["Me"]) + (4*Nc*my_einsum("wvsr,wv",C["S1udRR"].conj(),C["Mu"].conj().T @ C["Mu"] @ C["Mu"].conj().T) - 2*my_einsum("wrsv,wv",C["S1udduRR"].conj(),C["Mu"].conj().T @ C["Mu"] @ C["Mu"].conj().T) - 2*CF*my_einsum("wrsv,wv",C["S8udduRR"].conj(),C["Mu"].conj().T @ C["Mu"] @ C["Mu"].conj().T)) - 8*(my_einsum("vsrw,wv",C["V1udduLR"],C["Mu"] @ C["Mu"].conj().T @ C["Mu"]) + CF*my_einsum("vsrw,wv",C["V8udduLR"],C["Mu"] @ C["Mu"].conj().T @ C["Mu"])) + (8*Nc*my_einsum("wvsr,wv",C["S1ddRR"].conj(),C["Md"].conj().T @ C["Md"] @ C["Md"].conj().T) - 4*my_einsum("wrsv,wv",C["S1ddRR"].conj(),C["Md"].conj().T @ C["Md"] @ C["Md"].conj().T) - 4*CF*my_einsum("wrsv,wv",C["S8ddRR"].conj(),C["Md"].conj().T @ C["Md"] @ C["Md"].conj().T)) - 8*(my_einsum("vsrw,wv",C["V1ddLR"],C["Md"] @ C["Md"].conj().T @ C["Md"]) + CF*my_einsum("vsrw,wv",C["V8ddLR"],C["Md"] @ C["Md"].conj().T @ C["Md"])) - 12*my_einsum("wr,vu,wv,us",C["dgamma"].conj(),C["dgamma"],C["Md"].conj().T @ C["Md"],C["Md"]) + 4*my_einsum("wr,wv,vs",C["dgamma"].conj(),C["dgamma"],C["Md"] @ C["Md"].conj().T @ C["Md"]) - 12*my_einsum("uw,sv,wv,ru",C["dgamma"],C["dgamma"].conj(),C["Md"] @ C["Md"].conj().T,C["Md"]) + 4*my_einsum("vw,sw,rv",C["dgamma"],C["dgamma"].conj(),C["Md"] @ C["Md"].conj().T @ C["Md"]) - 12*CF*my_einsum("wr,vu,wv,us",C["dG"].conj(),C["dG"],C["Md"].conj().T @ C["Md"],C["Md"]) + 4*CF*my_einsum("wr,wv,vs",C["dG"].conj(),C["dG"],C["Md"] @ C["Md"].conj().T @ C["Md"]) - 12*CF*my_einsum("uw,sv,wv,ru",C["dG"],C["dG"].conj(),C["Md"] @ C["Md"].conj().T,C["Md"]) + 4*CF*my_einsum("vw,sw,rv",C["dG"],C["dG"].conj(),C["Md"] @ C["Md"].conj().T @ C["Md"]) - 24*my_einsum("vr,sw,vw",C["dgamma"].conj(),C["dgamma"].conj(),C["Md"].conj().T @ C["Md"] @ C["Md"].conj().T) - 24*CF*my_einsum("vr,sw,vw",C["dG"].conj(),C["dG"].conj(),C["Md"].conj().T @ C["Md"] @ C["Md"].conj().T) # Dimension 4: Gauge Couplings From f3549a52f9b735246ecaf26285e7399aeaff2bdb Mon Sep 17 00:00:00 2001 From: Jacky Kumar Date: Sat, 12 Feb 2022 12:48:02 +0100 Subject: [PATCH 4/9] resolve conflicts with PR#92 --- wilson/run/smeft/classes.py | 12 +++++++++--- wilson/run/smeft/rgeleft.py | 3 +-- 2 files changed, 10 insertions(+), 5 deletions(-) diff --git a/wilson/run/smeft/classes.py b/wilson/run/smeft/classes.py index fcfe9c4..1059bb1 100644 --- a/wilson/run/smeft/classes.py +++ b/wilson/run/smeft/classes.py @@ -69,7 +69,9 @@ def __init__(self, wc, dim4_left=True): if dim4_left: self.C_in.update(self._get_sm_left(self.scale_in, self.f)) - + + self.C_in = wilson.util.wetutil.pad_C(self.C_in) + def _leftevolve_leadinglog(self, scale_out): """Compute the leading logarithmic approximation to the solution of the LEFT RGEs from the initial scale to `scale_out`. @@ -103,14 +105,18 @@ def _get_sm_left(self, scale, f, loop=3): C_in_SM['Md'] = np.array([[m_d,0,0],[0,m_s,0],[0,0,m_b]]) C_in_SM['Mu'] = np.array([[m_u,0],[0,m_c]]) - C_in_SM['Mnu'] = np.array([[0,0,0],[0,0,0],[0,0,0]]) # update + C_in_SM['Mnu'] = np.array([[0,0,0],[0,0,0],[0,0,0]]) # update? return C_in_SM def _to_wcxf(self, C_out, scale_out): """Return the Wilson coefficients `C_out` as a wcxf.WC instance. """ +# C = wetutil.unpad_C(C_out) C = C_out - d = wilson.util.wetutil.arrays2wcxf(C) + d = wilson.util.wetutil.arrays2wcxf(C) + basis = wcxf.Basis['WET', 'JMS'] + left_wcs = set(basis.all_wcs) + d = {k: v for k, v in d.items() if k in left_wcs and v != 0} d = wcxf.WC.dict2values(d) wc = wcxf.WC('WET', 'JMS', scale_out, d) return wc diff --git a/wilson/run/smeft/rgeleft.py b/wilson/run/smeft/rgeleft.py index b84dd25..eb342b7 100644 --- a/wilson/run/smeft/rgeleft.py +++ b/wilson/run/smeft/rgeleft.py @@ -10,9 +10,8 @@ def left_evolve_leadinglog(C_in, scale_in, scale_out): """Solve the LEFT RGEs in the leading log approximation. Input C_in and output C_out are dictionaries of arrays.""" C_out = deepcopy(C_in) - b = beta.beta(C_out) - for k, C in C_out.items(): + for k, C in C_in.items(): # look for loopholes C_in vs C_out C_out[k] = C + b[k] / (16 * pi**2) * log(scale_out / scale_in) return C_out From 2bc7c63e0721a6745c98a250ad936643eaa284e2 Mon Sep 17 00:00:00 2001 From: Jacky Kumar Date: Sat, 12 Feb 2022 14:48:26 +0100 Subject: [PATCH 5/9] resolve conflicts to pass the unittests --- wilson/classes.py | 78 +++++++++++++++++++++++------------------- wilson/run/wet/beta.py | 3 +- 2 files changed, 44 insertions(+), 37 deletions(-) diff --git a/wilson/classes.py b/wilson/classes.py index c818948..c86492d 100644 --- a/wilson/classes.py +++ b/wilson/classes.py @@ -203,12 +203,14 @@ def match_run(self, scale, eft, basis, sectors='all'): scale_ew = self.get_option('smeft_matchingscale') mb = self.get_option('mb_matchingscale') mc = self.get_option('mc_matchingscale') + wet_method = self.get_option('wet_method') if self.wc.basis == basis and self.wc.eft == eft and scale == self.wc.scale: return self.wc # nothing to do if self.wc.eft == eft and scale == self.wc.scale: wc_out = self.wc.translate(basis, sectors=translate_sectors, parameters=self.parameters) # only translation necessary self._set_cache(sectors, scale, eft, basis, wc_out) return wc_out + if self.wc.eft == 'SMEFT': smeft_accuracy = self.get_option('smeft_accuracy') if eft == 'SMEFT': @@ -227,48 +229,54 @@ def match_run(self, scale, eft, basis, sectors='all'): smeft = SMEFT(self.wc.translate('Warsaw', parameters=self.parameters)) wc_ew = smeft.run(scale_ew, accuracy=smeft_accuracy).match('WET', 'JMS', parameters=self.matching_parameters) self._set_cache('all', scale_ew, wc_ew.eft, wc_ew.basis, wc_ew) - wet = WETrunner(wc_ew, **self._wetrun_opt()) + if wet_method == 'adms': + wet = WETrunner(wc_ew, **self._wetrun_opt()) + elif wet_method == 'betafunctions': + left = LEFT(wc_ew) + elif self.wc.eft in ['WET', 'WET-4', 'WET-3']: - wet_method = self.get_option('wet_method') if wet_method == 'adms': wet = WETrunner(self.wc.translate('JMS', parameters=self.parameters, sectors=translate_sectors), **self._wetrun_opt()) - if eft == wet.eft: # just run - wc_out = wet.run(scale, sectors=sectors).translate(basis, sectors=translate_sectors, parameters=self.parameters) - self._set_cache(sectors, scale, eft, basis, wc_out) - return wc_out - elif eft == 'WET-4' and wet.eft == 'WET': # match at mb - wc_mb = wet.run(mb, sectors=sectors).match('WET-4', 'JMS', parameters=self.matching_parameters) - wet4 = WETrunner(wc_mb, **self._wetrun_opt()) - wc_out = wet4.run(scale, sectors=sectors).translate(basis, sectors=translate_sectors, parameters=self.parameters) - self._set_cache(sectors, scale, 'WET-4', basis, wc_out) - return wc_out - elif eft == 'WET-3' and wet.eft == 'WET-4': # match at mc - wc_mc = wet.run(mc, sectors=sectors).match('WET-3', 'JMS', parameters=self.matching_parameters) - wet3 = WETrunner(wc_mc, **self._wetrun_opt()) - wc_out = wet3.run(scale, sectors=sectors).translate(basis, sectors=translate_sectors, parameters=self.parameters) - return wc_out - self._set_cache(sectors, scale, 'WET-3', basis, wc_out) - elif eft == 'WET-3' and wet.eft == 'WET': # match at mb and mc - wc_mb = wet.run(mb, sectors=sectors).match('WET-4', 'JMS', parameters=self.matching_parameters) - wet4 = WETrunner(wc_mb, **self._wetrun_opt()) - wc_mc = wet4.run(mc, sectors=sectors).match('WET-3', 'JMS', parameters=self.matching_parameters) - wet3 = WETrunner(wc_mc, **self._wetrun_opt()) - wc_out = wet3.run(scale, sectors=sectors).translate(basis, sectors=translate_sectors, parameters=self.parameters) - self._set_cache(sectors, scale, 'WET-3', basis, wc_out) - return wc_out - else: - raise ValueError(f"Running from {wet.eft} to {eft} not implemented") - elif wet_method == 'betafunctions': - left = LEFT(self.wc.translate('JMS', parameters=self.parameters, sectors=translate_sectors)) - if eft == left.eft: # just run - wc_out = left.run(scale) - return wc_out - else: - raise ValueError(f"Running from {wet.eft} to {eft} not implemented") + left = LEFT(self.wc.translate('JMS', parameters=self.parameters, sectors=translate_sectors)) else: raise ValueError(f"Input EFT {self.wc.eft} unknown or not supported") + if wet_method == 'adms': + if eft == wet.eft: # just run + wc_out = wet.run(scale, sectors=sectors).translate(basis, sectors=translate_sectors, parameters=self.parameters) + self._set_cache(sectors, scale, eft, basis, wc_out) + return wc_out + elif eft == 'WET-4' and wet.eft == 'WET': # match at mb + wc_mb = wet.run(mb, sectors=sectors).match('WET-4', 'JMS', parameters=self.matching_parameters) + wet4 = WETrunner(wc_mb, **self._wetrun_opt()) + wc_out = wet4.run(scale, sectors=sectors).translate(basis, sectors=translate_sectors, parameters=self.parameters) + self._set_cache(sectors, scale, 'WET-4', basis, wc_out) + return wc_out + elif eft == 'WET-3' and wet.eft == 'WET-4': # match at mc + wc_mc = wet.run(mc, sectors=sectors).match('WET-3', 'JMS', parameters=self.matching_parameters) + wet3 = WETrunner(wc_mc, **self._wetrun_opt()) + wc_out = wet3.run(scale, sectors=sectors).translate(basis, sectors=translate_sectors, parameters=self.parameters) + return wc_out + self._set_cache(sectors, scale, 'WET-3', basis, wc_out) + elif eft == 'WET-3' and wet.eft == 'WET': # match at mb and mc + wc_mb = wet.run(mb, sectors=sectors).match('WET-4', 'JMS', parameters=self.matching_parameters) + wet4 = WETrunner(wc_mb, **self._wetrun_opt()) + wc_mc = wet4.run(mc, sectors=sectors).match('WET-3', 'JMS', parameters=self.matching_parameters) + wet3 = WETrunner(wc_mc, **self._wetrun_opt()) + wc_out = wet3.run(scale, sectors=sectors).translate(basis, sectors=translate_sectors, parameters=self.parameters) + self._set_cache(sectors, scale, 'WET-3', basis, wc_out) + return wc_out + else: + raise ValueError(f"Running from {wet.eft} to {eft} not implemented") + + elif wet_method == 'betafunctions': + if eft == left.eft: # just run + wc_out = left.run(scale) + return wc_out + else: + raise ValueError(f"Running from {wet.eft} to {eft} not implemented") + def clear_cache(self): self._cache = {} diff --git a/wilson/run/wet/beta.py b/wilson/run/wet/beta.py index aa8597b..9ff7daa 100644 --- a/wilson/run/wet/beta.py +++ b/wilson/run/wet/beta.py @@ -49,9 +49,8 @@ def beta(C, n_gen=3): Beta = {} - # Dimension 3: Masses - + Beta["Mnu"] = zeros_2F#24*my_einsum("vwrs,wv",C["SnunuLL"],C["Mnu"].conj().T @ C["Mnu"] @ C["Mnu"].conj().T) + 16*my_einsum("wrvs,wv",C["VnunuLL"],C["Mnu"] @ C["Mnu"].conj().T @ C["Mnu"]) + 8*my_einsum("rsvw,wv",C["SnueLL"],C["Me"].conj().T @ C["Me"] @ C["Me"].conj().T) + 8*my_einsum("rsvw,wv",C["SnueLR"],C["Me"] @ C["Me"].conj().T @ C["Me"]) + 8*Nc*my_einsum("rsvw,wv",C["SnuuLL"],C["Mu"].conj().T @ C["Mu"] @ C["Mu"].conj().T) + 8*Nc*my_einsum("rsvw,wv",C["SnuuLR"],C["Mu"] @ C["Mu"].conj().T @ C["Mu"]) + 8*Nc*my_einsum("rsvw,wv",C["SnudLL"],C["Md"].conj().T @ C["Md"] @ C["Md"].conj().T) + 8*Nc*my_einsum("rsvw,wv",C["SnudLR"],C["Md"] @ C["Md"].conj().T @ C["Md"]) - 48*my_einsum("rw,uv,wv,us",C["nugamma"],C["nugamma"].conj(),C["Mnu"].conj().T @ C["Mnu"],C["Mnu"]) + 16*my_einsum("rw,vw,vs",C["nugamma"],C["nugamma"].conj(),C["Mnu"] @ C["Mnu"].conj().T @ C["Mnu"]) - 48*my_einsum("wu,vs,wv,ru",C["nugamma"].conj(),C["nugamma"],C["Mnu"] @ C["Mnu"].conj().T,C["Mnu"]) + 16*my_einsum("wv,ws,rv",C["nugamma"].conj(),C["nugamma"],C["Mnu"] @ C["Mnu"].conj().T @ C["Mnu"]) - 96*my_einsum("rv,ws,vw",C["nugamma"],C["nugamma"],C["Mnu"].conj().T @ C["Mnu"] @ C["Mnu"].conj().T) Beta["Me"] = - 6*qe**2*e**2*my_einsum("rs",C["Me"]) #+ 12*qe*e*my_einsum("vr,vs",C["egamma"].conj(),C["Me"].conj().T @ C["Me"]) + 12*qe*e*my_einsum("sv,rv",C["egamma"].conj(),C["Me"] @ C["Me"].conj().T) + 4*my_einsum("vwrs,wv",C["SnueLL"],C["Mnu"].conj().T @ C["Mnu"] @ C["Mnu"].conj().T) + 4*my_einsum("wvsr,wv",C["SnueLR"].conj(),C["Mnu"] @ C["Mnu"].conj().T @ C["Mnu"]) + (8*my_einsum("srwv,wv",C["SeeRR"].conj(),C["Me"].conj().T @ C["Me"] @ C["Me"].conj().T) - 4*my_einsum("wrsv,wv",C["SeeRR"].conj(),C["Me"].conj().T @ C["Me"] @ C["Me"].conj().T)) - 8*my_einsum("vsrw,wv",C["VeeLR"],C["Me"] @ C["Me"].conj().T @ C["Me"]) + 4*Nc*my_einsum("srwv,wv",C["SeuRR"].conj(),C["Mu"].conj().T @ C["Mu"] @ C["Mu"].conj().T) + 4*Nc*my_einsum("srwv,wv",C["SeuRL"].conj(),C["Mu"] @ C["Mu"].conj().T @ C["Mu"]) + 4*Nc*my_einsum("srwv,wv",C["SedRR"].conj(),C["Md"].conj().T @ C["Md"] @ C["Md"].conj().T) + 4*Nc*my_einsum("srwv,wv",C["SedRL"].conj(),C["Md"] @ C["Md"].conj().T @ C["Md"]) - 12*my_einsum("wr,vu,wv,us",C["egamma"].conj(),C["egamma"],C["Me"].conj().T @ C["Me"],C["Me"]) + 4*my_einsum("wr,wv,vs",C["egamma"].conj(),C["egamma"],C["Me"] @ C["Me"].conj().T @ C["Me"]) - 12*my_einsum("uw,sv,wv,ru",C["egamma"],C["egamma"].conj(),C["Me"] @ C["Me"].conj().T,C["Me"]) + 4*my_einsum("vw,sw,rv",C["egamma"],C["egamma"].conj(),C["Me"] @ C["Me"].conj().T @ C["Me"]) - 24*my_einsum("vr,sw,vw",C["egamma"].conj(),C["egamma"].conj(),C["Me"].conj().T @ C["Me"] @ C["Me"].conj().T) From b7cccfce3ccec77525ce7aef79dd4256e2171ee9 Mon Sep 17 00:00:00 2001 From: Jacky Kumar Date: Mon, 14 Feb 2022 20:27:01 +0100 Subject: [PATCH 6/9] Implement running from WFT-x to WET-y --- wilson/classes.py | 24 ++++++++++++++++++++++-- wilson/run/smeft/classes.py | 34 ++++++++++++++++++++-------------- wilson/run/smeft/rgeleft.py | 4 ++-- 3 files changed, 44 insertions(+), 18 deletions(-) diff --git a/wilson/classes.py b/wilson/classes.py index c86492d..c05d740 100644 --- a/wilson/classes.py +++ b/wilson/classes.py @@ -238,7 +238,7 @@ def match_run(self, scale, eft, basis, sectors='all'): if wet_method == 'adms': wet = WETrunner(self.wc.translate('JMS', parameters=self.parameters, sectors=translate_sectors), **self._wetrun_opt()) elif wet_method == 'betafunctions': - left = LEFT(self.wc.translate('JMS', parameters=self.parameters, sectors=translate_sectors)) + left = LEFT(self.wc.translate('JMS', parameters=self.parameters, sectors=translate_sectors)) #look else: raise ValueError(f"Input EFT {self.wc.eft} unknown or not supported") @@ -272,10 +272,30 @@ def match_run(self, scale, eft, basis, sectors='all'): elif wet_method == 'betafunctions': if eft == left.eft: # just run - wc_out = left.run(scale) + wc_out = left.run(scale).translate(basis, sectors=translate_sectors, parameters=self.parameters) + return wc_out + elif eft == 'WET-4' and left.eft == 'WET': # match at mb + wc_mb = left.run(mb).match('WET-4', 'JMS', parameters=self.matching_parameters) + wet4 = LEFT(wc_mb) # Fix no. of flavours + wc_out = wet4.run(scale).translate(basis, sectors=translate_sectors, parameters=self.parameters) + return wc_out + elif eft == 'WET-3' and left.eft == 'WET': # match at mb and mc + wc_mb = left.run(mb).match('WET-4', 'JMS', parameters=self.matching_parameters) + wet4 = LEFT(wc_mb) + wc_mc = wet4.run(mc).match('WET-3', 'JMS', parameters=self.matching_parameters) + wet3 = LEFT(wc_mc) + wc_out = wet3.run(scale).translate(basis, sectors=translate_sectors, parameters=self.parameters) + return wc_out + elif eft == 'WET-3' and left.eft == 'WET-4': # match at mc + wc_mc = left.run(mc).match('WET-3', 'JMS', parameters=self.matching_parameters) + wet3 = LEFT(wc_mc) + wc_out = wet3.run(scale).translate(basis, sectors=translate_sectors, parameters=self.parameters) return wc_out else: raise ValueError(f"Running from {wet.eft} to {eft} not implemented") + else: + raise ValueError(f"The key {wet_method} does not exist.") + def clear_cache(self): self._cache = {} diff --git a/wilson/run/smeft/classes.py b/wilson/run/smeft/classes.py index 1059bb1..d6d531e 100644 --- a/wilson/run/smeft/classes.py +++ b/wilson/run/smeft/classes.py @@ -48,13 +48,19 @@ def __init__(self, wc, dim4_left=True): self.C_in = None if self.eft == 'WET': - self.f = 5 + self.Nu=2 + self.Nd=3 elif self.eft == 'WET-4': - self.f = 4 + self.Nu=2 + self.Nd=2 elif self.eft == 'WET-3': - self.f = 3 + self.Nu=1 + self.Nd=2 + + f = self.Nu+ self.Nd C = wilson.util.wetutil.wcxf2arrays_symmetrized(wc.dict) + for k, s in wetutil.C_keys_shape.items(): if k not in C and k not in wetutil.dim4_keys: if s == 1: @@ -68,7 +74,7 @@ def __init__(self, wc, dim4_left=True): self.C_in.update(C) if dim4_left: - self.C_in.update(self._get_sm_left(self.scale_in, self.f)) + self.C_in.update(self._get_sm_left(self.scale_in, f)) self.C_in = wilson.util.wetutil.pad_C(self.C_in) @@ -79,27 +85,27 @@ def _leftevolve_leadinglog(self, scale_out): """ return rgeleft.left_evolve_leadinglog(C_in=self.C_in, scale_in=self.scale_in, - scale_out=scale_out) + scale_out=scale_out, Nu= self.Nu, Nd= self.Nd) def _get_sm_left(self, scale, f, loop=3): C_in_SM={} parameters= default_parameters.copy() - m_d = qcd.m_s(parameters['m_d'], scale, self.f, parameters['alpha_s'], loop=loop) - m_s = qcd.m_s(parameters['m_s'], scale, self.f, parameters['alpha_s'], loop=loop) - m_b = qcd.m_b(parameters['m_b'], scale, self.f, parameters['alpha_s'], loop=loop) + m_d = qcd.m_s(parameters['m_d'], scale, f, parameters['alpha_s'], loop=loop) + m_s = qcd.m_s(parameters['m_s'], scale, f, parameters['alpha_s'], loop=loop) + m_b = qcd.m_b(parameters['m_b'], scale, f, parameters['alpha_s'], loop=loop) - m_u = qcd.m_s(parameters['m_u'], scale, self.f, parameters['alpha_s'], loop=loop) - m_c = qcd.m_c(parameters['m_c'], scale, self.f, parameters['alpha_s'], loop=loop) + m_u = qcd.m_s(parameters['m_u'], scale, f, parameters['alpha_s'], loop=loop) + m_c = qcd.m_c(parameters['m_c'], scale, f, parameters['alpha_s'], loop=loop) # running ignored for alpha_e and lepton mass m_e = parameters['m_e'] m_mu = parameters['m_mu'] m_tau = parameters['m_tau'] - C_in_SM['gs'] = sqrt(4*pi*qcd.alpha_s(scale, self.f, parameters['alpha_s'], loop=loop)) - C_in_SM['e'] = sqrt(4*pi*parameters['alpha_e']) + C_in_SM['gs'] = sqrt(4*pi*qcd.alpha_s(scale, f, parameters['alpha_s'], loop=loop)) + C_in_SM['e'] = sqrt(4*pi*parameters['alpha_e']) C_in_SM['Me'] = np.array([[m_e,0,0],[0,m_mu,0],[0,0,m_tau]]) C_in_SM['Md'] = np.array([[m_d,0,0],[0,m_s,0],[0,0,m_b]]) @@ -114,11 +120,11 @@ def _to_wcxf(self, C_out, scale_out): # C = wetutil.unpad_C(C_out) C = C_out d = wilson.util.wetutil.arrays2wcxf(C) - basis = wcxf.Basis['WET', 'JMS'] + basis = wcxf.Basis[self.eft, 'JMS'] left_wcs = set(basis.all_wcs) d = {k: v for k, v in d.items() if k in left_wcs and v != 0} d = wcxf.WC.dict2values(d) - wc = wcxf.WC('WET', 'JMS', scale_out, d) + wc = wcxf.WC(self.eft, 'JMS', scale_out, d) return wc def run(self, scale): diff --git a/wilson/run/smeft/rgeleft.py b/wilson/run/smeft/rgeleft.py index eb342b7..c8c7f34 100644 --- a/wilson/run/smeft/rgeleft.py +++ b/wilson/run/smeft/rgeleft.py @@ -6,11 +6,11 @@ import numpy as np # # -def left_evolve_leadinglog(C_in, scale_in, scale_out): +def left_evolve_leadinglog(C_in, scale_in, scale_out, Nu,Nd): """Solve the LEFT RGEs in the leading log approximation. Input C_in and output C_out are dictionaries of arrays.""" C_out = deepcopy(C_in) - b = beta.beta(C_out) + b = beta.beta(C_out, Nu, Nd) for k, C in C_in.items(): # look for loopholes C_in vs C_out C_out[k] = C + b[k] / (16 * pi**2) * log(scale_out / scale_in) return C_out From a26e8349d3529b2d7e1c1fd685f113ad57f4435c Mon Sep 17 00:00:00 2001 From: Jacky Kumar Date: Mon, 14 Feb 2022 20:28:55 +0100 Subject: [PATCH 7/9] Implement running from WET-x to WET-y --- wilson/run/wet/beta.py | 20 +++++++++----------- 1 file changed, 9 insertions(+), 11 deletions(-) diff --git a/wilson/run/wet/beta.py b/wilson/run/wet/beta.py index 9ff7daa..42d783b 100644 --- a/wilson/run/wet/beta.py +++ b/wilson/run/wet/beta.py @@ -15,21 +15,19 @@ qd = -1/3 qe = -1 -nu = 2 -nd = 3 -ne = 3 +def beta(C, Nu=2, Nd=3): -b0g = (11*Nc - 2*(nd + nu))/3. -b0e = (-4*(Nc*nd*qd**2 + ne*qe**2 + Nc*nu*qu**2))/3. + Ne=3 + b0g = (11*Nc - 2*(Nd + Nu))/3. + b0e = (-4*(Nc*Nd*qd**2 + Ne*qe**2 + Nc*Nu*qu**2))/3. - -def beta(C, n_gen=3): e = C["e"] g = C["gs"] # set undefined Wilson coefficients to zero - zeros_4F = np.zeros((n_gen,n_gen,n_gen,n_gen)) - zeros_2F = np.zeros((n_gen,n_gen)) + + zeros_4F = np.zeros((3,3,3,3)) + zeros_2F = np.zeros((3,3)) C['SnunuLL'] = zeros_4F C['SnueLL'] = zeros_4F C['SnueLR'] = zeros_4F @@ -37,10 +35,10 @@ def beta(C, n_gen=3): C['SnuuLR'] = zeros_4F C['SnudLL'] = zeros_4F C['SnudLR'] = zeros_4F - C['nugamma'] = zeros_2F + C['nugamma'] = zeros_2F # define Kronecker delta - C['delta'] = np.eye(n_gen) + C['delta'] = np.eye(3) # Eq. (3.41) zetae = (8/3)*(2*my_einsum("wv,wv",C["nugamma"],C["nugamma"].conj())+my_einsum("wv,wv",C["egamma"],C["egamma"].conj())+Nc*my_einsum("wv,wv",C["ugamma"],C["ugamma"].conj())+Nc*my_einsum("wv,wv",C["dgamma"],C["dgamma"].conj())) From d9e8f12d0f66277c05b190f9de8b7439ba19082b Mon Sep 17 00:00:00 2001 From: Jacky Kumar Date: Mon, 14 Feb 2022 20:30:53 +0100 Subject: [PATCH 8/9] Delete leftutil.py --- wilson/util/leftutil.py | 205 ---------------------------------------- 1 file changed, 205 deletions(-) delete mode 100644 wilson/util/leftutil.py diff --git a/wilson/util/leftutil.py b/wilson/util/leftutil.py deleted file mode 100644 index 58f44c4..0000000 --- a/wilson/util/leftutil.py +++ /dev/null @@ -1,205 +0,0 @@ -import numpy as np - -SM_keys = ['e', 'g', 'Md', 'Mu', 'Me', 'Mnu'] - -WC_keys_0f= ['G', 'Gtilde'] - -WC_keys_2f = ['egamma', 'ugamma', 'dgamma', 'nugamma', 'uG', 'dG', 'delta'] - -WC_keys_4f= ['S1udRR', 'S1udduRR', 'S8udRR', 'S8udduRR', 'SedRL', 'SedRR', 'SeuRL', 'SeuRR', \ -'SnueduRL', 'SnueduRR', 'TedRR', 'TeuRR', 'TnueduRR', 'V1udduLR', 'V8udduLR', 'VnueduLL', 'VnueduLR', \ -'SuddLL', 'SduuLL', 'SduuLR', 'SduuRL', 'SdudRL', 'SduuRR', 'VuuRR', 'VddRR', 'VuuLL', 'VddLL', 'S1ddRR',\ - 'S1uuRR', 'S8uuRR', 'SeeRR', 'S8ddRR', 'VnueLL', 'VnuuLL', 'VnudLL', 'VeuLL', 'VedLL', 'V1udLL', 'V8udLL',\ - 'VeuRR', 'VedRR', 'V1udRR', 'V8udRR', 'VnueLR', 'VeeLR', 'VnuuLR', 'VnudLR', 'VeuLR', 'VedLR', 'VueLR',\ - 'VdeLR', 'V1uuLR', 'V8uuLR', 'V1udLR', 'V8udLR', 'V1duLR', 'V8duLR', 'V1ddLR', 'V8ddLR', 'VeeLL', 'VeeRR',\ - 'VnunuLL', 'SuudLR', 'SuudRL', 'SdduRL', 'SnudLL', 'SnudLR', 'SnueLL', 'SnueLR', 'SnuuLL', 'SnuuLR', \ -'SnunuLL', 'TnueLL', 'TnuuLL', 'TnudLL', 'SnueduLL', 'TnueduLL', 'SnueduLR', 'VnueduRL', 'VnueduRR',\ - 'SdddLL', 'SuddLR', 'SdduLR', 'SdddLR', 'SdddRL', 'SuddRR', 'SdddRR'] - -C_keys = SM_keys + WC_keys_0f + WC_keys_2f + WC_keys_4f -WC_keys = WC_keys_0f + WC_keys_2f + WC_keys_4f - -#FIXME remove third flavour -C_keys_shape = { - 'delta': (3,3), - 'G': 1, - 'Gtilde': 1, - 'egamma': (3, 3), - 'uG': (3, 3), - 'dG': (3, 3), - 'ugamma': (3, 3), - 'dgamma': (3, 3), - 'S1udRR': (3, 3, 3, 3), - 'S1udduRR': (3, 3, 3, 3), - 'S8udRR': (3, 3, 3, 3), - 'S8udduRR': (3, 3, 3, 3), - 'SedRL': (3, 3, 3, 3), - 'SedRR': (3, 3, 3, 3), - 'SeuRL': (3, 3, 3, 3), - 'SeuRR': (3, 3, 3, 3), - 'SnueduRL': (3, 3, 3, 3), - 'SnueduRR': (3, 3, 3, 3), - 'TedRR': (3, 3, 3, 3), - 'TeuRR': (3, 3, 3, 3), - 'TnueduRR': (3, 3, 3, 3), - 'V1udduLR': (3, 3, 3, 3), - 'V8udduLR': (3, 3, 3, 3), - 'VnueduLL': (3, 3, 3, 3), - 'VnueduLR': (3, 3, 3, 3), - 'SuddLL': (3, 3, 3, 3), - 'SduuLL': (3, 3, 3, 3), - 'SduuLR': (3, 3, 3, 3), - 'SduuRL': (3, 3, 3, 3), - 'SdudRL': (3, 3, 3, 3), - 'SduuRR': (3, 3, 3, 3), - 'VuuRR': (3, 3, 3, 3), - 'VddRR': (3, 3, 3, 3), - 'VuuLL': (3, 3, 3, 3), - 'VddLL': (3, 3, 3, 3), - 'S1ddRR': (3, 3, 3, 3), - 'S1uuRR': (3, 3, 3, 3), - 'S8uuRR': (3, 3, 3, 3), - 'SeeRR': (3, 3, 3, 3), - 'S8ddRR': (3, 3, 3, 3), - 'VnueLL': (3, 3, 3, 3), - 'VnuuLL': (3, 3, 3, 3), - 'VnudLL': (3, 3, 3, 3), - 'VeuLL': (3, 3, 3, 3), - 'VedLL': (3, 3, 3, 3), - 'V1udLL': (3, 3, 3, 3), - 'V8udLL': (3, 3, 3, 3), - 'VeuRR': (3, 3, 3, 3), - 'VedRR': (3, 3, 3, 3), - 'V1udRR': (3, 3, 3, 3), - 'V8udRR': (3, 3, 3, 3), - 'VnueLR': (3, 3, 3, 3), - 'VeeLR': (3, 3, 3, 3), - 'VnuuLR': (3, 3, 3, 3), - 'VnudLR': (3, 3, 3, 3), - 'VeuLR': (3, 3, 3, 3), - 'VedLR': (3, 3, 3, 3), - 'VueLR': (3, 3, 3, 3), - 'VdeLR': (3, 3, 3, 3), - 'V1uuLR': (3, 3, 3, 3), - 'V8uuLR': (3, 3, 3, 3), - 'V1udLR': (3, 3, 3, 3), - 'V8udLR': (3, 3, 3, 3), - 'V1duLR': (3, 3, 3, 3), - 'V8duLR': (3, 3, 3, 3), - 'V1ddLR': (3, 3, 3, 3), - 'V8ddLR': (3, 3, 3, 3), - 'VeeLL': (3, 3, 3, 3), - 'VeeRR': (3, 3, 3, 3), - 'VnunuLL': (3, 3, 3, 3), - 'SuudLR': (3, 3, 3, 3), - 'SuudRL': (3, 3, 3, 3), - 'SdduRL': (3, 3, 3, 3), -} - -C_keys_shape_missing = { - 'e': 1, - 'g': 1, - 'Md': (3,3), - 'Me': (3,3), - 'Mu': (3,3), - 'Mnu': (3,3), - 'nugamma': (3,3), - 'SnudLL': (3,3,3,3), - 'SnudLR': (3,3,3,3), - 'SnueLL': (3,3,3,3), - 'SnueLR': (3,3,3,3), - 'SnuuLL': (3,3,3,3), - 'SnuuLR': (3,3,3,3), - 'SnunuLL': (3,3,3,3), - 'TnueLL': (3,3,3,3), - 'TnuuLL': (3,3,3,3), - 'TnudLL': (3,3,3,3), - 'SnueduLL': (3,3,3,3), - 'TnueduLL': (3,3,3,3), - 'SnueduLR': (3,3,3,3), - 'VnueduRL': (3,3,3,3), - 'VnueduRR': (3,3,3,3), - 'SdddLL': (3,3,3,3), - 'SuddLR': (3,3,3,3), - 'SdduLR': (3,3,3,3), - 'SdddLR': (3,3,3,3), - 'SdddRL': (3,3,3,3), - 'SuddRR': (3,3,3,3), - 'SdddRR': (3,3,3,3), -} - -C_keys_shape.update(C_keys_shape_missing) - - -def wcxf2arrays(d): - """Convert a dictionary with a Wilson coefficient - name followed by underscore and numeric indices as keys and numbers as - values to a dictionary with Wilson coefficient names as keys and - numbers or numpy arrays as values. This is needed for the parsing - of input in WCxf format.""" - C = {} - for k, v in d.items(): - name = k.split('_')[0] - s = C_keys_shape[name] - if s == 1: - C[k] = v - else: - ind = k.split('_')[-1] - if name not in C: - C[name] = np.zeros(s, dtype=complex) - C[name][tuple([int(i) - 1 for i in ind])] = v - return C - -def add_missing(C): - """Add arrays with zeros for missing Wilson coefficient keys""" - C_out = C.copy() - for k in (set(C_keys) - set(C.keys())): # FIXME - s = C_keys_shape[k] - if s == 1: - C_out[k] = 0 - else: - C_out[k] = np.zeros(C_keys_shape[k]) - return C_out - -def wcxf2arrays_symmetrized(d): - """Convert a LEFT dictionary with a Wilson coefficient - name followed by underscore and numeric indices as keys and numbers as - values to a dictionary with Wilson coefficient names as keys and - numbers or numpy arrays as values. - - - In contrast to `wcxf2arrays`, here the numpy arrays fulfill the same - symmetry relations as the operators (i.e. they contain redundant entries) - and they do not contain undefined indices. - - Zero arrays are added for missing coefficients.""" - C = wcxf2arrays(d) -# C = symmetrize_nonred(C) - C = add_missing(C) - return C - - -def arrays2wcxf(C): - """Convert a dictionary with Wilson coefficient names as keys and - numbers or numpy arrays as values to a dictionary with a Wilson coefficient - name followed by underscore and numeric indices as keys and numbers as - values. This is needed for the output in WCxf format.""" - d = {} - for k, v in C.items(): - if np.shape(v) == () or np.shape(v) == (1,): - d[k] = v - else: - ind = np.indices(v.shape).reshape(v.ndim, v.size).T - for i in ind: - name = k + '_' + ''.join([str(int(j) + 1) for j in i]) - d[name] = v[tuple(i)] - return d - - - - - - - - - From 81c905c7c1e4cf26b5d5a1a2b7b316f1f4f9d285 Mon Sep 17 00:00:00 2001 From: Jacky Kumar Date: Mon, 14 Feb 2022 20:51:50 +0100 Subject: [PATCH 9/9] Delete .DS_Store --- .DS_Store | Bin 6148 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 .DS_Store diff --git a/.DS_Store b/.DS_Store deleted file mode 100644 index 5c32bc83297d13710e6b04a5e21993d5dd04353f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6148 zcmeHKPm9w)9Q{pOx9OI}9u&O@0k5^TENH$RxNFU-8j%zK&4n`Wj%L~OA1dqgcFvXBJU_K{r?qFtn|sOTD@ zWAYgZ%_*P=S7(cDDvSfhfxpcG@$DYaDRJ`gXL0t3*g~N%ga&YS1y*M>K+Z48;ZcMMdST zq_8lKfKpmwHR>RJEb+gW`1|0Bv8NORv#T`KVM((GUWj!rfpeu1;9ZL@6}VoO%(bK6 zym=HRX}9}>RjRdXdv&XBHLcg~JD$1eEL|pp+2WWw0F+lR!r158fG=Y|ky=+ZSPiQ&ZQWX}`n|S&_;B5}SH0eYe%tPM57+C4b@T51 zN5|9i=pyEy@cIabC0)jW#!L8&LSabn-9;SnSWJV^T;H??W(IVI>z>bayC7qa~(B#Ge<3Q1Ys=957 z{eS%D^M6rf?u-M*f&a<@RvWpa0fwaa)~&&bz1Bv0gCs)ma)nZYOmD}sAhzP$NHWl7 YivrNmm@7mL!u%1CHkiyfuu}(q1NW4+-v9sr