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:

[legend]

Collaboration diagram for genie::TabulatedLabFrameHadronTensor:

[legend]

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}$ .
virtual std::complex< double >	tz (double q0, double q_mag) const
	The tensor element $W^{0z}$ .
virtual std::complex< double >	xx (double q0, double q_mag) const
	The tensor element $W^{xx}$ .
virtual std::complex< double >	xy (double q0, double q_mag) const
	The tensor element $W^{xy}$ .
virtual std::complex< double >	zz (double q0, double q_mag) const
	The tensor element $W^{zz}$ .
virtual double	W1 (double q0, double q_mag, double Mi) const
	The structure function $W_1 = \frac{ W^{xx} }{ 2M_i }$ .
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}$ .
virtual std::complex< double >	ty (double, double) const
	The tensor element $W^{0y}$ .
virtual std::complex< double >	xt (double q0, double q_mag) const
	The tensor element $W^{x0} = (W^{0x})^*$ .
virtual std::complex< double >	xz (double, double) const
	The tensor element $W^{xz}$ .
virtual std::complex< double >	yt (double q0, double q_mag) const
	The tensor element $W^{y0} = (W^{0y})^*$ .
virtual std::complex< double >	yx (double q0, double q_mag) const
	The tensor element $W^{yx} = (W^{xy})^*$ .
virtual std::complex< double >	yy (double q0, double q_mag) const
	The tensor element $W^{yy}$ .
virtual std::complex< double >	yz (double, double) const
	The tensor element $W^{yz}$ .
virtual std::complex< double >	zt (double q0, double q_mag) const
	The tensor element $W^{z0} = (W^{0z})^*$ .
virtual std::complex< double >	zx (double q0, double q_mag) const
	The tensor element $W^{zx} = (W^{xz})^*$ .
virtual std::complex< double >	zy (double q0, double q_mag) const
	The tensor element $W^{zy} = (W^{yz})^*$ .
Public Member Functions inherited from genie::HadronTensorI
virtual	~HadronTensorI ()
int	pdg () const
	PDG code of the target nucleus.
int	Z () const
	Atomic number of the target nucleus.
int	A () const
	Mass number of the target nucleus.
void	set_pdg (int pdg)
	Set the target nucleus PDG code.

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.

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 \at fnal.gov> Fermi National Accelerator Laboratory

Created:\n August 23, 2018

License:\n Copyright (c) 2003-2025, The GENIE Collaboration: For the full text of the license visit http://copyright.genie-mc.org or see $GENIE/LICENSE

Definition at line 34 of file TabulatedLabFrameHadronTensor.h.

Constructor & Destructor Documentation

◆ TabulatedLabFrameHadronTensor()

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++;
    }
  }
}

References genie::HadronTensorI::A(), fEntries, fGrid, fq0Points, fqmagPoints, genie::TabulatedLabFrameHadronTensor::TableEntry::ImWxy, genie::pdg::IonPdgCode(), read1DGridValues(), genie::TabulatedLabFrameHadronTensor::TableEntry::ReW0z, genie::HadronTensorI::set_pdg(), genie::TabulatedLabFrameHadronTensor::TableEntry::W00, genie::TabulatedLabFrameHadronTensor::TableEntry::Wxx, genie::TabulatedLabFrameHadronTensor::TableEntry::Wzz, and genie::HadronTensorI::Z().

◆ ~TabulatedLabFrameHadronTensor()

genie::TabulatedLabFrameHadronTensor::~TabulatedLabFrameHadronTensor ( )

virtual

Definition at line 102 of file TabulatedLabFrameHadronTensor.cxx.

103{

104}

Member Function Documentation

◆ dSigma_dT_dCosTheta() [1/2]

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);
}

References dSigma_dT_dCosTheta(), genie::Interaction::FSPrimLepton(), genie::Kinematics::GetKV(), genie::Interaction::InitState(), genie::Interaction::Kine(), genie::kKVctl, genie::kKVTl, genie::kRfLab, genie::InitialState::Probe(), genie::InitialState::ProbeE(), and genie::InitialState::ProbePdg().

Referenced by dSigma_dT_dCosTheta().

◆ dSigma_dT_dCosTheta() [2/2]

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;
}

References fGrid, genie::constants::kAem, genie::constants::kGF2, genie::kPdgElectron, genie::kPdgNuE, genie::kPdgNuMu, genie::kPdgNuTau, genie::constants::kPi, genie::TabulatedLabFrameHadronTensor::TableEntry::W00, W1(), W2(), W3(), W4(), W5(), and genie::TabulatedLabFrameHadronTensor::TableEntry::Wxx.

◆ dSigma_dT_dCosTheta_rosenbluth() [1/2]

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);
}

References dSigma_dT_dCosTheta_rosenbluth(), genie::Interaction::FSPrimLepton(), genie::Kinematics::GetKV(), genie::Interaction::InitState(), genie::Interaction::Kine(), genie::kKVctl, genie::kKVTl, genie::kRfLab, genie::InitialState::Probe(), genie::InitialState::ProbeE(), and genie::InitialState::ProbePdg().

Referenced by dSigma_dT_dCosTheta_rosenbluth().

◆ dSigma_dT_dCosTheta_rosenbluth() [2/2]

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);
    // ALTHOUGH THE DIFFERENCES SHOULD BE VERY SMALL OR NEGLIGIBLE
 
    // Longitudinal part
    double l_part = std::pow(q2 / q_mag2, 2) * entry.W00 * c2_half;
 
    // Transverse part
    double t_part = ( 2.*s2_half - (q2*c2_half / 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;
}

References genie::AlgConfigPool::CommonList(), fGrid, genie::Registry::GetDouble(), genie::TabulatedLabFrameHadronTensor::TableEntry::ImWxy, genie::AlgConfigPool::Instance(), genie::constants::kAem, genie::constants::kGF2, genie::kPdgElectron, genie::kPdgNuE, genie::kPdgNuMu, genie::kPdgNuTau, genie::constants::kPi, genie::TabulatedLabFrameHadronTensor::TableEntry::ReW0z, genie::TabulatedLabFrameHadronTensor::TableEntry::W00, genie::TabulatedLabFrameHadronTensor::TableEntry::Wxx, and genie::TabulatedLabFrameHadronTensor::TableEntry::Wzz.

◆ q0Max()

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(); }

References fGrid.

◆ q0Min()

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(); }

References fGrid.

◆ qMagMax()

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(); }

References fGrid.

◆ qMagMin()

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(); }

References fGrid.

◆ read1DGridValues()

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 );
    }
  }
 
}

References LOG, and pERROR.

Referenced by TabulatedLabFrameHadronTensor().

◆ tt()

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.);
}

References fGrid, and genie::TabulatedLabFrameHadronTensor::TableEntry::W00.

◆ tz()

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.);
}

References fGrid, and genie::TabulatedLabFrameHadronTensor::TableEntry::ReW0z.

◆ W1() [1/2]

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.;
}

References genie::TabulatedLabFrameHadronTensor::TableEntry::Wxx.

◆ W1() [2/2]

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;
}

References fGrid, and W1().

Referenced by dSigma_dT_dCosTheta(), and W1().

◆ W2() [1/2]

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.;
}

References genie::TabulatedLabFrameHadronTensor::TableEntry::ReW0z, genie::TabulatedLabFrameHadronTensor::TableEntry::W00, genie::TabulatedLabFrameHadronTensor::TableEntry::Wxx, and genie::TabulatedLabFrameHadronTensor::TableEntry::Wzz.

◆ W2() [2/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;
}

References fGrid, and W2().

Referenced by dSigma_dT_dCosTheta(), and W2().

◆ W3() [1/2]

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 );
}

References genie::TabulatedLabFrameHadronTensor::TableEntry::ImWxy.

◆ W3() [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);
}

References fGrid, and W3().

Referenced by dSigma_dT_dCosTheta(), and W3().

◆ W4() [1/2]

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) );
}

References genie::TabulatedLabFrameHadronTensor::TableEntry::Wxx, and genie::TabulatedLabFrameHadronTensor::TableEntry::Wzz.

◆ W4() [2/2]

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;
}

References fGrid, and W4().

Referenced by dSigma_dT_dCosTheta(), and W4().

◆ W5() [1/2]

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;
}

References genie::TabulatedLabFrameHadronTensor::TableEntry::ReW0z, genie::TabulatedLabFrameHadronTensor::TableEntry::Wxx, and genie::TabulatedLabFrameHadronTensor::TableEntry::Wzz.

◆ W5() [2/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);
}

References fGrid, and W5().

Referenced by dSigma_dT_dCosTheta(), and W5().

◆ W6() [1/2]

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.;
}

◆ W6() [2/2]

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.;
}

◆ xx()

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.);
}

References fGrid, and genie::TabulatedLabFrameHadronTensor::TableEntry::Wxx.

◆ xy()

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);
}

References fGrid, and genie::TabulatedLabFrameHadronTensor::TableEntry::ImWxy.

◆ zz()

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.);
}

References fGrid, and genie::TabulatedLabFrameHadronTensor::TableEntry::Wzz.

Member Data Documentation

◆ fEntries

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

protected

Definition at line 205 of file TabulatedLabFrameHadronTensor.h.

Referenced by TabulatedLabFrameHadronTensor().

◆ fGrid

BLI2DNonUnifObjectGrid<TableEntry> genie::TabulatedLabFrameHadronTensor::fGrid

protected

Definition at line 207 of file TabulatedLabFrameHadronTensor.h.

Referenced by dSigma_dT_dCosTheta(), dSigma_dT_dCosTheta_rosenbluth(), q0Max(), q0Min(), qMagMax(), qMagMin(), TabulatedLabFrameHadronTensor(), tt(), tz(), W1(), W2(), W3(), W4(), W5(), xx(), xy(), and zz().

◆ fq0Points

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

protected

Definition at line 203 of file TabulatedLabFrameHadronTensor.h.

Referenced by TabulatedLabFrameHadronTensor().

◆ fqmagPoints

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

protected

Definition at line 204 of file TabulatedLabFrameHadronTensor.h.

Referenced by TabulatedLabFrameHadronTensor().

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

Classes

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ TabulatedLabFrameHadronTensor()

◆ ~TabulatedLabFrameHadronTensor()

Member Function Documentation

◆ dSigma_dT_dCosTheta() [1/2]

◆ dSigma_dT_dCosTheta() [2/2]

◆ dSigma_dT_dCosTheta_rosenbluth() [1/2]

◆ dSigma_dT_dCosTheta_rosenbluth() [2/2]

◆ q0Max()

◆ q0Min()

◆ qMagMax()

◆ qMagMin()

◆ read1DGridValues()

◆ tt()

◆ tz()

◆ W1() [1/2]

◆ W1() [2/2]

◆ W2() [1/2]

◆ W2() [2/2]

◆ W3() [1/2]

◆ W3() [2/2]

◆ W4() [1/2]

◆ W4() [2/2]

◆ W5() [1/2]

◆ W5() [2/2]

◆ W6() [1/2]

◆ W6() [2/2]

◆ xx()

◆ xy()

◆ zz()

Member Data Documentation

◆ fEntries

◆ fGrid

◆ fq0Points

◆ fqmagPoints