jpacPhoto/amplitudes/vector_exchange.hpp

0001 // Axial-vector meson photoproduction proceeding through a vector meson exchange

0002 //

0003 // Author:       Daniel Winney (2020)

0004 // Affiliation:  Joint Physics Analysis Center (JPAC)

0005 // Email:        dwinney@iu.edu

0006 // ---------------------------------------------------------------------------

0007
0008 #ifndef _AXIAL_
0009 #define _AXIAL_
0010
0011 #include "amplitude.hpp"
0012 #include "regge_trajectory.hpp"
0013
0014 // ---------------------------------------------------------------------------

0015 // vector_exchange class describes the amplitude for a fixed-spin-1 exchange

0016 // in the t-channel. Derived in terms of simple feynman rules at tree level

0017 //

0018 // Initialization required a reaction_kinematics object, the mass of the exchange,

0019 // and an optional string to identify the amplitude with.

0020 //

0021 //  Evaluation requires three couplings photon coupling, gGamma, and vector/tensor

0022 // nucleon couplings, gV and gT respectively.

0023 //

0024 // Set couplings with amp.set_params({gGamma, gV, gT});

0025 // ---------------------------------------------------------------------------

0026
0027 namespace jpacPhoto
0028 {
0029     class vector_exchange : public amplitude
0030     {
0031         public:
0032
0033         // Constructor for fixed spin

0034         vector_exchange(reaction_kinematics * xkinem, double mass, std::string id = "vector_exchange")
0035         : amplitude(xkinem, id), _mEx2(mass*mass), _ifReggeized(false)
0036         {
0037             set_nParams(3);
0038             check_JP(xkinem->_jp);
0039
0040             // For scalar interaction only 4-vector eval implemented so far

0041             if (xkinem->_jp[0] == 0) _useCovariant = true;
0042         };
0043
0044         // Constructor for the reggized)

0045         vector_exchange(reaction_kinematics * xkinem, linear_trajectory * traj, std::string id = "vector_exchange")
0046         : amplitude(xkinem, id), _alpha(traj), _ifReggeized(true)
0047         {
0048             set_nParams(3);
0049             check_JP(xkinem->_jp);
0050
0051             if (xkinem->_jp[0] == 0)
0052             {
0053                 std::cout << "Error! Scalar production via Reggeized vector_exchange not yet implemented...\n";
0054                 exit(0);
0055             }
0056         };
0057
0058         // Setting utility

0059         inline void set_params(std::vector<double> params)
0060         {
0061             check_nParams(params); // make sure the right amout of params passed

0062             _gGam = params[0];
0063             _gV = params[1];
0064             _gT = params[2];
0065         };
0066
0067         // Whether or not to include an exponential form factor (default false)

0068         inline void set_formfactor(int FF, double bb = 0.)
0069         {
0070             _useFormFactor = FF;
0071             _cutoff = bb;
0072         }
0073
0074         // Assemble the helicity amplitude by contracting the lorentz indices

0075         std::complex<double> helicity_amplitude(std::array<int, 4> helicities, double s, double t);
0076
0077         // axial vector and scalar kinematics allowed

0078         inline std::vector<std::array<int,2>> allowedJP()
0079         {
0080             return {{1, 1}, {0, 1}, {0, -1}};
0081         };
0082
0083         private:
0084
0085         // if using reggeized propagator

0086         bool _ifReggeized;
0087         // or the regge trajectory of the exchange

0088         linear_trajectory * _alpha;
0089         double _zt;
0090
0091         // Whether using analytic or covariant expression

0092         bool _useCovariant = false;
0093
0094         // Form factor parameters

0095         int _useFormFactor = 0;
0096         double _cutoff = 0.;
0097         double form_factor();
0098
0099         // Couplings to the axial-vector/photon and vector/tensor couplings to nucleon

0100         double _gGam = 0., _gpGam = 0., _gV = 0., _gT = 0.;
0101
0102         // ---------------------------------------------------------------------------

0103         // Covariant evaluation

0104
0105         // Mass of the exchange

0106         double _mEx2 = 0.;
0107
0108         // Full covariant amplitude

0109         std::complex<double> covariant_amplitude(std::array<int, 4> helicities);
0110
0111         // Four-momentum of the exhange

0112         std::complex<double> exchange_momenta(int mu);
0113
0114         // Photon - Axial Vector - Vector vertex

0115         std::complex<double> top_vertex(int mu, int lam_gam, int lam_vec);
0116
0117         // Nucleon - Nucleon - Vector vertex

0118         std::complex<double> bottom_vertex(int nu, int lam_targ, int lam_rec);
0119
0120         // Photon field strength tensor

0121         std::complex<double> field_tensor(int mu, int nu, int lambda);
0122
0123         // Vector propogator

0124         std::complex<double> vector_propagator(int mu, int nu);
0125
0126         // ---------------------------------------------------------------------------

0127         // Analytic evaluation

0128
0129         // Photon - Axial - Vector

0130         std::complex<double> top_residue(int lam_gam, int lam_vec);
0131
0132         // Nucleon - Nucleon - Vector

0133         std::complex<double> bottom_residue(int lam_targ, int lam_rec);
0134
0135         // Reggeon propagator

0136         std::complex<double> regge_propagator(int j, int lam, int lamp);
0137
0138         // Half angle factors

0139         std::complex<double> half_angle_factor(int lam, int lamp);
0140
0141         // Angular momentum barrier factor

0142         std::complex<double> barrier_factor(int j, int M);
0143     };
0144 };
0145
0146 #endif