def get_amp(self, data, _data_c=None, **kwargs): mass = data["m"] zeros = tf.zeros_like(mass) a = tf.abs(self.a()) b = self.b() r = -tf.complex(a, b) * tf.complex(mass * mass, zeros) return tf.exp(r)
def get_amp(self, data, data_c=None, **kwargs): r""" .. math:: R(m) = \frac{m}{q cot \delta_B - i q} + e^{2i \delta_B}\frac{m_0 \Gamma_0 \frac{m_0}{q_0}} {(m_0^2 - m^2) - i m_0\Gamma_0 \frac{q}{m}\frac{m_0}{q_0}} .. math:: cot \delta_B = \frac{1}{a q} + \frac{1}{2} r q .. math:: e^{2i\delta_B} = \cos 2 \delta_B + i \sin 2\delta_B = \frac{cot^2\delta_B -1 }{cot^2 \delta_B +1} + i \frac{2 cot \delta_B }{cot^2 \delta_B +1 } """ m = data["m"] q = data_c["|q|"] q0 = data_c["|q0|"] mass = self.get_mass() width = self.get_width() a, r = tf.abs(self.a()), tf.abs(self.r()) cot_delta_B = (1.0 / a) / q + 0.5 * r * q cot2_delta_B = cot_delta_B * cot_delta_B expi_2delta_B = tf.complex(cot2_delta_B - 1, 2 * cot_delta_B) expi_2delta_B /= tf.cast(cot2_delta_B + 1, expi_2delta_B.dtype) ret = 1.0 / tf.complex(q * cot_delta_B, -q) ret = tf.cast(m, ret.dtype) * ret ret += (expi_2delta_B * BWR(m, mass, width, q, q0, 0, 1.0) * tf.cast(mass * width * mass / q0, ret.dtype)) return ret
def cal_monentum(m, ma, mb): mabp = ma + mb mabm = ma - mb s = m * m p2 = (s - mabp * mabp) * (s - mabm * mabm) / 4 / s zeros = tf.zeros_like(s) p_p = tf.complex(tf.sqrt(tf.abs(p2)), zeros) p_m = tf.complex(zeros, tf.sqrt(tf.abs(p2))) return tf.where(p2 > 0, p_p, p_m)
def interp(self, m): # q = data_extra[self.outs[0]]["|q|"] # a = self.a() p = self.point_value() zeros = tf.zeros_like(m) ones = tf.ones_like(m) def poly_i(i, xi): tmp = zeros for j in range(i - 1, i + 1): if j < 0 or j > self.interp_N - 1: continue r = ones for k in range(j, j + 2): if k == i: continue r = r * (m - xi[k]) / (xi[i] - xi[k]) r = tf.where((m >= xi[j]) & (m < xi[j + 1]), r, zeros) tmp = tmp + r return tmp h = tf.stack( [poly_i(i, self.points) for i in range(1, self.interp_N - 1)], axis=-1, ) h = tf.stop_gradient(h) p_r = tf.math.real(p) p_i = tf.math.imag(p) ret_r = tf.reduce_sum(h * p_r, axis=-1) ret_i = tf.reduce_sum(h * p_i, axis=-1) return tf.complex(ret_r, ret_i)
def get_amp(self, data, data_c=None, **kwargs): m = data["m"] mass1 = self.mass1() mass2 = self.mass2() width1 = self.width1() width2 = self.width2() q = data_c["|q|"] mdaughter1 = kwargs["all_data"]["particle"][self.decay[0].outs[0]]["m"] mdaughter2 = kwargs["all_data"]["particle"][self.decay[0].outs[1]]["m"] q1 = get_relative_p(mass1, mdaughter1, mdaughter2) q2 = get_relative_p(mass2, mdaughter1, mdaughter2) mlist = tf.stack([mass1, mass2]) wlist = tf.stack([width1, width2]) qlist = tf.stack([q1, q2]) Klist = [] for mi, wi, qi in zip(mlist, wlist, qlist): rw = Gamma(m, wi, q, qi, self.bw_l, mi, self.d) Klist.append(mi * rw / (mi**2 - m**2)) KK = tf.reduce_sum(Klist, axis=0) KK += self.alpha() beta_term = self.get_beta( m=m, mlist=mlist, wlist=wlist, q=q, qlist=qlist, Klist=Klist, **kwargs, ) MM = tf.complex(np.float64(1), -KK) MM = beta_term / MM return MM + self.KNR()
def interp(self, m): p = self.point_value() p_r = tf.math.real(p) p_i = tf.math.imag(p) idx = self.get_bin_index(m) idx = tf.clip_by_value(idx, 0, self.h_matrix.shape[1] - 1) ret_r = do_spline_hmatrix(self.h_matrix, p_r, m, idx) ret_i = do_spline_hmatrix(self.h_matrix, p_i, m, idx) return tf.complex(ret_r, ret_i)
def get_amp(self, *args, **kwargs): m = args[0]["m"] mass = self.get_mass() zeros = tf.zeros_like(m) delta_s = mass * mass - m * m m_c = mass / m rhos = [] for i, mab in enumerate(self.mass_list): ma, mb = mab pi = cal_monentum(m, ma, mb) # print(pi) m_rho_i = pi * tf.complex(zeros, self.g_value[i]() * m_c) rhos.append(m_rho_i) rho = sum(rhos) re = delta_s + tf.math.real(rho) im = tf.math.imag(rho) d = re * re + im * im ret = tf.complex(re / d, -im / d) return ret
def interp(self, m): zeros = tf.zeros_like(m) p = self.point_value() p_r = tf.math.real(p) p_i = tf.math.imag(p) xi_m = self.h_matrix x_m = spline_x_matrix(m, self.points) x_m = tf.expand_dims(x_m, axis=-1) m_xi = tf.reduce_sum(xi_m * x_m, axis=[-3, -2]) m_xi = tf.stop_gradient(m_xi) ret_r = tf.reduce_sum(tf.cast(m_xi, p_r.dtype) * p_r, axis=-1) ret_i = tf.reduce_sum(tf.cast(m_xi, p_i.dtype) * p_i, axis=-1) return tf.complex(ret_r, ret_i)
def interp(self, m): p = self.point_value() ones = tf.ones_like(m) zeros = tf.zeros_like(m) p_r = tf.math.real(p) p_i = tf.math.imag(p) h, b = get_matrix_interp1d3_v2(m, self.points) h = tf.stop_gradient(h) f = lambda x: tf.reshape( tf.matmul(tf.cast(h, x.dtype), tf.reshape(x, (-1, 1))), b.shape ) + tf.cast(b, x.dtype) ret_r = f(p_r) ret_i = f(p_i) return tf.complex(ret_r, ret_i)
def interp(self, m): # q = data_extra[self.outs[0]]["|q|"] # a = self.a() zeros = tf.zeros_like(m) p = tf.abs(self.point_value()) def add_f(x, bl, br, pl, pr): return tf.where( (x > bl) & (x <= br), (x - bl) / (br - bl) * (pr - pl) + pl, zeros, ) ret = [ add_f(m, self.points[i], self.points[i + 1], p[i], p[i + 1]) for i in range(self.interp_N - 1) ] return tf.complex(tf.reduce_sum(ret, axis=0), zeros)
def interp(self, m): zeros = tf.zeros_like(m) p = self.point_value() xs = [] def poly_i(i): x = 1.0 for j in range(self.interp_N): if i == j: continue x = (x * (m - self.points[j]) / (self.points[i] - self.points[j])) return x xs = tf.stack([poly_i(i) for i in range(self.interp_N)], axis=-1) zeros = tf.zeros_like(xs) xs = tf.complex(xs, zeros) ret = tf.reduce_sum(xs[:, 1:-1] * p, axis=-1) return ret
def get_ls_amp(self, data, data_p, **kwargs): amp = super(ParticleDecay, self).get_ls_amp(data, data_p, **kwargs) a = self.core b = self.outs[0] c = self.outs[1] mass = a.get_mass() width = a.get_width() m = data_p[a]["m"] if width is None: ret = tf.zeros_like(m) ret = tf.complex(ret, ret) elif not a.running_width: ret = tf.reshape(BW(m, mass, width), (-1, 1)) else: q = data["|q|"] q0 = data["|q0|"] ret = [] for i in self.get_l_list(): bw = BWR(m, mass, width, q, q0, i, self.d) ret.append(tf.reshape(bw, (-1, 1))) ret = tf.concat(ret, axis=-1) return ret * amp
def interp(self, m): p = self.point_value() ones = tf.ones_like(m) zeros = tf.zeros_like(m) def add_f(x, bl, br): return tf.where((x > bl) & (x <= br), ones, zeros) x_bin = tf.stack( [ add_f( m, (self.points[i] + self.points[i + 1]) / 2, (self.points[i + 1] + self.points[i + 2]) / 2, ) for i in range(self.interp_N - 2) ], axis=-1, ) p_r = tf.math.real(p) p_i = tf.math.imag(p) x_bin = tf.stop_gradient(x_bin) ret_r = tf.reduce_sum(x_bin * p_r, axis=-1) ret_i = tf.reduce_sum(x_bin * p_i, axis=-1) return tf.complex(ret_r, ret_i)
def interp(self, m): _, p_r, p_i = self.get_point_values() bin_idx = self.get_bin_index(m) ret_r = tf.gather(p_r[1:], bin_idx) ret_i = tf.gather(p_i[1:], bin_idx) return tf.complex(ret_r, ret_i)
def get_amp(self, data, _data_c=None, **kwargs): mass = data["m"] zeros = tf.zeros_like(mass) a = tf.abs(self.a()) return tf.complex(tf.exp(-a * mass), zeros)
def get_amp(self, data, _data_c=None, **kwargs): mass = data["m"] zeros = tf.zeros_like(mass) ones = tf.ones_like(mass) return tf.complex(ones, zeros)