Computes the elements and structure functions of the hadron tensor $W^{\mu\nu}$ (using the conventions of the Valencia model) using precomputed tables. Is a concrete implementation of the HadronTensorI interface. More...

#include <TabulatedLabFrameHadronTensor.h>

Inheritance diagram for genie::TabulatedLabFrameHadronTensor:

Classes
class	TableEntry

Public Member Functions
	TabulatedLabFrameHadronTensor (const std::string &table_file_name)

virtual	~TabulatedLabFrameHadronTensor ()

virtual std::complex< double >	tt (double q0, double q_mag) const
	The tensor element $W^{00}$ . More...

virtual std::complex< double >	tz (double q0, double q_mag) const
	The tensor element $W^{0z}$ . More...

virtual std::complex< double >	xx (double q0, double q_mag) const
	The tensor element $W^{xx}$ . More...

virtual std::complex< double >	xy (double q0, double q_mag) const
	The tensor element $W^{xy}$ . More...

virtual std::complex< double >	zz (double q0, double q_mag) const
	The tensor element $W^{zz}$ . More...

virtual double	W1 (double q0, double q_mag, double Mi) const
	The structure function $W_1 = \frac{ W^{xx} }{ 2M_i }$ . More...

virtual double	W2 (double q0, double q_mag, double Mi) const

virtual double	W3 (double q0, double q_mag, double Mi) const

virtual double	W4 (double q0, double q_mag, double Mi) const

virtual double	W5 (double q0, double q_mag, double Mi) const

virtual double	W6 (double q0, double q_mag, double Mi) const

virtual double	dSigma_dT_dCosTheta (const Interaction *interaction, double Q_value) const

virtual double	dSigma_dT_dCosTheta (int probe_pdg, double E_probe, double m_probe, double Tl, double cos_l, double ml, double Q_value) const

virtual double	dSigma_dT_dCosTheta_rosenbluth (const Interaction *interaction, double Q_value) const

virtual double	dSigma_dT_dCosTheta_rosenbluth (int probe_pdg, double E_probe, double m_probe, double Tl, double cos_l, double ml, double Q_value) const

virtual double	q0Min () const

virtual double	q0Max () const

virtual double	qMagMin () const

virtual double	qMagMax () const

Public Member Functions inherited from genie::LabFrameHadronTensorI
virtual	~LabFrameHadronTensorI ()

virtual double	contraction (const Interaction *interaction, double Q_value) const

virtual double	contraction (int probe_pdg, double E_probe, double m_probe, double Tl, double cos_l, double ml, double Q_value) const

virtual std::complex< double >	tx (double, double) const
	The tensor element $W^{0x}$ . More...

virtual std::complex< double >	ty (double, double) const
	The tensor element $W^{0y}$ . More...

virtual std::complex< double >	xt (double q0, double q_mag) const
	The tensor element $W^{x0} = (W^{0x})^*$ . More...

virtual std::complex< double >	xz (double, double) const
	The tensor element $W^{xz}$ . More...

virtual std::complex< double >	yt (double q0, double q_mag) const
	The tensor element $W^{y0} = (W^{0y})^*$ . More...

virtual std::complex< double >	yx (double q0, double q_mag) const
	The tensor element $W^{yx} = (W^{xy})^*$ . More...

virtual std::complex< double >	yy (double q0, double q_mag) const
	The tensor element $W^{yy}$ . More...

virtual std::complex< double >	yz (double, double) const
	The tensor element $W^{yz}$ . More...

virtual std::complex< double >	zt (double q0, double q_mag) const
	The tensor element $W^{z0} = (W^{0z})^*$ . More...

virtual std::complex< double >	zx (double q0, double q_mag) const
	The tensor element $W^{zx} = (W^{xz})^*$ . More...

virtual std::complex< double >	zy (double q0, double q_mag) const
	The tensor element $W^{zy} = (W^{yz})^*$ . More...

Public Member Functions inherited from genie::HadronTensorI
virtual	~HadronTensorI ()

int	pdg () const
	PDG code of the target nucleus. More...

int	Z () const
	Atomic number of the target nucleus. More...

int	A () const
	Mass number of the target nucleus. More...

void	set_pdg (int pdg)
	Set the target nucleus PDG code. More...

Protected Member Functions

void read1DGridValues (int num_points, int flag, std::ifstream &in_file, std::vector< double > &vec_to_fill)

Structure function helpers

These helper functions allow multiple structure function values (e.g., $W_1$ and $W_2$ ) to be computed without having to perform bilinear interpolation every time.

Because the differential cross section $\frac{ d^2\sigma_{\nu l} } { d\cos(\theta^\prime) dE^\prime_l }$ does not depend on the initial nucleus's mass $M_i$ , the explicit factors of $M_i$ have been removed from these internally-used functions.

Parameters

[in] Hadronic tensor table entry that has been pre-interpolated

virtual double W1 (double q0, double q_mag, const TableEntry &entry) const

virtual double W2 (double q0, double q_mag, const TableEntry &entry) const

virtual double W3 (double q0, double q_mag, const TableEntry &entry) const

virtual double W4 (double q0, double q_mag, const TableEntry &entry) const

virtual double W5 (double q0, double q_mag, const TableEntry &entry) const

virtual double W6 (double q0, double q_mag, const TableEntry &entry) const

Protected Member Functions inherited from genie::LabFrameHadronTensorI

LabFrameHadronTensorI (int pdg=0)

LabFrameHadronTensorI (int Z, int A)

Protected Member Functions inherited from genie::HadronTensorI

HadronTensorI (int pdg=0)

HadronTensorI (int Z, int A)

PDG code for the target nucleus represented by the tensor. More...

Protected Attributes
std::vector< double >	fq0Points

std::vector< double >	fqmagPoints

std::vector< TableEntry >	fEntries

BLI2DNonUnifObjectGrid< TableEntry >	fGrid

Protected Attributes inherited from genie::HadronTensorI
int	fTargetPDG

Detailed Description

Computes the elements and structure functions of the hadron tensor $W^{\mu\nu}$ (using the conventions of the Valencia model) using precomputed tables. Is a concrete implementation of the HadronTensorI interface.

Author: Steven Gardiner <gardiner fnal.gov> Fermi National Accelerator Laboratory

August 23, 2018

Definition at line 34 of file TabulatedLabFrameHadronTensor.h.

Constructor & Destructor Documentation

genie::TabulatedLabFrameHadronTensor::TabulatedLabFrameHadronTensor ( const std::string & table_file_name )

Todo:: Add error checks

Todo:: Use type name

Definition at line 36 of file TabulatedLabFrameHadronTensor.cxx.

   : fGrid(&fq0Points, &fqmagPoints, &fEntries)
 {
   // Read in the table
   std::ifstream in_file( table_file_name.c_str() );
 
 
   // Skip the initial comment line
   std::string dummy;
   std::getline(in_file, dummy);
 
   /// \todo Add error checks
   std::string type_name;
   int Z, A, num_q0, num_q_mag;
 
   /// \todo Use type name
   in_file >> Z >> A >> type_name >> num_q0 >> num_q_mag;
 
   int q0_flag;
   in_file >> q0_flag;
   read1DGridValues(num_q0, q0_flag, in_file, fq0Points);
 
   int q_mag_flag;
   in_file >> q_mag_flag;
   read1DGridValues(num_q_mag, q_mag_flag, in_file, fqmagPoints);
 
   set_pdg( genie::pdg::IonPdgCode(A, Z) );
 
   std::cout<< "TabulatedLabFrameHadronTensor: reading hadron tensor table" << std::endl;
   std::cout<< "table_file_name:  " << table_file_name << std::endl;
   std::cout<< "Z:                " << Z << std::endl;
   std::cout<< "A:                " << A << std::endl;
   std::cout<< "num_q0:           " << num_q0 << std::endl;
   std::cout<< "num_q_mag:        " << num_q_mag << std::endl;
 
   double W00, ReW0z, Wxx, ImWxy, Wzz;
   int lineCount=1;
 
   for (long j = 0; j < num_q0; ++j) {
     for (long k = 0; k < num_q_mag; ++k) {
 
       fEntries.push_back( TableEntry() );
       TableEntry& entry = fEntries.back();
 
       // in_file >> entry.W00 >> entry.ReW0z >> entry.Wxx
       //   >> entry.ImWxy >> entry.Wzz;
 
       in_file >> W00 >> ReW0z >> Wxx >> ImWxy >> Wzz;
 
       entry.W00  = W00;
       entry.ReW0z= ReW0z;
       entry.Wxx  = Wxx;
       entry.ImWxy= ImWxy;
       entry.Wzz  = Wzz;
 
       //if(W00 > 0.0) {
       //  std::cout<< "line count is" << lineCount << std::endl;
       //  std::cout<< "Entry: " << entry.W00 << " " << entry.ReW0z << " " << entry.Wxx << " " << entry.ImWxy << " " << entry.Wzz << std::endl;
       //  std::cout<< "File:  " << W00 << " " << ReW0z << " " << Wxx << " " << ImWxy << " " << Wzz << std::endl;
       //}
       lineCount++;
     }
   }
 }

genie::TabulatedLabFrameHadronTensor::~TabulatedLabFrameHadronTensor ( )

virtual

Definition at line 102 of file TabulatedLabFrameHadronTensor.cxx.

103 {

104 }

Member Function Documentation

double genie::TabulatedLabFrameHadronTensor::dSigma_dT_dCosTheta	(	const Interaction *	interaction,
		double	Q_value
	)		const

virtual

Computes the differential cross section $\frac{ d^2\sigma } { dT_\ell d\cos(\theta^\prime) }$ for the reaction represented by this hadron tensor

Parameters

[in]	interaction	An Interaction object storing information about the initial and final states
[in]	Q_value	The Q-value that should be used to correct the energy transfer (GeV)

Returns: The differential cross section (GeV^-3)

Implements genie::LabFrameHadronTensorI.

Definition at line 256 of file TabulatedLabFrameHadronTensor.cxx.

 {
   // Don't do anything if you've been handed a nullptr
   if ( !interaction ) return 0.;
 
   int probe_pdg     = interaction->InitState().ProbePdg();
   double E_probe    = interaction->InitState().ProbeE(kRfLab);
   double m_probe    = interaction->InitState().Probe()->Mass();
   double Tl      = interaction->Kine().GetKV(kKVTl);
   double cos_l   = interaction->Kine().GetKV(kKVctl);
   double ml      = interaction->FSPrimLepton()->Mass();
 
   return dSigma_dT_dCosTheta(probe_pdg, E_probe, m_probe, Tl, cos_l, ml,
     Q_value);
 }

double genie::TabulatedLabFrameHadronTensor::dSigma_dT_dCosTheta	(	int	probe_pdg,
		double	E_probe,
		double	m_probe,
		double	Tl,
		double	cos_l,
		double	ml,
		double	Q_value
	)		const

virtual

Parameters

[in]	probe_pdg	The PDG code for the incident projectile
[in]	E_probe	The lab frame energy of the incident projectile (GeV)
[in]	m_probe	The mass of the incident projectile (GeV)
[in]	Tl	The lab frame kinetic energy of the final state lepton (GeV)
[in]	cos_l	The angle between the direction of the incident neutrino and the final state lepton (radians)
[in]	ml	The mass of the final state lepton (GeV)
[in]	Q_value	The Q-value that should be used to correct the energy transfer (GeV)

Returns: The differential cross section (GeV^-3)

Todo:: Add check if in grid. If not, return 0

Todo:: Add any needed changes for positron projectiles

Implements genie::LabFrameHadronTensorI.

Definition at line 273 of file TabulatedLabFrameHadronTensor.cxx.

 {
   // dSigma_dT_dCosTheta in GeV^(-3)
   double xsec = 0.;
 
   /// \todo Add check if in grid. If not, return 0
 
   // Final state lepton total energy
   double El = Tl + ml;
 
   // Energy transfer (uncorrected)
   double q0 = E_probe - El;
 
   // The corrected energy transfer takes into account the binding
   // energy of the struck nucleon(s)
   double q0_corrected = q0 - Q_value;
 
   // Magnitude of the initial state lepton 3-momentum
   double k_initial = real_sqrt( std::pow(E_probe, 2) - std::pow(m_probe, 2) );
 
   // Magnitude of the final state lepton 3-momentum
   double k_final = real_sqrt( std::pow(Tl, 2) + 2*ml*Tl );
 
   // Magnitude of the 3-momentum transfer
   double q_mag2 = std::pow(k_initial, 2) + std::pow(k_final, 2)
     - 2.*k_initial*k_final*cos_l;
   double q_mag = real_sqrt( q_mag2 );
 
   // Find the appropriate values of the hadron tensor elements for the
   // given combination of q0_corrected and q_mag
   TableEntry entry = fGrid.interpolate(q0_corrected, q_mag);
 
   // The half-angle formulas come in handy here. See, e.g.,
   // http://mathworld.wolfram.com/Half-AngleFormulas.html
   double s2_half = (1. - cos_l) / 2.; // sin^2(theta/2) = (1 - cos(theta)) / 2
   double c2_half = 1. - s2_half; // cos^2(theta / 2) = 1 - sin^2(theta / 2)
 
   // Calculate a nonzero cross section only for incident (anti)electrons
   // or (anti)neutrinos
   int abs_probe_pdg = std::abs(probe_pdg);
 
   /// \todo Add any needed changes for positron projectiles
   if ( probe_pdg == genie::kPdgElectron ) {
     // (e,e') differential cross section
 
     double q2 = std::pow(q0, 2) - q_mag2;
 
     double mott = std::pow(
       genie::constants::kAem / (2. * E_probe * s2_half), 2) * c2_half;
 
     // Longitudinal part
     double l_part = std::pow(q2 / q_mag2, 2) * entry.W00;
 
     // Transverse part
     double t_part = ( (2. * s2_half / c2_half) - (q2 / q_mag2) ) * entry.Wxx;
 
     xsec = (2. * genie::constants::kPi) * mott * (l_part + t_part);
   }
   else if ( abs_probe_pdg == genie::kPdgNuE
     || abs_probe_pdg == genie::kPdgNuMu
     || abs_probe_pdg == genie::kPdgNuTau )
   {
     // Simplify the expressions below by pre-computing the structure functions
     double w1 = this->W1(q0, q_mag, entry);
     double w2 = this->W2(q0, q_mag, entry);
     double w4 = this->W4(q0, q_mag, entry);
     double w5 = this->W5(q0, q_mag, entry);
 
     // Flip the sign of the terms proportional to W3 for antineutrinos
     double w3 = this->W3(q0, q_mag, entry);
     if (probe_pdg < 0) w3 *= -1;
 
     double part_1 = (2. * w1 * s2_half) + (w2 * c2_half)
       - (w3 * (E_probe + El) * s2_half);
 
     double part_2 = (w1 * cos_l) - (w2/2. * cos_l)
       + (w3/2. * (El + k_final - (E_probe + El)*cos_l))
       + (w4/2. * (std::pow(ml, 2)*cos_l + 2*El*(El + k_final)*s2_half))
       - (w5/2. * (El + k_final));
 
     double all_terms = part_1 + std::pow(ml, 2)
       * part_2 / (El * (El + k_final));
 
     xsec = (2. / genie::constants::kPi) * k_final * El
       * genie::constants::kGF2 * all_terms;
   }
 
   return xsec;
 }

double genie::TabulatedLabFrameHadronTensor::dSigma_dT_dCosTheta_rosenbluth	(	const Interaction *	interaction,
		double	Q_value
	)		const

virtual

Implements genie::LabFrameHadronTensorI.

Definition at line 365 of file TabulatedLabFrameHadronTensor.cxx.

 {
   // Don't do anything if you've been handed a nullptr
   if ( !interaction ) return 0.;
 
   int probe_pdg     = interaction->InitState().ProbePdg();
   double E_probe    = interaction->InitState().ProbeE(kRfLab);
   double m_probe    = interaction->InitState().Probe()->Mass();
   double Tl      = interaction->Kine().GetKV(kKVTl);
   double cos_l   = interaction->Kine().GetKV(kKVctl);
   double ml      = interaction->FSPrimLepton()->Mass();
 
   return dSigma_dT_dCosTheta_rosenbluth(probe_pdg, E_probe, m_probe, Tl, cos_l, ml,
     Q_value);
 }

double genie::TabulatedLabFrameHadronTensor::dSigma_dT_dCosTheta_rosenbluth	(	int	probe_pdg,
		double	E_probe,
		double	m_probe,
		double	Tl,
		double	cos_l,
		double	ml,
		double	Q_value
	)		const

virtual

Todo:: Add check if in grid. If not, return 0

Todo:: Add any needed changes for positron projectiles

Implements genie::LabFrameHadronTensorI.

Definition at line 382 of file TabulatedLabFrameHadronTensor.cxx.

 {
   // dSigma_dT_dCosTheta in GeV^(-3)
   double xsec = 0.;
 
   /// \todo Add check if in grid. If not, return 0
 
   // Final state lepton total energy
   double El = Tl + ml;
 
   // Energy transfer (uncorrected)
   double q0 = E_probe - El;
 
   // The corrected energy transfer takes into account the binding
   // energy of the struck nucleon(s)
   double q0_corrected = q0 - Q_value;
 
   // Magnitude of the initial state lepton 3-momentum
   double k_initial = real_sqrt( std::pow(E_probe, 2) - std::pow(m_probe, 2) );
 
   // Magnitude of the final state lepton 3-momentum
   double k_final = real_sqrt( std::pow(Tl, 2) + 2*ml*Tl );
 
   // Magnitude of the 3-momentum transfer
   double q_mag2 = std::pow(k_initial, 2) + std::pow(k_final, 2)
     - 2.*k_initial*k_final*cos_l;
   double q_mag = real_sqrt( q_mag2 );
 
   // Find the appropriate values of the hadron tensor elements for the
   // given combination of q0_corrected and q_mag
   TableEntry entry = fGrid.interpolate(q0_corrected, q_mag);
 
   // The half-angle formulas come in handy here. See, e.g.,
   // http://mathworld.wolfram.com/Half-AngleFormulas.html
   double s2_half = (1. - cos_l) / 2.; // sin^2(theta/2) = (1 - cos(theta)) / 2
   double c2_half = 1. - s2_half; // cos^2(theta / 2) = 1 - sin^2(theta / 2)
 
   // Calculate a nonzero cross section only for incident (anti)electrons
   // or (anti)neutrinos
   int abs_probe_pdg = std::abs(probe_pdg);
 
   // This Q^2 is defined as negative (Q^2<0)
   double q2 = std::pow(q0, 2) - q_mag2;
 
   /// \todo Add any needed changes for positron projectiles
   if ( probe_pdg == genie::kPdgElectron ) {
     // (e,e') differential cross section
 
     //   double mott = std::pow(
     //   genie::constants::kAem / (2. * E_probe * s2_half), 2) * c2_half;
     // the previous expression was an approximation in the case of ml-->0 (UR limit).
     // To be more accurate, SIGMA_MOTT SHOULD BE EXPRESSED AS:
     double mott = std::pow(2.*El*genie::constants::kAem / q2, 2) * c2_half;
     // ALTHOUGH THE DIFFERENCES SHOULD BE VERY SMALL OR NEGLIGIBLE
 
     // Longitudinal part
     double l_part = std::pow(q2 / q_mag2, 2) * entry.W00;
 
     // Transverse part
     double t_part = ( (2.*s2_half / c2_half) - (q2 / q_mag2) ) * entry.Wxx;
 
     // This is the double diff cross section dsigma/dOmega/domega==dsigma/dOmega/dEl
 
     //xsec = (2. * genie::constants::kPi) * mott * (l_part + t_part);
 
     //Bug in HT means we Wxx is off by factor of 2
     xsec = (2. * genie::constants::kPi) * mott * (l_part + t_part/2.);
   }
   else if ( abs_probe_pdg == genie::kPdgNuE
     || abs_probe_pdg == genie::kPdgNuMu
     || abs_probe_pdg == genie::kPdgNuTau )
   {
 
     // sigma_0 (sig0) for neutrinos. Similar to sigma_mott for electrons
     double v0=4.*El*E_probe+q2; // global factor v_0==cos^2(\tilde\theta/2)
 
     // CKM matrix element connecting the up and down quarks
     const genie::Registry* temp_reg = genie::AlgConfigPool::Instance()
       ->CommonList("Param", "CKM");
     double Vud = temp_reg->GetDouble( "CKM-Vud" );
 
     double Vud2 = std::pow(Vud, 2);
     double sig0 = genie::constants::kGF2 * Vud2 * v0 * k_final
       / (4. * genie::constants::kPi *  E_probe);
 
     // Definition of dimensionless factors
     double xdelta=ml/sqrt(-q2); // delta
     double xrho=-q2/q_mag2;
     double xrhop=q_mag/(El+E_probe);
     double tan2th2=-q2/v0;
 
     // Definition of the lepton kinematic factors, V_K, related to the lepton tensor
     double VCC=1-std::pow(xdelta, 2)*tan2th2;
     double VCL=q0/q_mag+tan2th2*std::pow(xdelta, 2)/xrhop;
     double VLL=std::pow(q0, 2)/q_mag2+std::pow(xdelta, 2)*tan2th2*(1.+2.*q0/q_mag/xrhop+xrho*std::pow(xdelta, 2));
     double VT=xrho/2.+tan2th2-tan2th2*std::pow(xdelta, 2)/xrhop*(q0/q_mag+std::pow(xdelta, 2)*xrho*xrhop/2.);
     double VTP=tan2th2/xrhop*(1-q0/q_mag*xrhop*std::pow(xdelta, 2));
 
     // Definition of the hadron (nuclear) response functions, R_K, related to the hadron (nuclear) tensor, Wij.
 
     double RCC=entry.W00;
     double RCL=-entry.ReW0z; // RCL must be always negative
     double RLL=entry.Wzz;
     double RT=2.*entry.Wxx;
     double RTP=-entry.ImWxy; // RTP must be positive for nu and negative for nubar
     if (probe_pdg < 0) RTP *= -1; // THIS IS FOR NUBAR
 
 
     // Determination of the double differential cross section: dsigma/dcostheta_ldEl.
     // In order to calculate dsigma/dcostheta_ldp_l, the c.s. must be multiplied by
     // k_final/El
     xsec= sig0*(VCC*RCC+2.*VCL*RCL+VLL*RLL+VT*RT+2.*VTP*RTP);
 
 
     // This should never happen using the full SuSAv2-MEC hadron tensors
     // but can trigger when using the tensors from the parameterisation
     if ( xsec < 0 ) {
       xsec=0.;
     }
   }
 
   return xsec;
 }

virtual double genie::TabulatedLabFrameHadronTensor::q0Max ( ) const

inlinevirtual

The maximum value of the energy transfer $q^0$ for which this hadron tensor may be used to compute cross sections

Implements genie::HadronTensorI.

Definition at line 77 of file TabulatedLabFrameHadronTensor.h.

77 { return fGrid.x_max(); }

genie::TabulatedLabFrameHadronTensor::fGrid

BLI2DNonUnifObjectGrid< TableEntry > fGrid

Definition: TabulatedLabFrameHadronTensor.h:207

virtual double genie::TabulatedLabFrameHadronTensor::q0Min ( ) const

inlinevirtual

The minimum value of the energy transfer $q^0$ for which this hadron tensor may be used to compute cross sections

Implements genie::HadronTensorI.

Definition at line 76 of file TabulatedLabFrameHadronTensor.h.

76 { return fGrid.x_min(); }

genie::TabulatedLabFrameHadronTensor::fGrid

BLI2DNonUnifObjectGrid< TableEntry > fGrid

Definition: TabulatedLabFrameHadronTensor.h:207

virtual double genie::TabulatedLabFrameHadronTensor::qMagMax ( ) const

inlinevirtual

The maximum value of the magnitude of the 3-momentum transfer $\left|\overrightarrow{q}\right|$ for which this hadron tensor may be used to compute cross sections

Implements genie::HadronTensorI.

Definition at line 79 of file TabulatedLabFrameHadronTensor.h.

79 { return fGrid.y_max(); }

genie::TabulatedLabFrameHadronTensor::fGrid

BLI2DNonUnifObjectGrid< TableEntry > fGrid

Definition: TabulatedLabFrameHadronTensor.h:207

virtual double genie::TabulatedLabFrameHadronTensor::qMagMin ( ) const

inlinevirtual

The minimum value of the magnitude of the 3-momentum transfer $\left|\overrightarrow{q}\right|$ for which this hadron tensor may be used to compute cross sections

Implements genie::HadronTensorI.

Definition at line 78 of file TabulatedLabFrameHadronTensor.h.

78 { return fGrid.y_min(); }

genie::TabulatedLabFrameHadronTensor::fGrid

BLI2DNonUnifObjectGrid< TableEntry > fGrid

Definition: TabulatedLabFrameHadronTensor.h:207

void genie::TabulatedLabFrameHadronTensor::read1DGridValues	(	int	num_points,
		int	flag,
		std::ifstream &	in_file,
		std::vector< double > &	vec_to_fill
	)

protected

Helper function that allows this class to handle variations in the data file format for the 1D $q_0$ and $\left|\overrightarrow{q}\right|$ grids

Parameters

[in]	num_points	The number of grid points to be read from the file
[in]	flag	A numerical flag describing the grid data format
[in,out]	in_file	A reference to the file being read
[out]	vec_to_fill	The vector that will store the grid points

Definition at line 187 of file TabulatedLabFrameHadronTensor.cxx.

 {
   vec_to_fill.clear();
 
   if (flag >= kHadronTensorGridFlag_COUNT) {
     LOG("TabulatedLabFrameHadronTensor", pERROR)
       << "Invalid hadron tensor grid flag value \"" << flag
       << "\" encountered.";
     return;
   }
   else if (flag == kStartAndStep) {
     double start_val, step;
     in_file >> start_val >> step;
     for (int k = 0; k < num_points; ++k)
       vec_to_fill.push_back( start_val + (k * step) );
   }
   else if (flag == kExplicitValues) {
     double val;
     for (int k = 0; k < num_points; ++k) {
       in_file >> val;
       vec_to_fill.push_back( val );
     }
   }
 
 }

std::complex< double > genie::TabulatedLabFrameHadronTensor::tt	(	double	q0,
		double	q_mag
	)		const

virtual

The tensor element $W^{00}$ .

Implements genie::HadronTensorI.

Definition at line 106 of file TabulatedLabFrameHadronTensor.cxx.

 {
   TableEntry entry = fGrid.interpolate(q0, q_mag);
   return std::complex<double>(entry.W00, 0.);
 }

std::complex< double > genie::TabulatedLabFrameHadronTensor::tz	(	double	q0,
		double	q_mag
	)		const

virtual

The tensor element $W^{0z}$ .

Todo:: Think about adding the imaginary part even though it's not needed for the cross section calculation

Implements genie::HadronTensorI.

Definition at line 113 of file TabulatedLabFrameHadronTensor.cxx.

 {
   TableEntry entry = fGrid.interpolate(q0, q_mag);
   // Currently only the real part of W0z is tabulated
   /// \todo Think about adding the imaginary part even though it's not needed
   /// for the cross section calculation
   return std::complex<double>(entry.ReW0z, 0.);
 }

double genie::TabulatedLabFrameHadronTensor::W1	(	double	q0,
		double	q_mag,
		double	Mi
	)		const

virtual

The structure function $W_1 = \frac{ W^{xx} }{ 2M_i }$ .

Implements genie::LabFrameHadronTensorI.

Definition at line 146 of file TabulatedLabFrameHadronTensor.cxx.

 {
   TableEntry entry = fGrid.interpolate(q0, q_mag);
   return W1(q0, q_mag, entry) / Mi;
 }

double genie::TabulatedLabFrameHadronTensor::W1	(	double	q0,
		double	q_mag,
		const TableEntry &	entry
	)		const

protectedvirtual

Definition at line 214 of file TabulatedLabFrameHadronTensor.cxx.

 {
   return entry.Wxx / 2.;
 }

double genie::TabulatedLabFrameHadronTensor::W2	(	double	q0,
		double	q_mag,
		double	Mi
	)		const

virtual

The structure function $W_2 = \frac{ 1 }{ 2M_i } \left( W^{00} + W^{xx} + \frac{ (q^0)^2 } { \left|\overrightarrow{q}\right|^2 } ( W^{zz} - W^{xx} ) - 2\frac{ q^0 }{ \left|\overrightarrow{q}\right| }\Re W^{0z} \right)$

Implements genie::LabFrameHadronTensorI.

Definition at line 153 of file TabulatedLabFrameHadronTensor.cxx.

 {
   TableEntry entry = fGrid.interpolate(q0, q_mag);
   return W2(q0, q_mag, entry) / Mi;
 }

double genie::TabulatedLabFrameHadronTensor::W2	(	double	q0,
		double	q_mag,
		const TableEntry &	entry
	)		const

protectedvirtual

Definition at line 220 of file TabulatedLabFrameHadronTensor.cxx.

 {
   double temp_1 = ( std::pow(q0, 2) / std::pow(q_mag, 2) )
     * (entry.Wzz - entry.Wxx);
   double temp_2 = 2. * q0 * entry.ReW0z / q_mag;
   return ( entry.W00 + entry.Wxx + temp_1 - temp_2 ) / 2.;
 }

double genie::TabulatedLabFrameHadronTensor::W3	(	double	q0,
		double	q_mag,
		double	Mi
	)		const

virtual

The structure function $W_3 = -i \frac{ W^{xy} } { \left|\overrightarrow{q}\right| }$

Implements genie::LabFrameHadronTensorI.

Definition at line 160 of file TabulatedLabFrameHadronTensor.cxx.

 {
   TableEntry entry = fGrid.interpolate(q0, q_mag);
   return W3(q0, q_mag, entry);
 }

double genie::TabulatedLabFrameHadronTensor::W3	(	double	q0,
		double	q_mag,
		const TableEntry &	entry
	)		const

protectedvirtual

Definition at line 229 of file TabulatedLabFrameHadronTensor.cxx.

 {
   return ( entry.ImWxy / q_mag );
 }

double genie::TabulatedLabFrameHadronTensor::W4	(	double	q0,
		double	q_mag,
		double	Mi
	)		const

virtual

The structure function $W_4 = \frac{ M_i } { 2 \left|\overrightarrow{q}\right|^2 } ( W^{zz} - W^{xx} )$

Implements genie::LabFrameHadronTensorI.

Definition at line 167 of file TabulatedLabFrameHadronTensor.cxx.

 {
   TableEntry entry = fGrid.interpolate(q0, q_mag);
   return W4(q0, q_mag, entry) * Mi;
 }

double genie::TabulatedLabFrameHadronTensor::W4	(	double	q0,
		double	q_mag,
		const TableEntry &	entry
	)		const

protectedvirtual

Definition at line 235 of file TabulatedLabFrameHadronTensor.cxx.

 {
   return ( entry.Wzz - entry.Wxx ) / ( 2. * std::pow(q_mag, 2) );
 }

double genie::TabulatedLabFrameHadronTensor::W5	(	double	q0,
		double	q_mag,
		double	Mi
	)		const

virtual

The structure function $W_5 = \frac{ 1 } { \left|\overrightarrow{q}\right| } \left( \Re W^{0z} - \frac{ q^0 }{ \left|\overrightarrow{q}\right| } ( W^{zz} - W^{xx} ) \right)$

Implements genie::LabFrameHadronTensorI.

Definition at line 174 of file TabulatedLabFrameHadronTensor.cxx.

 {
   TableEntry entry = fGrid.interpolate(q0, q_mag);
   return W5(q0, q_mag, entry);
 }

double genie::TabulatedLabFrameHadronTensor::W5	(	double	q0,
		double	q_mag,
		const TableEntry &	entry
	)		const

protectedvirtual

Definition at line 241 of file TabulatedLabFrameHadronTensor.cxx.

 {
   return ( entry.ReW0z - q0 * (entry.Wzz - entry.Wxx) / q_mag ) / q_mag;
 }

double genie::TabulatedLabFrameHadronTensor::W6	(	double	q0,
		double	q_mag,
		double	Mi
	)		const

virtual

The structure function $W_6 = \frac{ \Im W^{0z} } { \left|\overrightarrow{q}\right| }$

Implements genie::LabFrameHadronTensorI.

Definition at line 181 of file TabulatedLabFrameHadronTensor.cxx.

 {
   return 0.;
 }

double genie::TabulatedLabFrameHadronTensor::W6	(	double	q0,
		double	q_mag,
		const TableEntry &	entry
	)		const

protectedvirtual

Definition at line 247 of file TabulatedLabFrameHadronTensor.cxx.

 {
   // Currently, \Im W^{0z} has not been tabulated, so we can't really
   // evaluate W6. This isn't a huge problem, however, because W6 doesn't
   // contribute to neutrino cross sections.
   return 0.;
 }

std::complex< double > genie::TabulatedLabFrameHadronTensor::xx	(	double	q0,
		double	q_mag
	)		const

virtual

The tensor element $W^{xx}$ .

Implements genie::HadronTensorI.

Definition at line 123 of file TabulatedLabFrameHadronTensor.cxx.

 {
   TableEntry entry = fGrid.interpolate(q0, q_mag);
   return std::complex<double>(entry.Wxx, 0.);
 }

std::complex< double > genie::TabulatedLabFrameHadronTensor::xy	(	double	q0,
		double	q_mag
	)		const

virtual

The tensor element $W^{xy}$ .

Implements genie::HadronTensorI.

Definition at line 130 of file TabulatedLabFrameHadronTensor.cxx.

 {
   TableEntry entry = fGrid.interpolate(q0, q_mag);
   // The Wxy element is purely imaginary
   return std::complex<double>(0., entry.ImWxy);
 }

std::complex< double > genie::TabulatedLabFrameHadronTensor::zz	(	double	q0,
		double	q_mag
	)		const

virtual

The tensor element $W^{zz}$ .

Implements genie::HadronTensorI.

Definition at line 138 of file TabulatedLabFrameHadronTensor.cxx.

 {
   TableEntry entry = fGrid.interpolate(q0, q_mag);
   // The Wxy element is purely imaginary
   return std::complex<double>(entry.Wzz, 0.);
 }

Member Data Documentation

std::vector<TableEntry> genie::TabulatedLabFrameHadronTensor::fEntries

protected

Definition at line 205 of file TabulatedLabFrameHadronTensor.h.

BLI2DNonUnifObjectGrid<TableEntry> genie::TabulatedLabFrameHadronTensor::fGrid

protected

Definition at line 207 of file TabulatedLabFrameHadronTensor.h.

std::vector<double> genie::TabulatedLabFrameHadronTensor::fq0Points

protected

Definition at line 203 of file TabulatedLabFrameHadronTensor.h.

std::vector<double> genie::TabulatedLabFrameHadronTensor::fqmagPoints

protected

Definition at line 204 of file TabulatedLabFrameHadronTensor.h.

The documentation for this class was generated from the following files:

Generator/src/Physics/HadronTensors/TabulatedLabFrameHadronTensor.h
Generator/src/Physics/HadronTensors/TabulatedLabFrameHadronTensor.cxx

Classes

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation