SemiAnalyticalModel Class Reference

#include <SemiAnalyticalModel.h>

Classes
struct	Dims
struct	OpticalDetector

Public Member Functions
	SemiAnalyticalModel (fhicl::ParameterSet VUVHits, fhicl::ParameterSet VISHits, bool doReflectedLight=false, bool includeAnodeReflections=false)
void	detectedDirectVisibilities (std::map< size_t, double > &DetectedVisibilities, geo::Point_t const &ScintPoint)
void	detectedReflectedVisibilities (std::map< size_t, double > &ReflDetectedVisibilities, geo::Point_t const &ScintPoint, bool AnodeMode=false)

Private Member Functions
void	Initialization ()
void	VUVVisibility (geo::Point_t const &ScintPoint, OpticalDetector const &opDet, double &DetThis)
void	VISVisibility (geo::Point_t const &ScintPoint, OpticalDetector const &opDet, const double cathode_visibility, geo::Point_t const &hotspot, double &ReflDetThis, bool AnodeMode=false)
double	Gaisser_Hillas (const double x, const double *par) const
double	Rectangle_SolidAngle (const double a, const double b, const double d) const
double	Rectangle_SolidAngle (Dims const &o, geo::Vector_t const &v, const double OpDetOrientation) const
double	Disk_SolidAngle (const double d, const double h, const double b) const
double	Omega_Dome_Model (const double distance, const double theta) const
bool	isOpDetInSameTPC (geo::Point_t const &ScintPoint, geo::Point_t const &OpDetPoint) const
double	fast_acos (double x) const
double	interpolate (const std::vector< double > &xData, const std::vector< double > &yData, double x, bool extrapolate, size_t i=0) const
double	interpolate2 (const std::vector< double > &xDistances, const std::vector< double > &rDistances, const std::vector< std::vector< std::vector< double >>> &parameters, const double x, const double r, const size_t k) const

Static Private Member Functions
template<typename TReal >
static constexpr bool	isApproximatelyEqual (TReal a, TReal b, TReal tolerance=std::numeric_limits< TReal >::epsilon())
template<typename TReal >
static constexpr bool	isApproximatelyZero (TReal a, TReal tolerance=std::numeric_limits< TReal >::epsilon())
template<typename TReal >
static constexpr bool	isDefinitelyLessThan (TReal a, TReal b, TReal tolerance=std::numeric_limits< TReal >::epsilon())
template<typename TReal >
static constexpr bool	isDefinitelyGreaterThan (TReal a, TReal b, TReal tolerance=std::numeric_limits< TReal >::epsilon())

Private Attributes
fhicl::ParameterSet	fVUVHitsParams
fhicl::ParameterSet	fVISHitsParams
int	fNTPC
larg4::ISTPC	fISTPC
std::vector< geo::BoxBoundedGeo >	fActiveVolumes
double	fplane_depth
double	fcathode_zdimension
double	fcathode_ydimension
double	fanode_plane_depth
double	fanode_ydimension
double	fanode_zdimension
TVector3	fcathode_centre
TVector3	fanode_centre
size_t	nOpDets
double	fradius
Dims	fcathode_plane
Dims	fanode_plane
std::vector< geo::Point_t >	fOpDetCenter
std::vector< int >	fOpDetType
std::vector< int >	fOpDetOrientation
std::vector< double >	fOpDetLength
std::vector< double >	fOpDetHeight
int	fL_abs_vuv
double	fdelta_angulo_vuv
bool	fIsFlatPDCorr
std::vector< std::vector< double > >	fGHvuvpars_flat
std::vector< double >	fborder_corr_angulo_flat
std::vector< std::vector< double > >	fborder_corr_flat
bool	fIsFlatPDCorrLat
std::vector< double >	fGH_distances_anode
std::vector< std::vector< std::vector< double > > >	fGHvuvpars_flat_lateral
bool	fIsDomePDCorr
std::vector< std::vector< double > >	fGHvuvpars_dome
std::vector< double >	fborder_corr_angulo_dome
std::vector< std::vector< double > >	fborder_corr_dome
bool	fApplyFieldCageTransparency
double	fFieldCageTransparencyLateral
double	fFieldCageTransparencyCathode
bool	fDoReflectedLight
bool	fIncludeAnodeReflections
double	fdelta_angulo_vis
double	fAnodeReflectivity
std::vector< double >	fvis_distances_x_flat
std::vector< double >	fvis_distances_r_flat
std::vector< std::vector< std::vector< double > > >	fvispars_flat
std::vector< double >	fvis_distances_x_flat_lateral
std::vector< double >	fvis_distances_r_flat_lateral
std::vector< std::vector< std::vector< double > > >	fvispars_flat_lateral
std::vector< double >	fvis_distances_x_dome
std::vector< double >	fvis_distances_r_dome
std::vector< std::vector< std::vector< double > > >	fvispars_dome

Detailed Description

Definition at line 27 of file SemiAnalyticalModel.h.

Constructor & Destructor Documentation

SemiAnalyticalModel::SemiAnalyticalModel	(	fhicl::ParameterSet	VUVHits,
		fhicl::ParameterSet	VISHits,
		bool	doReflectedLight = false,
		bool	includeAnodeReflections = false
	)

Definition at line 22 of file SemiAnalyticalModel.cxx.

  : fISTPC{*(lar::providerFrom<geo::Geometry>())}
{

  // set input parameters
  fVUVHitsParams = VUVHits;
  fDoReflectedLight = doReflectedLight;
  fIncludeAnodeReflections = includeAnodeReflections;
  
  if (fDoReflectedLight || includeAnodeReflections) fVISHitsParams = VISHits;  

  // initialise parameters and geometry 
  std::cout << "Semi-analytical model initialized." << std::endl;
  Initialization();
}

Member Function Documentation

void SemiAnalyticalModel::detectedDirectVisibilities	(	std::map< size_t, double > &	DetectedVisibilities,
		geo::Point_t const &	ScintPoint
	)

Definition at line 194 of file SemiAnalyticalModel.cxx.

{
  for (size_t const OpDet : util::counter(nOpDets)) {
    if (!isOpDetInSameTPC(ScintPoint, fOpDetCenter[OpDet])) continue;

    // set detector struct for solid angle function
    const SemiAnalyticalModel::OpticalDetector op{
    fOpDetHeight[OpDet], fOpDetLength[OpDet],
    fOpDetCenter[OpDet], fOpDetType[OpDet], fOpDetOrientation[OpDet]};

    double DetThis;
    VUVVisibility(ScintPoint, op, DetThis);

    DetectedVisibilities[OpDet] = DetThis;
  }
}

void SemiAnalyticalModel::detectedReflectedVisibilities	(	std::map< size_t, double > &	ReflDetectedVisibilities,
		geo::Point_t const &	ScintPoint,
		bool	AnodeMode = false
	)

Definition at line 334 of file SemiAnalyticalModel.cxx.

{
  // 1). calculate visibility of VUV photons on
  // reflective foils via solid angle + Gaisser-Hillas
  // corrections:  

  // get scintpoint coords relative to centre of cathode plane and set plane dimensions
  geo::Vector_t ScintPoint_relative;
  Dims plane_dimensions;
  double plane_depth;
  if (AnodeMode) {
    plane_dimensions = fanode_plane;
    plane_depth = fanode_plane_depth;
    ScintPoint_relative.SetCoordinates(std::abs(ScintPoint.X() - fanode_plane_depth), std::abs(ScintPoint.Y() - fanode_centre[1]), std::abs(ScintPoint.Z() - fanode_centre[2]));
  }
  else {
    plane_dimensions = fcathode_plane;
    plane_depth = ScintPoint.X() < 0. ? -fplane_depth : fplane_depth;
    ScintPoint_relative.SetCoordinates(std::abs(ScintPoint.X() - plane_depth), std::abs(ScintPoint.Y() - fcathode_centre[1]), std::abs(ScintPoint.Z() - fcathode_centre[2]));
  }

  // calculate solid angle of anode/cathode from the scintillation point, orientation always = 0 (anode/cathode)
  double solid_angle_cathode = Rectangle_SolidAngle(plane_dimensions, ScintPoint_relative, 0);

  // calculate distance and angle between ScintPoint and hotspot
  // vast majority of hits in hotspot region directly infront of scintpoint,
  // therefore consider attenuation for this distance and on axis GH instead of for the centre coordinate
  double distance_cathode = std::abs(plane_depth - ScintPoint.X());
  // calculate hits on cathode plane via geometric acceptance
  double cathode_visibility_geo = std::exp(-1. * distance_cathode / fL_abs_vuv) * (solid_angle_cathode / (4. * CLHEP::pi));
  
  // determine Gaisser-Hillas correction including border effects
  // use flat correction
  double r = std::hypot(ScintPoint.Y() - fcathode_centre[1], ScintPoint.Z() - fcathode_centre[2]);
  double pars_ini[4] = {0, 0, 0, 0};
  double s1 = 0; double s2 = 0; double s3 = 0;
  if(fIsFlatPDCorr) {
    pars_ini[0] = fGHvuvpars_flat[0][0];
    pars_ini[1] = fGHvuvpars_flat[1][0];
    pars_ini[2] = fGHvuvpars_flat[2][0];
    pars_ini[3] = fGHvuvpars_flat[3][0];
    s1 = interpolate( fborder_corr_angulo_flat, fborder_corr_flat[0], 0, true);
    s2 = interpolate( fborder_corr_angulo_flat, fborder_corr_flat[1], 0, true);
    s3 = interpolate( fborder_corr_angulo_flat, fborder_corr_flat[2], 0, true);
  }
  else {
  throw cet::exception("SemiAnalyticalModel")
        << "Error: flat optical detector VUV correction required for reflected semi-analytic hits. - configuration error in semi-analytical model." << "\n";
  }

  // add border correction
  pars_ini[0] = pars_ini[0] + s1 * r;
  pars_ini[1] = pars_ini[1] + s2 * r;
  pars_ini[2] = pars_ini[2] + s3 * r;
  pars_ini[3] = pars_ini[3];

  // calculate corrected number of hits
  double GH_correction = Gaisser_Hillas(distance_cathode, pars_ini);
  const double cathode_visibility_rec = GH_correction * cathode_visibility_geo;

  // 2). detemine visibility of each PD
  const geo::Point_t hotspot = {plane_depth, ScintPoint.Y(), ScintPoint.Z()};
  for (size_t const OpDet : util::counter(nOpDets)) {
    if (!isOpDetInSameTPC(ScintPoint, fOpDetCenter[OpDet])) continue;

    // set detector struct for solid angle function
    const  OpticalDetector op{
      fOpDetHeight[OpDet], fOpDetLength[OpDet],
      fOpDetCenter[OpDet], fOpDetType[OpDet], fOpDetOrientation[OpDet]};

    double ReflDetThis;
    VISVisibility(ScintPoint, op, cathode_visibility_rec, hotspot, ReflDetThis, AnodeMode);

    ReflDetectedVisibilities[OpDet] = ReflDetThis;
  }
}

double SemiAnalyticalModel::Disk_SolidAngle ( const double  d, const double  h, const double  b  ) const

private

Definition at line 522 of file SemiAnalyticalModel.cxx.

{
  if (b <= 0. || d < 0. || h <= 0.) return 0.;
  const double leg2 = (b + d) * (b + d);
  const double aa = std::sqrt(h * h / (h * h + leg2));
  if (isApproximatelyZero(d)) { return 2. * CLHEP::pi * (1. - aa); }
  double bb = 2. * std::sqrt(b * d / (h * h + leg2));
  double cc = 4. * b * d / leg2;

  if (isDefinitelyGreaterThan(d, b)) {
    try {
      return 2. * aa *
             (std::sqrt(1. - cc) * boost::math::ellint_3(bb, cc, noLDoublePromote()) -
              boost::math::ellint_1(bb, noLDoublePromote()));
    }
    catch (std::domain_error& e) {
      if (isApproximatelyEqual(d, b, 1e-9)) {
        mf::LogWarning("SemiAnalyticalModel")
          << "Elliptic Integral in Disk_SolidAngle() given parameters "
             "outside domain."
          << "\nbb: " << bb << "\ncc: " << cc << "\nException message: " << e.what()
          << "\nRelax condition and carry on.";
        return CLHEP::pi - 2. * aa * boost::math::ellint_1(bb, noLDoublePromote());
      }
      else {
        mf::LogError("SemiAnalyticalModel")
          << "Elliptic Integral inside Disk_SolidAngle() given parameters "
             "outside domain.\n"
          << "\nbb: " << bb << "\ncc: " << cc << "Exception message: " << e.what();
        return 0.;
      }
    }
  }
  if (isDefinitelyLessThan(d, b)) {
    try {
      return 2. * CLHEP::pi -
             2. * aa *
               (boost::math::ellint_1(bb, noLDoublePromote()) +
                std::sqrt(1. - cc) * boost::math::ellint_3(bb, cc, noLDoublePromote()));
    }
    catch (std::domain_error& e) {
      if (isApproximatelyEqual(d, b, 1e-9)) {
        mf::LogWarning("SemiAnalyticalModel")
          << "Elliptic Integral in Disk_SolidAngle() given parameters "
             "outside domain."
          << "\nbb: " << bb << "\ncc: " << cc << "\nException message: " << e.what()
          << "\nRelax condition and carry on.";
        return CLHEP::pi - 2. * aa * boost::math::ellint_1(bb, noLDoublePromote());
      }
      else {
        mf::LogError("SemiAnalyticalModel")
          << "Elliptic Integral inside Disk_SolidAngle() given parameters "
             "outside domain.\n"
          << "\nbb: " << bb << "\ncc: " << cc << "Exception message: " << e.what();
        return 0.;
      }
    }
  }
  if (isApproximatelyEqual(d, b)) {
    return CLHEP::pi - 2. * aa * boost::math::ellint_1(bb, noLDoublePromote());
  }
  return 0.;
}

double SemiAnalyticalModel::fast_acos ( double  x ) const

private

Definition at line 715 of file SemiAnalyticalModel.cxx.

{
  double negate = double(x < 0);
  x = std::abs(x);
  x -= double(x > 1.0) * (x - 1.0); // <- equivalent to min(1.0,x), but faster
  double ret = -0.0187293;
  ret = ret * x;
  ret = ret + 0.0742610;
  ret = ret * x;
  ret = ret - 0.2121144;
  ret = ret * x;
  ret = ret + 1.5707288;
  ret = ret * std::sqrt(1.0 - x);
  ret = ret - 2. * negate * ret;
  return negate * 3.14159265358979 + ret;
}

double SemiAnalyticalModel::Gaisser_Hillas ( const double  x, const double *  par  ) const

private

Definition at line 508 of file SemiAnalyticalModel.cxx.

{
  double X_mu_0 = par[3];
  double Normalization = par[0];
  double Diff = par[1] - X_mu_0;
  double Term = std::pow((x - X_mu_0) / Diff, Diff / par[2]);
  double Exponential = std::exp((par[1] - x) / par[2]);

  return (Normalization * Term * Exponential);
}

void SemiAnalyticalModel::Initialization ( )

private

Definition at line 39 of file SemiAnalyticalModel.cxx.

{
  // access geometry
  geo::GeometryCore const& geom = *(lar::providerFrom<geo::Geometry>());

  // store information from geometry service
  nOpDets = geom.NOpDets();
  fNTPC = geom.NTPC();
  
  // get TPC information
  fActiveVolumes = fISTPC.extractActiveLArVolume(geom);

  fcathode_centre = {geom.TPC(0, 0).GetCathodeCenter().X(),
                     fActiveVolumes[0].CenterY(),
                     fActiveVolumes[0].CenterZ()};

  fanode_centre = {geom.TPC(0, 0).FirstPlane().GetCenter().X(),
                    fActiveVolumes[0].CenterY(),
                    fActiveVolumes[0].CenterZ() };

  // get PDS information
  fOpDetType.reserve(nOpDets); fOpDetOrientation.reserve(nOpDets);
  fOpDetCenter.reserve(nOpDets); fOpDetLength.reserve(nOpDets); fOpDetHeight.reserve(nOpDets);
  
  for (size_t const i : util::counter(nOpDets)) {
    
    geo::OpDetGeo const& opDet = geom.OpDetGeoFromOpDet(i);
    fOpDetCenter.push_back(opDet.GetCenter());

    if (opDet.isSphere()) {  // dome PMTs
      fOpDetType.push_back(1); // dome
      fOpDetOrientation.push_back(0); // anode/cathode (default)
      fOpDetLength.push_back(-1);
      fOpDetHeight.push_back(-1);
    }
    else if (opDet.isBar()) {
      fOpDetType.push_back(0); // (X)Arapucas/Bars
      // determine orientation to get correction OpDet dimensions
      fOpDetLength.push_back(opDet.Length());
      if (opDet.Width() > opDet.Height()) { // laterals, Y dimension smallest
        fOpDetOrientation.push_back(1);          
        fOpDetHeight.push_back(opDet.Width());  
      }
      else {  // anode/cathode (default), X dimension smallest
        fOpDetOrientation.push_back(0);
        fOpDetHeight.push_back(opDet.Height());
      }        
    }
    else {
      fOpDetType.push_back(2); // disk PMTs
      fOpDetOrientation.push_back(0); // anode/cathode (default)
      fOpDetLength.push_back(-1);
      fOpDetHeight.push_back(-1);
    }
  }

  // determine LAr absorption length in cm
  std::map<double, double> abs_length_spectrum = lar::providerFrom<detinfo::LArPropertiesService>()->AbsLengthSpectrum();
  std::vector<double> x_v, y_v;
  for (auto elem : abs_length_spectrum) {
    x_v.push_back(elem.first);
    y_v.push_back(elem.second);
  }
  fL_abs_vuv = std::round(interpolate(x_v, y_v, 9.7, false)); // 9.7 eV: peak of VUV emission spectrum   // TO DO UNHARDCODE FOR XENON 

  // Load Gaisser-Hillas corrections for VUV semi-analytic hits
  mf::LogInfo("SemiAnalyticalModel") << "Using VUV visibility parameterization";
  
  fIsFlatPDCorr     = fVUVHitsParams.get<bool>("FlatPDCorr", false);
  fIsFlatPDCorrLat  = fVUVHitsParams.get<bool>("FlatPDCorrLat", false);
  fIsDomePDCorr     = fVUVHitsParams.get<bool>("DomePDCorr", false);
  fdelta_angulo_vuv = fVUVHitsParams.get<double>("delta_angulo_vuv", 10);
  fradius           = fVUVHitsParams.get<double>("PMT_radius", 10.16);
  fApplyFieldCageTransparency = fVUVHitsParams.get<bool>("ApplyFieldCageTransparency", false);
  fFieldCageTransparencyLateral = fVUVHitsParams.get<double>("FieldCageTransparencyLateral", 1.0);
  fFieldCageTransparencyCathode = fVUVHitsParams.get<double>("FieldCageTransparencyCathode", 1.0);    
  
  if (!fIsFlatPDCorr && !fIsDomePDCorr && !fIsFlatPDCorrLat) {
    throw cet::exception("SemiAnalyticalModel")
        << "Both isFlatPDCorr/isFlatPDCorrLat and isDomePDCorr parameters are false, at least one type of parameterisation is required for the semi-analytic light simulation." << "\n";
  }
  if (fIsFlatPDCorr) {
      fGHvuvpars_flat          = fVUVHitsParams.get<std::vector<std::vector<double>>>("GH_PARS_flat");
      fborder_corr_angulo_flat = fVUVHitsParams.get<std::vector<double>>("GH_border_angulo_flat");
      fborder_corr_flat        = fVUVHitsParams.get<std::vector<std::vector<double>>>("GH_border_flat");
  }
  if (fIsFlatPDCorrLat) {
      fGHvuvpars_flat_lateral  = fVUVHitsParams.get<std::vector<std::vector<std::vector<double>>>>("GH_PARS_flat_lateral");
      fGH_distances_anode      = fVUVHitsParams.get<std::vector<double>>("GH_distances_anode");
  }
  if (fIsDomePDCorr) {
      fGHvuvpars_dome          = fVUVHitsParams.get<std::vector<std::vector<double>>>("GH_PARS_dome");
      fborder_corr_angulo_dome = fVUVHitsParams.get<std::vector<double>>("GH_border_angulo_dome");
      fborder_corr_dome        = fVUVHitsParams.get<std::vector<std::vector<double>>>("GH_border_dome");
  }

  // Load corrections for VIS semi-analytic hits
  if (fDoReflectedLight) {
    mf::LogInfo("SemiAnalyticalModel") << "Using VIS (reflected) visibility parameterization";
    fdelta_angulo_vis = fVISHitsParams.get<double>("delta_angulo_vis");

    if (fIsFlatPDCorr) {
      fvis_distances_x_flat = fVISHitsParams.get<std::vector<double>>("VIS_distances_x_flat");
      fvis_distances_r_flat = fVISHitsParams.get<std::vector<double>>("VIS_distances_r_flat");
      fvispars_flat         = fVISHitsParams.get<std::vector<std::vector<std::vector<double>>>>("VIS_correction_flat");
    }
    if (fIsDomePDCorr) {
      fvis_distances_x_dome = fVISHitsParams.get<std::vector<double>>("VIS_distances_x_dome");
      fvis_distances_r_dome = fVISHitsParams.get<std::vector<double>>("VIS_distances_r_dome");
      fvispars_dome         = fVISHitsParams.get<std::vector<std::vector<std::vector<double>>>>("VIS_correction_dome");
    }

    // cathode dimensions
    fcathode_ydimension = fActiveVolumes[0].SizeY();
    fcathode_zdimension = fActiveVolumes[0].SizeZ();

    // set cathode plane struct for solid angle function
    fcathode_plane.h = fcathode_ydimension;
    fcathode_plane.w = fcathode_zdimension;
    fplane_depth = std::abs(fcathode_centre[0]);
  }

  // Load corrections for Anode reflections configuration
  if (fIncludeAnodeReflections) {
    mf::LogInfo("SemiAnalyticalModel") << "Using anode reflections parameterization";
    fdelta_angulo_vis = fVISHitsParams.get<double>("delta_angulo_vis");
    fAnodeReflectivity = fVISHitsParams.get<double>("AnodeReflectivity");

    if (fIsFlatPDCorr) {
      fvis_distances_x_flat = fVISHitsParams.get<std::vector<double>>("VIS_distances_x_flat");
      fvis_distances_r_flat = fVISHitsParams.get<std::vector<double>>("VIS_distances_r_flat");
      fvispars_flat         = fVISHitsParams.get<std::vector<std::vector<std::vector<double>>>>("VIS_correction_flat");
    }

    if (fIsFlatPDCorrLat) {
      fvis_distances_x_flat_lateral = fVISHitsParams.get<std::vector<double>>("VIS_distances_x_flat_lateral");
      fvis_distances_r_flat_lateral = fVISHitsParams.get<std::vector<double>>("VIS_distances_r_flat_lateral");
      fvispars_flat_lateral         = fVISHitsParams.get<std::vector<std::vector<std::vector<double>>>>("VIS_correction_flat_lateral");
    }

    // anode dimensions
    fanode_ydimension = fActiveVolumes[0].SizeY();
    fanode_zdimension = fActiveVolumes[0].SizeZ();

    // set anode plane struct for solid angle function
    fanode_plane.h = fanode_ydimension;
    fanode_plane.w = fanode_zdimension;
    fanode_plane_depth = fanode_centre[0];
  }  

}

double SemiAnalyticalModel::interpolate ( const std::vector< double > &  xData, const std::vector< double > &  yData, double  x, bool  extrapolate, size_t  i = 0  ) const

private

Definition at line 738 of file SemiAnalyticalModel.cxx.

{
  if (i == 0) {
    size_t size = xData.size();
    if (x >= xData[size - 2]) { // special case: beyond right end
      i = size - 2;
    }
    else {
      while (x > xData[i + 1])
        i++;
    }
  }
  double xL = xData[i];
  double xR = xData[i + 1];
  double yL = yData[i];
  double yR = yData[i + 1]; // points on either side (unless beyond ends)
  if (!extrapolate) {       // if beyond ends of array and not extrapolating
    if (x < xL) return yL;
    if (x > xR) return yL;
  }
  const double dydx = (yR - yL) / (xR - xL); // gradient
  return yL + dydx * (x - xL);               // linear interpolation
}

double SemiAnalyticalModel::interpolate2 ( const std::vector< double > &  xDistances, const std::vector< double > &  rDistances, const std::vector< std::vector< std::vector< double >>> &  parameters, const double  x, const double  r, const size_t  k  ) const

private

Definition at line 767 of file SemiAnalyticalModel.cxx.

{
  // interpolate in x for each r bin, for angle bin k
  const size_t nbins_r = parameters[k].size();
  std::vector<double> interp_vals(nbins_r, 0.0);
  {
    size_t idx = 0;
    size_t size = xDistances.size();
    if (x >= xDistances[size - 2])
      idx = size - 2;
    else {
      while (x > xDistances[idx + 1])
        idx++;
    }
    for (size_t i = 0; i < nbins_r; ++i) {
      interp_vals[i] = interpolate(xDistances,
                                   parameters[k][i],
                                   x,
                                   false,
                                   idx);
    }
  }
  // interpolate in r
  double border_correction = interpolate(rDistances, interp_vals, r, false);
  return border_correction;
}

template<typename TReal >

static constexpr bool SemiAnalyticalModel::isApproximatelyEqual ( TReal  a, TReal  b, TReal  tolerance = std::numeric_limits<TReal>::epsilon()  )

inlinestaticprivate

Definition at line 103 of file SemiAnalyticalModel.h.

    {
        TReal diff = std::fabs(a - b);
        if (diff <= tolerance) return true;
        if (diff < std::fmax(std::fabs(a), std::fabs(b)) * tolerance) return true;
        return false;
    }

template<typename TReal >

static constexpr bool SemiAnalyticalModel::isApproximatelyZero ( TReal  a, TReal  tolerance = std::numeric_limits<TReal>::epsilon()  )

inlinestaticprivate

Definition at line 116 of file SemiAnalyticalModel.h.

    {
        if (std::fabs(a) <= tolerance) return true;
        return false;
    }

template<typename TReal >

static constexpr bool SemiAnalyticalModel::isDefinitelyGreaterThan ( TReal  a, TReal  b, TReal  tolerance = std::numeric_limits<TReal>::epsilon()  )

inlinestaticprivate

Definition at line 136 of file SemiAnalyticalModel.h.

    {
        TReal diff = a - b;
        if (diff > tolerance) return true;
        if (diff > std::fmax(std::fabs(a), std::fabs(b)) * tolerance) return true;
        return false;
    }

template<typename TReal >

static constexpr bool SemiAnalyticalModel::isDefinitelyLessThan ( TReal  a, TReal  b, TReal  tolerance = std::numeric_limits<TReal>::epsilon()  )

inlinestaticprivate

Definition at line 126 of file SemiAnalyticalModel.h.

    {
        TReal diff = a - b;
        if (diff < tolerance) return true;
        if (diff < std::fmax(std::fabs(a), std::fabs(b)) * tolerance) return true;
        return false;
    }

bool SemiAnalyticalModel::isOpDetInSameTPC ( geo::Point_t const &  ScintPoint, geo::Point_t const &  OpDetPoint  ) const

private

Definition at line 700 of file SemiAnalyticalModel.cxx.

{
  // method working for SBND, uBooNE, DUNE-HD 1x2x6 and DUNE-VD 1x8x6
  // will need to be replaced to work in full DUNE geometry, ICARUS geometry
  // check x coordinate has same sign or is close to zero, otherwise return false
  if (((ScintPoint.X() < 0.) != (OpDetPoint.X() < 0.)) &&
     std::abs(OpDetPoint.X()) > 10. && fNTPC == 2) { // TODO: replace with geometry service
    return false;
  }
  return true;
}

double SemiAnalyticalModel::Omega_Dome_Model ( const double  distance, const double  theta  ) const

private

Definition at line 667 of file SemiAnalyticalModel.cxx.

{
  // this function calculates the solid angle of a semi-sphere of radius b,
  // as a correction to the analytic formula of the on-axix solid angle,
  // as we move off-axis an angle theta. We have used 9-angular bins
  // with delta_theta width.

  // par0 = Radius correction close
  // par1 = Radius correction far
  // par2 = breaking distance betwween "close" and "far"

  double par0[9] = {0., 0., 0., 0., 0., 0.597542, 1.00872, 1.46993, 2.04221};
  double par1[9] = {0, 0, 0.19569, 0.300449, 0.555598, 0.854939, 1.39166, 2.19141, 2.57732};
  const double delta_theta = 10.;
  int j = int(theta/delta_theta);
  // PMT radius
  const double b = fradius; // cm
  // distance form which the model parameters break (empirical value)
  const double d_break = 5*b; //par2

  if(distance >= d_break) {
    double R_apparent_far = b - par1[j];
    return  (2*CLHEP::pi * (1 - std::sqrt(1 - std::pow(R_apparent_far/distance,2))));
  }
  else {
    double R_apparent_close = b - par0[j];
    return (2*CLHEP::pi * (1 - std::sqrt(1 - std::pow(R_apparent_close/distance,2))));
  }
}

double SemiAnalyticalModel::Rectangle_SolidAngle ( const double  a, const double  b, const double  d  ) const

private

Definition at line 589 of file SemiAnalyticalModel.cxx.

{
  double aa = a / (2. * d);
  double bb = b / (2. * d);
  double aux = (1. + aa * aa + bb * bb) / ((1. + aa * aa) * (1. + bb * bb));
  return 4. * fast_acos(std::sqrt(aux));
}

double SemiAnalyticalModel::Rectangle_SolidAngle ( Dims const &  o, geo::Vector_t const &  v, const double  OpDetOrientation  ) const

private

Definition at line 598 of file SemiAnalyticalModel.cxx.

{
  // v is the position of the track segment with respect to
  // the center position of the arapuca window

  // solid angle calculation depends on orientation of PD, set correct distances to use
  double d1;
  double d2; 
  if (OpDetOrientation == 1) {
    // lateral PD, arapuca plane fixed in y direction
    d1 = std::abs(v.X());
    d2 = std::abs(v.Y()); 
  }
  else {
    // anode/cathode PD, arapuca plane fixed in x direction [default]
    d1 = std::abs(v.Y());
    d2 = std::abs(v.X());
  }
  // arapuca plane fixed in x direction
  if (isApproximatelyZero(d1) && isApproximatelyZero(v.Z())) {
    return Rectangle_SolidAngle(o.h, o.w, d2);
  }
  if (isDefinitelyGreaterThan(d1, o.h * .5) && isDefinitelyGreaterThan(std::abs(v.Z()), o.w * .5)) {
    double A = d1 - o.h * .5;
    double B = std::abs(v.Z()) - o.w * .5;
    double to_return = (Rectangle_SolidAngle(2. * (A + o.h), 2. * (B + o.w), d2) -
                        Rectangle_SolidAngle(2. * A, 2. * (B + o.w), d2) -
                        Rectangle_SolidAngle(2. * (A + o.h), 2. * B, d2) +
                        Rectangle_SolidAngle(2. * A, 2. * B, d2)) *
                       .25;
    return to_return;
  }
  if ((d1 <= o.h * .5) && (std::abs(v.Z()) <= o.w * .5)) {
    double A = -d1 + o.h * .5;
    double B = -std::abs(v.Z()) + o.w * .5;
    double to_return = (Rectangle_SolidAngle(2. * (o.h - A), 2. * (o.w - B), d2) +
                        Rectangle_SolidAngle(2. * A, 2. * (o.w - B), d2) +
                        Rectangle_SolidAngle(2. * (o.h - A), 2. * B, d2) +
                        Rectangle_SolidAngle(2. * A, 2. * B, d2)) *
                       .25;
    return to_return;
  }
  if (isDefinitelyGreaterThan(d1, o.h * .5) && (std::abs(v.Z()) <= o.w * .5)) {
    double A = d1 - o.h * .5;
    double B = -std::abs(v.Z()) + o.w * .5;
    double to_return = (Rectangle_SolidAngle(2. * (A + o.h), 2. * (o.w - B), d2) -
                        Rectangle_SolidAngle(2. * A, 2. * (o.w - B), d2) +
                        Rectangle_SolidAngle(2. * (A + o.h), 2. * B, d2) -
                        Rectangle_SolidAngle(2. * A, 2. * B, d2)) *
                       .25;
    return to_return;
  }
  if ((d1 <= o.h * .5) && isDefinitelyGreaterThan(std::abs(v.Z()), o.w * .5)) {
    double A = -d1 + o.h * .5;
    double B = std::abs(v.Z()) - o.w * .5;
    double to_return = (Rectangle_SolidAngle(2. * (o.h - A), 2. * (B + o.w), d2) -
                        Rectangle_SolidAngle(2. * (o.h - A), 2. * B, d2) +
                        Rectangle_SolidAngle(2. * A, 2. * (B + o.w), d2) -
                        Rectangle_SolidAngle(2. * A, 2. * B, d2)) *
                       .25;
    return to_return;
  }

  return 0.;
}

void SemiAnalyticalModel::VISVisibility ( geo::Point_t const &  ScintPoint, OpticalDetector const &  opDet, const double  cathode_visibility, geo::Point_t const &  hotspot, double &  ReflDetThis, bool  AnodeMode = false  )

private

Definition at line 414 of file SemiAnalyticalModel.cxx.

{
  // set correct plane_depth
  double plane_depth;
  if (AnodeMode) plane_depth = fanode_plane_depth;
  else plane_depth = ScintPoint.X() < 0. ? -fplane_depth : fplane_depth;

  // calculate visibility of the optical
  // detector from the hotspot using solid angle:

  geo::Vector_t const emission_relative = hotspot - opDet.OpDetPoint;

  // calculate distances and angles for application of corrections
  // distance from hotspot to optical detector
  const double distance_vis = emission_relative.R();
  //  angle between hotspot and optical detector
  double cosine_vis;
  if (opDet.orientation == 1) { // lateral
    cosine_vis = std::abs(emission_relative.Y()) / distance_vis;
  }
  else { // anode/cathode (default)
    cosine_vis = std::abs(emission_relative.X()) / distance_vis;
  }
  const double theta_vis = fast_acos(cosine_vis) * 180. / CLHEP::pi;

  // calculate solid angle of optical channel
  double solid_angle_detector = 0.;
  // ARAPUCAS/Bars (rectangle)
  if (opDet.type == 0) {
    // get hotspot coordinates relative to opDet
    geo::Vector_t const abs_emission_relative{std::abs(emission_relative.X()),
                                              std::abs(emission_relative.Y()),
                                              std::abs(emission_relative.Z())};
    solid_angle_detector = Rectangle_SolidAngle(Dims{opDet.h, opDet.w}, abs_emission_relative, opDet.orientation);
  }
  // PMTS (dome)
  else if (opDet.type == 1) {
    solid_angle_detector = Omega_Dome_Model(distance_vis, theta_vis);
  }
  // PMTs (disk)
  else if (opDet.type == 2) {
    const double zy_offset = std::sqrt(emission_relative.Y() * emission_relative.Y() +
                                       emission_relative.Z() * emission_relative.Z());
    const double x_distance = std::abs(emission_relative.X());
    solid_angle_detector = Disk_SolidAngle(zy_offset, x_distance, fradius);
  }
  else {
    throw cet::exception("SemiAnalyticalModel")
        << "Error: Invalid optical detector shape requested - configuration error in semi-analytical model, only rectangular, dome or disk optical detectors are supported." << "\n";
  }

  // calculate number of hits via geometeric acceptance
  double visibility_geo = (solid_angle_detector / (2. * CLHEP::pi)) *
                    cathode_visibility; // 2*pi due to presence of reflective foils

  // determine correction factor, depending on PD type
  const size_t k = (theta_vis / fdelta_angulo_vis);         // off-set angle bin
  double r = std::hypot(ScintPoint.Y() - fcathode_centre[1], ScintPoint.Z() - fcathode_centre[2]);
  double d_c = std::abs(ScintPoint.X() - plane_depth);       // distance to cathode
  double border_correction = 0;
  // flat PDs
  if ((opDet.type == 0 || opDet.type == 2) && (fIsFlatPDCorr || fIsFlatPDCorrLat)) {
    // cathode/anode case
    if (opDet.orientation == 0 && fIsFlatPDCorr) border_correction = interpolate2(fvis_distances_x_flat, fvis_distances_r_flat, fvispars_flat, d_c, r, k);
    // laterals case
    else if (opDet.orientation == 1 && fIsFlatPDCorrLat) border_correction = interpolate2(fvis_distances_x_flat_lateral, fvis_distances_r_flat_lateral, fvispars_flat_lateral, d_c, r, k);
    else {
      throw cet::exception("SemiAnalyticalModel")
        << "Error: Invalid optical detector shape requested or corrections are missing - configuration error in semi-analytical model." << "\n";
    }
  }
  // dome PDs
  else if (opDet.type == 1 && fIsDomePDCorr) border_correction = interpolate2(fvis_distances_x_dome, fvis_distances_r_dome, fvispars_dome, d_c, r, k);
  else {
      throw cet::exception("SemiAnalyticalModel")
        << "Error: Invalid optical detector shape requested or corrections are missing - configuration error in semi-analytical model." << "\n";
  }

  // apply anode reflectivity factor
  if (AnodeMode) border_correction = border_correction * fAnodeReflectivity;

  // apply field cage transparency factor 
  if (fApplyFieldCageTransparency) {
    if (opDet.orientation == 1) border_correction = border_correction * fFieldCageTransparencyLateral;
    else if (opDet.orientation == 0) border_correction = border_correction * fFieldCageTransparencyCathode;
  }

  ReflDetThis = border_correction * visibility_geo / cosine_vis;
}

void SemiAnalyticalModel::VUVVisibility ( geo::Point_t const &  ScintPoint, OpticalDetector const &  opDet, double &  DetThis  )

private

Definition at line 213 of file SemiAnalyticalModel.cxx.

{
  // distance and angle between ScintPoint and OpDetPoint
  geo::Vector_t const relative = ScintPoint - opDet.OpDetPoint;
  const double distance = relative.R();
  double cosine;
  if (opDet.orientation == 1) cosine = std::abs(relative.Y()) / distance;
  else cosine = std::abs(relative.X()) / distance;
  const double theta = fast_acos(cosine) * 180. / CLHEP::pi;

  double solid_angle = 0.;
  // ARAPUCAS/Bars (rectangle)
  if (opDet.type == 0) {
    // get scintillation point coordinates relative to arapuca window centre
    geo::Vector_t const abs_relative{std::abs(relative.X()), std::abs(relative.Y()), std::abs(relative.Z())};
    solid_angle = Rectangle_SolidAngle(Dims{opDet.h, opDet.w}, abs_relative, opDet.orientation);
  }
  // PMTs (dome)
  else if (opDet.type == 1) {
    solid_angle = Omega_Dome_Model(distance, theta);
  }
  // PMTs (disk)
  else if (opDet.type == 2) {
    const double zy_offset = std::sqrt(relative.Y() * relative.Y() + relative.Z() * relative.Z());
    const double x_distance = std::abs(relative.X());
    solid_angle = Disk_SolidAngle(zy_offset, x_distance, fradius);
  }
  else {
    throw cet::exception("SemiAnalyticalModel")
        << "Error: Invalid optical detector shape requested - configuration error in semi-analytical model, only rectangular, dome or disk optical detectors are supported." << "\n";
  }

  // calculate visibility by geometric acceptance
  // accounting for solid angle and LAr absorbtion length
  double visibility_geo = std::exp(-1. * distance / fL_abs_vuv) * (solid_angle / (4 * CLHEP::pi));

  // apply Gaisser-Hillas correction for Rayleigh scattering distance
  // and angular dependence offset angle bin
  const size_t j = (theta / fdelta_angulo_vuv);

  // determine GH parameters, accounting for border effects
  // radial distance from centre of detector (Y-Z)
  double r = std::hypot(ScintPoint.Y() - fcathode_centre[1], ScintPoint.Z() - fcathode_centre[2]);

  double pars_ini[4] = {0, 0, 0, 0};
  double s1 = 0; double s2 = 0; double s3 = 0;
  // flat PDs
  if ((opDet.type == 0 || opDet.type == 2) && (fIsFlatPDCorr || fIsFlatPDCorrLat)){
    if (opDet.orientation == 1 && fIsFlatPDCorrLat) { // laterals, alternate parameterisation method
      // distance to anode plane
      double d_anode = std::abs(fanode_centre[0] - ScintPoint.X()); 
      
      // build arrays for interpolation
      int n_distances = fGH_distances_anode.size();
      std::vector<double> p1, p2, p3, p4;
      p1.reserve(n_distances); p2.reserve(n_distances); p3.reserve(n_distances); p4.reserve(n_distances);
      for (int i = 0; i < n_distances; i++) {
        p1.push_back(fGHvuvpars_flat_lateral[0][i][j]);
        p2.push_back(fGHvuvpars_flat_lateral[1][i][j]);
        p3.push_back(fGHvuvpars_flat_lateral[2][i][j]);
        p4.push_back(fGHvuvpars_flat_lateral[3][i][j]);
      }

      // interpolate in distance to anode
      pars_ini[0] = interpolate(fGH_distances_anode, p1, d_anode, false);
      pars_ini[1] = interpolate(fGH_distances_anode, p2, d_anode, false);
      pars_ini[2] = interpolate(fGH_distances_anode, p3, d_anode, false);
      pars_ini[3] = interpolate(fGH_distances_anode, p4, d_anode, false);
    
    }
    else if (opDet.orientation == 0 && fIsFlatPDCorr) { // cathode/anode, default parameterisation method
      pars_ini[0] = fGHvuvpars_flat[0][j];
      pars_ini[1] = fGHvuvpars_flat[1][j];
      pars_ini[2] = fGHvuvpars_flat[2][j];
      pars_ini[3] = fGHvuvpars_flat[3][j];
      s1 = interpolate( fborder_corr_angulo_flat, fborder_corr_flat[0], theta, true);
      s2 = interpolate( fborder_corr_angulo_flat, fborder_corr_flat[1], theta, true);
      s3 = interpolate( fborder_corr_angulo_flat, fborder_corr_flat[2], theta, true);
    }
    else {
      throw cet::exception("SemiAnalyticalModel")
        << "Error: flat optical detectors are found, but parameters are missing - configuration error in semi-analytical model." << "\n";
    }
  }
  // dome PDs
  else if (opDet.type == 1 && fIsDomePDCorr) {
    pars_ini[0] = fGHvuvpars_dome[0][j];
    pars_ini[1] = fGHvuvpars_dome[1][j];
    pars_ini[2] = fGHvuvpars_dome[2][j];
    pars_ini[3] = fGHvuvpars_dome[3][j];
    s1 = interpolate( fborder_corr_angulo_dome, fborder_corr_dome[0], theta, true);
    s2 = interpolate( fborder_corr_angulo_dome, fborder_corr_dome[1], theta, true);
    s3 = interpolate( fborder_corr_angulo_dome, fborder_corr_dome[2], theta, true);
  }
  else {
    throw cet::exception("SemiAnalyticalModel")
        << "Error: Invalid optical detector shape requested or corrections are missing - configuration error in semi-analytical model." << "\n";
  }

  // add border correction to parameters
  pars_ini[0] = pars_ini[0] + s1 * r;
  pars_ini[1] = pars_ini[1] + s2 * r;
  pars_ini[2] = pars_ini[2] + s3 * r;
  pars_ini[3] = pars_ini[3];

  // calculate correction
  double GH_correction = Gaisser_Hillas(distance, pars_ini);

  // apply field cage transparency factor 
  if (fApplyFieldCageTransparency) {
    if (opDet.orientation == 1) GH_correction = GH_correction * fFieldCageTransparencyLateral;
    else if (opDet.orientation == 0) GH_correction = GH_correction * fFieldCageTransparencyCathode;
  }

  // determine corrected visibility of photo-detector
  DetThis = GH_correction * visibility_geo / cosine;
}

Member Data Documentation

std::vector<geo::BoxBoundedGeo> SemiAnalyticalModel::fActiveVolumes

private

Definition at line 151 of file SemiAnalyticalModel.h.

TVector3 SemiAnalyticalModel::fanode_centre

private

Definition at line 154 of file SemiAnalyticalModel.h.

Dims SemiAnalyticalModel::fanode_plane

private

Definition at line 160 of file SemiAnalyticalModel.h.

double SemiAnalyticalModel::fanode_plane_depth

private

Definition at line 153 of file SemiAnalyticalModel.h.

double SemiAnalyticalModel::fanode_ydimension

private

Definition at line 153 of file SemiAnalyticalModel.h.

double SemiAnalyticalModel::fanode_zdimension

private

Definition at line 153 of file SemiAnalyticalModel.h.

double SemiAnalyticalModel::fAnodeReflectivity

private

Definition at line 196 of file SemiAnalyticalModel.h.

bool SemiAnalyticalModel::fApplyFieldCageTransparency

private

Definition at line 187 of file SemiAnalyticalModel.h.

std::vector<double> SemiAnalyticalModel::fborder_corr_angulo_dome

private

Definition at line 184 of file SemiAnalyticalModel.h.

std::vector<double> SemiAnalyticalModel::fborder_corr_angulo_flat

private

Definition at line 175 of file SemiAnalyticalModel.h.

std::vector<std::vector<double> > SemiAnalyticalModel::fborder_corr_dome

private

Definition at line 185 of file SemiAnalyticalModel.h.

std::vector<std::vector<double> > SemiAnalyticalModel::fborder_corr_flat

private

Definition at line 176 of file SemiAnalyticalModel.h.

TVector3 SemiAnalyticalModel::fcathode_centre

private

Definition at line 154 of file SemiAnalyticalModel.h.

Dims SemiAnalyticalModel::fcathode_plane

private

Definition at line 159 of file SemiAnalyticalModel.h.

double SemiAnalyticalModel::fcathode_ydimension

private

Definition at line 152 of file SemiAnalyticalModel.h.

double SemiAnalyticalModel::fcathode_zdimension

private

Definition at line 152 of file SemiAnalyticalModel.h.

double SemiAnalyticalModel::fdelta_angulo_vis

private

Definition at line 195 of file SemiAnalyticalModel.h.

double SemiAnalyticalModel::fdelta_angulo_vuv

private

Definition at line 171 of file SemiAnalyticalModel.h.

bool SemiAnalyticalModel::fDoReflectedLight

private

Definition at line 192 of file SemiAnalyticalModel.h.

double SemiAnalyticalModel::fFieldCageTransparencyCathode

private

Definition at line 189 of file SemiAnalyticalModel.h.

double SemiAnalyticalModel::fFieldCageTransparencyLateral

private

Definition at line 188 of file SemiAnalyticalModel.h.

std::vector<double> SemiAnalyticalModel::fGH_distances_anode

private

Definition at line 179 of file SemiAnalyticalModel.h.

std::vector<std::vector<double> > SemiAnalyticalModel::fGHvuvpars_dome

private

Definition at line 183 of file SemiAnalyticalModel.h.

std::vector<std::vector<double> > SemiAnalyticalModel::fGHvuvpars_flat

private

Definition at line 174 of file SemiAnalyticalModel.h.

std::vector<std::vector<std::vector<double> > > SemiAnalyticalModel::fGHvuvpars_flat_lateral

private

Definition at line 180 of file SemiAnalyticalModel.h.

bool SemiAnalyticalModel::fIncludeAnodeReflections

private

Definition at line 193 of file SemiAnalyticalModel.h.

bool SemiAnalyticalModel::fIsDomePDCorr

private

Definition at line 182 of file SemiAnalyticalModel.h.

bool SemiAnalyticalModel::fIsFlatPDCorr

private

Definition at line 173 of file SemiAnalyticalModel.h.

bool SemiAnalyticalModel::fIsFlatPDCorrLat

private

Definition at line 178 of file SemiAnalyticalModel.h.

larg4::ISTPC SemiAnalyticalModel::fISTPC

private

Definition at line 150 of file SemiAnalyticalModel.h.

int SemiAnalyticalModel::fL_abs_vuv

private

Definition at line 168 of file SemiAnalyticalModel.h.

int SemiAnalyticalModel::fNTPC

private

Definition at line 149 of file SemiAnalyticalModel.h.

std::vector<geo::Point_t> SemiAnalyticalModel::fOpDetCenter

private

Definition at line 161 of file SemiAnalyticalModel.h.

std::vector<double> SemiAnalyticalModel::fOpDetHeight

private

Definition at line 165 of file SemiAnalyticalModel.h.

std::vector<double> SemiAnalyticalModel::fOpDetLength

private

Definition at line 164 of file SemiAnalyticalModel.h.

std::vector<int> SemiAnalyticalModel::fOpDetOrientation

private

Definition at line 163 of file SemiAnalyticalModel.h.

std::vector<int> SemiAnalyticalModel::fOpDetType

private

Definition at line 162 of file SemiAnalyticalModel.h.

double SemiAnalyticalModel::fplane_depth

private

Definition at line 152 of file SemiAnalyticalModel.h.

double SemiAnalyticalModel::fradius

private

Definition at line 158 of file SemiAnalyticalModel.h.

std::vector<double> SemiAnalyticalModel::fvis_distances_r_dome

private

Definition at line 207 of file SemiAnalyticalModel.h.

std::vector<double> SemiAnalyticalModel::fvis_distances_r_flat

private

Definition at line 199 of file SemiAnalyticalModel.h.

std::vector<double> SemiAnalyticalModel::fvis_distances_r_flat_lateral

private

Definition at line 203 of file SemiAnalyticalModel.h.

std::vector<double> SemiAnalyticalModel::fvis_distances_x_dome

private

Definition at line 206 of file SemiAnalyticalModel.h.

std::vector<double> SemiAnalyticalModel::fvis_distances_x_flat

private

Definition at line 198 of file SemiAnalyticalModel.h.

std::vector<double> SemiAnalyticalModel::fvis_distances_x_flat_lateral

private

Definition at line 202 of file SemiAnalyticalModel.h.

fhicl::ParameterSet SemiAnalyticalModel::fVISHitsParams

private

Definition at line 146 of file SemiAnalyticalModel.h.

std::vector<std::vector<std::vector<double> > > SemiAnalyticalModel::fvispars_dome

private

Definition at line 208 of file SemiAnalyticalModel.h.

std::vector<std::vector<std::vector<double> > > SemiAnalyticalModel::fvispars_flat

private

Definition at line 200 of file SemiAnalyticalModel.h.

std::vector<std::vector<std::vector<double> > > SemiAnalyticalModel::fvispars_flat_lateral

private

Definition at line 204 of file SemiAnalyticalModel.h.

fhicl::ParameterSet SemiAnalyticalModel::fVUVHitsParams

private

Definition at line 145 of file SemiAnalyticalModel.h.

size_t SemiAnalyticalModel::nOpDets

private

Definition at line 157 of file SemiAnalyticalModel.h.

---

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

• larsim/larsim/PhotonPropagation/SemiAnalyticalModel.h
• larsim/larsim/PhotonPropagation/SemiAnalyticalModel.cxx

---

Generated by   1.8.11