Implements an earth model with depth/latitude/longitude bins. More...

#include <EarthModelBinned.h>

Inheritance diagram for OscProb::EarthModelBinned:

Classes
struct	LatBinInfo
	A struct holding information about upcoming latitude bin crossings along the neutrino's trajectory. More...

struct	LonBinInfo
	A struct holding information about upcoming longitude bin crossings along the neutrino's trajectory. More...

Public Member Functions
	EarthModelBinned (std::string filename="")
	Constructor. More...

virtual	~EarthModelBinned ()
	Destructor. More...

void	SetDetPos (double rad, double lat=0, double lon=0)

int	FillPath (double cosT, double phi=0)

virtual void	LoadModel (std::string filename)
	Load an earth model from a file. More...

virtual std::vector< EarthBin >	GetEarthBins ()

virtual void	SetRegionZoA (int index, double zoa)
	Set Z/A of all bins with specified region index. More...

virtual double	GetRegionZoA (int index)
	Get Z/A of all bins with specified region index. More...

virtual void	ScaleRegionDensity (int index, double scalingfactor)

virtual std::vector< NuPath >	GetNuPath ()

virtual std::vector< NuPath >	GetMergedPaths (double prec=0.25)
	Get merged path sequence in a vector. More...

virtual double	GetTotalL (double cosT)
	Get the total baseline for a given cosTheta. More...

virtual double	GetCosT (double L)
	Get the cosTheta for a given total baseline. More...

virtual void	SetRemoveSmallPaths (bool rp=true)
	Set tag to remove small paths. More...

Protected Member Functions
virtual void	ClearModel ()
	Clear the earth model information. More...

virtual void	AddBin (double radius_out, double radius_in, double latitude, double longitude, double density, double zoa, double layer)
	Add a bin to the model (angles in degrees) More...

virtual void	AddPath (double length, EarthBin bin)
	Add a path segment to the sequence. More...

virtual double	DetDistForNextLatBin (int cur_index, LatBinInfo &L)

virtual double	DetDistForNextLonBin (double prev_lon, LonBinInfo &L)

virtual void	RecordLatLonBinCrossings (double detDist_nextDbin, double &DetDist, int &index, LatBinInfo &latI, LonBinInfo &lonI)

virtual int	LonBinIndex (double longitude)
	Find lon bin index containing longitude. More...

	ClassDef (EarthModelBinned, 1)

virtual void	SetDetectorCoordinates (double rad, double lat, double lon)

virtual void	AddPathSegment (double length, double density, double zoa, int index)
	Add a path segment to the sequence. More...

	ClassDef (EarthModelBase, 1)

Protected Attributes
TrajConstants	fC
	Useful constants for the trajectory. More...

std::vector< EarthBin >	fEarthBins
	The bins in the earth model. More...

int	fnDepthBins
	Total number of depth bins. More...

int	fnLonBins
	Total number of longitude bins. More...

int	fnLatBins
	Total number of latitude bins. More...

double	fInvLonBinWidth
	1/binwidth for each longitude bin More...

double	fInvLatBinWidth
	1/binwidth for each latitude bin More...

double	fHalfLonBinWidth
	Half-width of each longitude bin. More...

double	fHalfLatBinWidth
	Half-width of each latitude bin. More...

int	fmaxRegIndex
	Largest region index in model. More...

std::string	fErrorMessage_LonInfo

int	fLonError

std::vector< NuPath >	fNuPath
	The current neutrino path sequence. More...

double	fRadiusMax
	Maximum radius in Earth model (in km) More...

double	fDetRadius
	The radius where the detector sits (in km) More...

double	fDetLat
	The latitude (in rad) where the detector sits. More...

double	fDetLon
	The longitude (in rad) where the detector sits. More...

bool	fRemoveSmallPaths
	Tag whether to merge small paths. More...

Detailed Description

This class implements a 3D (asymmetric) model of the earth using EarthBin's to store bins with different properties.

The class is then able to produce path sequences through the Earth as a function of the azimuthal angle and cosine of the zenith angle with respect to the detector.

The detector can be positioned at any point within the Earth, and the path sequences will take into account the fact that some layers are above the detector.

Using indices to specify various regions (which must have a constant Z/A value), the Z/A value for a region can be changed, and the density throughout the region can be scaled by a constant factor.

By default this implements the model stored in EarthTables/earth_binned_default.txt with the detector at the bottom of the ocean layer (radius = 6368 km) where the prime meridian intersects the equator.

This class inherits from EarthModelBase and can be saved in ROOT files.

Author: rpestes@apc.in2p3.fr

Definition at line 201 of file EarthModelBinned.h.

Constructor & Destructor Documentation

◆ EarthModelBinned()

EarthModelBinned::EarthModelBinned ( std::string filename = "" )

Constructor.

By default this implements the model stored in EarthTables/earth_binned_default.txt with the detector 6368 km from the center of the Earth, having a latitude of 0 deg N and a longitude of 0 deg E.

Parameters

filename - The txt file containing a table of earth layers

Definition at line 121 of file EarthModelBinned.cxx.

{
  SetDetPos(6368, 0, 0);
  LoadModel(filename);
  SetRemoveSmallPaths(false);
  fLonError = 0;
}

References fLonError, LoadModel(), SetDetPos(), and OscProb::EarthModelBase::SetRemoveSmallPaths().

◆ ~EarthModelBinned()

EarthModelBinned::~EarthModelBinned ( )

virtual

Nothing to clean.

Definition at line 133 of file EarthModelBinned.cxx.

133{}

Member Function Documentation

◆ AddBin()

void EarthModelBinned::AddBin	(	double	radius_out,
		double	radius_in,
		double	latitude,
		double	longitude,
		double	density,
		double	zoa,
		double	index
	)

protectedvirtual

Add a bin to the earth model.

Parameters

radius_out	- The outer depth of the bin in km
radius_in	- The inner depth of the bin in km
latitude	- The latitude of the bin center in degrees
longitude	- The longitude of the bin center in degrees
density	- The density of the matter in the bin in g/cm^3
zoa	- The effective Z/A value of the matter in the bin
index	- Region index

Definition at line 187 of file EarthModelBinned.cxx.

{
  fEarthBins.push_back(EarthBin(radius_out, radius_in, latitude, longitude,
                                density, zoa, index));
}

References fEarthBins.

Referenced by LoadModel().

◆ AddPath()

void EarthModelBinned::AddPath	(	double	length,
		EarthBin	bin
	)

protectedvirtual

Add a path segment to the sequence.

For a given EarthBin, adds a path of a given length in that material

Parameters

length	- The length of the path segment in km
bin	- The bin we are crossing

Definition at line 433 of file EarthModelBinned.cxx.

{
  AddPathSegment(length, bin.density, bin.zoa, bin.index);
}

References OscProb::EarthModelBase::AddPathSegment(), OscProb::EarthBin::density, OscProb::EarthBin::index, and OscProb::EarthBin::zoa.

Referenced by FillPath(), and RecordLatLonBinCrossings().

◆ AddPathSegment()

void EarthModelBase::AddPathSegment	(	double	length,
		double	density,
		double	zoa,
		int	index
	)

protectedvirtualinherited

Add a path segment to the sequence.

For a given EarthBin, adds a path of a given length in that material

Parameters

length	- The length of the path segment in km
density	- The density along the path segment
zoa	- Z/A along the path segment
index	- Index for the matter along the path segment

Definition at line 65 of file EarthModelBase.cxx.

{
  fNuPath.push_back(NuPath(length, density, zoa, index));
}

References OscProb::EarthModelBase::fNuPath.

Referenced by AddPath(), and OscProb::PremModel::AddPath().

◆ ClassDef() [1/2]

OscProb::EarthModelBase::ClassDef	(	EarthModelBase	,
		1
	)

protectedinherited

◆ ClassDef() [2/2]

OscProb::EarthModelBinned::ClassDef	(	EarthModelBinned	,
		1
	)

protected

◆ ClearModel()

void EarthModelBinned::ClearModel ( )

protectedvirtual

Clear the earth model information.

Definition at line 147 of file EarthModelBinned.cxx.

{
  fnDepthBins = 0;
  fnLonBins   = 0;
  fnLatBins   = 0;
  fEarthBins.clear();
}

References fEarthBins, fnDepthBins, fnLatBins, and fnLonBins.

Referenced by LoadModel().

◆ DetDistForNextLatBin()

double EarthModelBinned::DetDistForNextLatBin	(	int	cur_index,
		LatBinInfo &	L
	)

protectedvirtual

Calculate the detector distance at the edge of the current lat bin along the neutrino's trajectory

Calculate the distance to the detector along a neutrino trajectory, specified by cosT and the azimuthal angle, at the edge of the current latitude bin in the direction specified by dir. Returns a negative value if the next latitude bin will not be reached before the neutrino reaches the detector. Flips L.sign and changes L.maxreached to true if the extreme latitude is within the cur_index Earth bin.

In an attempt to make this calculation more robust, this function turns the latitude bin iteration around when sin^2(lat) gets within 10^(-14) of its extreme limit.

Parameters

cur_index	- Index of current Earth bin
L	- Information for the lat bin crossings

Returns: Calculated detector distance

Definition at line 456 of file EarthModelBinned.cxx.

{
  // Find next lat bin boundary (bin center +/- 1/2-binwidth)
  double NewLat = fEarthBins[cur_index].latitude + L.sign * L.dLat;
  // Turn around if lat reaches +/- 90 degrees (or close enough)
  if (abs(NewLat) - 0.5 * M_PI > -1.0e-14) {
    if (L.maxreached) return -1; // Only turn around once
    L.maxreached = true;
    //    cout << "Max latitude reached..." << endl;
    L.sign = -L.sign;
    NewLat = fEarthBins[cur_index].latitude + L.sign * L.dLat;
    if (abs(NewLat) - 0.5 * M_PI > -1.0e-14)
      return -1; // This would happen if there's only one latitude bin...
  }
 
  // Calculate parts of answer
  double sinNewLat    = sin(NewLat);
  double NsinSqNewLat = -sinNewLat * sinNewLat;
  double radicand     = fC.maxSinSqLat +
                    NsinSqNewLat; // 1-[sin(NewLat)]^2-[sin(phi)cos(DetLat)]^2
  // Turn around if the radicand is 0 (close enough) or less
  if (radicand < 1.0e-14) {
    if (L.maxreached) return -1; // Only turn around once
    L.maxreached = true;
    //    cout << "Max latitude reached..." << endl;
    L.sign       = -L.sign;
    NewLat       = fEarthBins[cur_index].latitude + L.sign * L.dLat;
    sinNewLat    = sin(NewLat);
    NsinSqNewLat = -sinNewLat * sinNewLat;
    radicand     = fC.maxSinSqLat + NsinSqNewLat;
    if (radicand < 1.0e-14)
      return -1; // The rest of the track is contained in this lat bin
  }
  double denominator = fC.gammaSq + NsinSqNewLat;
 
  // Calculate distance from the detector at next lat bin boundary
  double answer;
  if (denominator == 0) {
    answer = 0.5 * (fC.xlatextreme - fC.rDetSinDetLat / fC.gamma);
    // There is a "possible" case where answer would be 0:
    //   if the detector is at the center of the Earth... just don't...
  }
  else {
    answer = -(fC.rDetCosT * NsinSqNewLat + fC.rDetGammaSinDetLat +
               L.sign * fC.rDetSinT * sinNewLat * sqrt(radicand)) /
             denominator;
  }
 
  // Check to see if going to the edge of the bin jumped to an invalid
  // part of the function (cosA*rDetCosDetLat/beta = x at max lat)
  if (L.maxreached && answer >= fC.xlatextreme) {
    return -1; // The rest of the track is contained in this lat bin
  }
 
  return answer;
}

References OscProb::EarthModelBinned::LatBinInfo::dLat, fC, fEarthBins, OscProb::TrajConstants::gamma, OscProb::TrajConstants::gammaSq, OscProb::EarthModelBinned::LatBinInfo::maxreached, OscProb::TrajConstants::maxSinSqLat, OscProb::TrajConstants::rDetCosT, OscProb::TrajConstants::rDetGammaSinDetLat, OscProb::TrajConstants::rDetSinDetLat, OscProb::TrajConstants::rDetSinT, OscProb::EarthModelBinned::LatBinInfo::sign, and OscProb::TrajConstants::xlatextreme.

Referenced by FillPath(), and RecordLatLonBinCrossings().

◆ DetDistForNextLonBin()

double EarthModelBinned::DetDistForNextLonBin	(	double	prev_lon,
		LonBinInfo &	L
	)

protectedvirtual

Calculate the detector distance at the edge of the current lon bin along the neutrino's trajectory and increment L.bin

Calculate the distance to the detector at the edge of the current longitude bin along a neutrino trajectory specified by cosT and the azimuthal angle, setting the index for the next longitude bin in the process. The maximum/minimum longitude are expressed around the 0-2pi boundary. So, if the track spans that boundary, the actual allowed range for lon is [min_lon,2pi)U[0,max_lon].

Parameters

prev_lon	- Value at center of initial longitude bin
L	- Information about longitude bin crossings

Returns: Calculated detector distance

Definition at line 526 of file EarthModelBinned.cxx.

{
  double twoPi = 2 * M_PI;
  // Increment to next bin in direction dLon
  double lon = prev_lon + L.dLon;
  if (lon < 0 || lon >= twoPi) { lon -= floor(lon / twoPi) * twoPi; }
  if (L.dLon > 0) {
    L.nextBin = L.bin + 1;
    if (L.nextBin >= fnLonBins) {
      // cross from 2pi to 0
      L.nextBin = 0;
    }
  }
  else {
    L.nextBin = L.bin - 1;
    if (L.nextBin < 0) {
      // cross from 0 to 2pi
      L.nextBin = fnLonBins - 1;
    }
  }
 
  // Check if lon is outside of range covered by neutrino's trajectory
  if (L.max < L.min) {
    if (0 > lon - L.min && L.max - lon < 0) return -1;
  }
  else {
    if (0 > lon - L.min || L.max - lon < 0) return -1;
  }
 
  // Parts of the answer
  double cosNewLon   = cos(lon);
  double sinNewLon   = sin(lon);
  double expression  = fC.sinDetLon * cosNewLon - sinNewLon * fC.cosDetLon;
  double denominator = fC.alpha * expression +
                       fC.sinTsinAcosDetLon * cosNewLon +
                       fC.sinTsinAsinDetLon * sinNewLon;
 
  // Calculate & return detector distance
  if (denominator == 0) { // Is there ever a case when this is true???
    // Error message will be printed at the end of the FillPath function
    L.err_message.assign("Longitude along neutrino trajectory = " +
                         std::to_string(lon));
    L.error = -1;
    return -1;
  }
  return fC.rDetCosDetLat * expression / denominator;
}

References OscProb::TrajConstants::alpha, OscProb::EarthModelBinned::LonBinInfo::bin, OscProb::TrajConstants::cosDetLon, OscProb::EarthModelBinned::LonBinInfo::dLon, OscProb::EarthModelBinned::LonBinInfo::err_message, OscProb::EarthModelBinned::LonBinInfo::error, fC, fnLonBins, OscProb::EarthModelBinned::LonBinInfo::max, OscProb::EarthModelBinned::LonBinInfo::min, OscProb::EarthModelBinned::LonBinInfo::nextBin, OscProb::TrajConstants::rDetCosDetLat, OscProb::TrajConstants::sinDetLon, OscProb::TrajConstants::sinTsinAcosDetLon, and OscProb::TrajConstants::sinTsinAsinDetLon.

Referenced by FillPath(), and RecordLatLonBinCrossings().

◆ FillPath()

int EarthModelBinned::FillPath	(	double	cosT,
		double	phi = `0`
	)

virtual

Fill the path sequence in a vector (phi in degrees)

Fill the path sequence in a vector.

This will start at the upper-most layer (where the neutrino's path started) and find path lengths to the next bin crossed. When reaching the inner-most depth in the given direction, the paths move back to outer layers until hitting the detector. The neutrino direction is specified as the zenith angle and azimuthal angle of the vector pointing from the detector to where the neutrino entered the Earth.

The path sequence is stored as an attribute and can be retrieved with the function GetNuPath.

Note: This function assumes uniform bin sizes for the latitude bins and the longitude bins.

Parameters

cosT	- The cosine of the zenith angle of the neutrino direction
phi	- The azimuthal angle (in degrees from North) of the neutrino direction

Returns: The number of path segments in the sequence

Implements OscProb::EarthModelBase.

Definition at line 691 of file EarthModelBinned.cxx.

{
  // Clear current path sequence
  fNuPath.clear();
 
  // Do nothing if cosine is unphysical
  if (fabs(cosT) > 1) return 0;
 
  // Calculate useful combinations of variables
  double Az = phi / 180.0 * M_PI; // convert from degrees to radians
  fC.UpdateNuAngles(cosT, Az);
  fC.Recalculate();
  double rDetSqSinSqT = pow(fC.rDetSinT, 2);
  double distEdgeToMin =
      sqrt(fRadiusMax * fRadiusMax -
           rDetSqSinSqT); // distance from point where neutrino enters to
                          // minimum depth (neglecting stopping at the detector)
  double baseline = distEdgeToMin - fC.rDetCosT; // total baseline
 
  // Define the maximum depth (minimum radius) along the path (detector
  // depth/radius, if cosT is non-negative)
  double minRadius = fDetRadius;
  if (cosT < 0) { minRadius = fC.rDetSinT; }
 
  // Starting latitude
  /*  cout << "Pieces of init_lat calculation:" << endl
         << "\trDetSinT = " << fC.rDetSinT << endl
         << "\tbeta = " << fC.beta << endl
         << "\tgamma = " << fC.gamma << endl
         << "\tdistEdgeToMin = " << distEdgeToMin << endl
         << "\tRadiusMax = " << fRadiusMax << endl; */
  double init_lat = asin((fC.rDetSinT * fC.beta + fC.gamma * distEdgeToMin) /
                         fRadiusMax); // in radians
 
  // Starting longitude
  double init_lon = atan2(
      fC.sinDetLon * fC.rDetCosDetLat -
          baseline * (fC.alpha * fC.sinDetLon + fC.sinTsinAcosDetLon),
      fC.cosDetLon * fC.rDetCosDetLat +
          baseline *
              (fC.sinTsinAsinDetLon -
               fC.alpha * fC.cosDetLon)); // in radians (between -M_PI and M_PI)
  if (init_lon < 0) { init_lon += 2 * M_PI; }
 
  // Get initial Earth bin and # of bins per depth layer
  LatBinInfo latinfo;
  LonBinInfo loninfo;
  int        binsPerDepth = fEarthBins.size() / fnDepthBins;
  int        init_lonBin  = LonBinIndex(init_lon);
  int        init_latBin  = floor((init_lat + M_PI / 2.0) * fInvLatBinWidth);
  int        index =
      fEarthBins.size() - binsPerDepth + init_lonBin * fnLatBins + init_latBin;
 
  latinfo.bin = init_latBin;
  loninfo.bin = init_lonBin;
  //  cout << "Neutrino starting at (lat,lon)=(" << init_lat << "rad," <<
  //  init_lon << "rad) in Earth bin " << index << " = (r" <<
  //  floor(index/binsPerDepth) << ", lon" << loninfo.bin << ", lat" <<
  //  latinfo.bin << ")" << endl;
 
  /* Find detector distances for 1st latitude/longitude bin changes */
  latinfo.dLat = fHalfLatBinWidth; // change in lat from bin center to next bin
                                   // (0 if no more than 1 lat bin change)
  // Condition calculation for starting sign in x(lat) equation
  latinfo.sign = 1; //+ => lat incr., - => lat decr. (with decr. x)
  latinfo.maxreached =
      false; // this changes to true if past the lat func transition
  if (fC.beta < 0) latinfo.sign = -1;
  if (fC.beta == 0) {
    if (fC.cosA > 0) latinfo.sign = -1;
  }
  else if (baseline < fC.xlatextreme) {
    latinfo.sign       = -(latinfo.sign);
    latinfo.maxreached = true;
  }
  // Condition calculation for incr./decr. Longitude (with decr. x)
  loninfo.dLon =
      fHalfLonBinWidth;   // change in lon from bin center to next bin (includes
                          // direction; 0 if no more than 1 lon bin change)
  loninfo.min = init_lon; // initial lon if lon is inc.
  loninfo.max = fDetLon;  // detector lon if lon is inc.
  if (fC.sinA < 0) {
    loninfo.dLon = -(loninfo.dLon);
    loninfo.min  = loninfo.max;
    loninfo.max  = init_lon;
    // Switch max/min if dec., instead of inc.
    loninfo.max = init_lon;
    loninfo.min = fDetLon;
  }
  // Remainder of detDist (and nextBin) calculations
  if (fC.sinT == 0) {
    // both latitude and logitude flip at center of the Earth
    loninfo.detDist_nextBin =
        -fC.rDetCosT; // formula is divided by cosT, but cosT = +-1
    loninfo.nextBin         = LonBinIndex(fDetLon);
    loninfo.dLon            = 0;
    latinfo.detDist_nextBin = loninfo.detDist_nextBin;
    latinfo.nextBin         = floor((fDetLat + 0.5 * M_PI) * fInvLatBinWidth);
    latinfo.dLat            = 0;
  }
  else {
    if (fC.sinA == 0) {
      if (fC.alpha == 0) { // crosses "at" infinity
        loninfo.detDist_nextBin = -1;
      }
      else { // longitude flips at center of the Earth
        loninfo.detDist_nextBin = fC.rDetCosDetLat / fC.alpha;
        loninfo.nextBin         = LonBinIndex(fDetLon);
      }
      loninfo.dLon = 0;
    }
    else if (fC.cosDetLat == 0) {
      loninfo.detDist_nextBin = -1;
    }
    else {
      // x(lon) calculation
      loninfo.detDist_nextBin = DetDistForNextLonBin(
          fEarthBins[index].longitude, loninfo); // also sets loninfo.nextBin
    }
    // x(lat) calculation
    latinfo.detDist_nextBin = DetDistForNextLatBin(index, latinfo);
    latinfo.nextBin         = init_latBin + latinfo.sign;
  }
 
  // Get initial Detector Distance
  double prev_DetDistance = baseline;
 
  /* Start at the top layer of Earth model and go down to minimum (not including
   * minimum), looping over depth bins */
  int dBin = 0; // depth bin index
  for (dBin = 0; dBin < fnDepthBins - 1; dBin++) {
    // Check if minimum radius is contained in depth bin
    double r_in = fEarthBins[index].radius_in; // inner-most radius
    if (r_in < minRadius) break;
 
    // Distance from detector at inner-most radius
    double DetDistance = -fC.rDetCosT + sqrt(r_in * r_in - rDetSqSinSqT);
 
    // Check for latitude/longitude bin crossings
    RecordLatLonBinCrossings(DetDistance, prev_DetDistance, index, latinfo,
                             loninfo);
 
    // Add Segment to next depth bin to path
    AddPath(prev_DetDistance - DetDistance, fEarthBins[index]);
 
    // Reset variables for next depth bin
    prev_DetDistance = DetDistance;
    index -= binsPerDepth;
    //    cout << "Depth bin crossing at x=" << DetDistance << "km...now in
    //    Earth bin " << index << " = (r" << floor(index/binsPerDepth) << ",
    //    lon" << loninfo.bin << ", lat" << latinfo.bin << ")" << endl;
  }
 
  /* Do minimum depth bin and then go up to the detector */
  int index2 = index;
  for (index2 = index; fEarthBins[index2].radius_out < fDetRadius;
       index2 += binsPerDepth) {
    double r_out = fEarthBins[index2].radius_out; // outer-most radius
 
    // Distance from detector at outer-most radius
    double DetDistance = -fC.rDetCosT - sqrt(r_out * r_out - rDetSqSinSqT);
 
    // Check for latitude/longitude bin crossings
    RecordLatLonBinCrossings(DetDistance, prev_DetDistance, index2, latinfo,
                             loninfo);
 
    // Add Segment in depth bin to path
    AddPath(prev_DetDistance - DetDistance, fEarthBins[index2]);
 
    // Reset variables for "previous" depth bin
    prev_DetDistance = DetDistance;
    //    cout << "Depth bin crossing at x=" << DetDistance << "km...now in
    //    Earth bin " << index2 << " = (r" <<
    //    floor((index2+binsPerDepth)/binsPerDepth) << ", lon" << loninfo.bin <<
    //    ", lat" << latinfo.bin << ")" << endl;
  }
 
  /* Do path to detector */
  // Check for latitude/longitude bin crossings
  RecordLatLonBinCrossings(0, prev_DetDistance, index2, latinfo, loninfo);
  // Add the path segment within the detector bin
  AddPath(prev_DetDistance, fEarthBins[index2]);
 
  // Longitude calculation error message, if needed
  if (loninfo.error < 0) {
    cerr
        << "ERROR:  Oops... It turns out that I was wrong about the denominator"
        << " of the x(long) equation never being 0 apart from the cases where "
        << "sin(Zenith) = 0, sin(Azimuthal) = 0, or cos(Detector Longitude) = "
        << "0."
        << "  Send the following message to rpestes@apc.in2p3.fr:" << endl
        << endl
        << "You were wrong about the denominator of x(long)... "
        << "Here are the values of the variables that broke it:" << endl
        << "\tDetector Coordinates (r,lat,lon) = (" << fDetRadius << ", "
        << fDetLat << ", " << fDetLon << ")" << endl
        << "\tcos(Zenith Angle) = " << cosT << endl
        << "\tAzimuthal Angle = " << phi << " deg" << endl
        << "\t" << loninfo.err_message << endl
        << "Please fix this ASAP!" << endl;
    return -1;
  }
 
  // Return the number of path segments
  return fNuPath.size();
}

◆ GetCosT()

double EarthModelBase::GetCosT ( double L )

virtualinherited

Get the cosTheta for a given total baseline.

Given a baseline, find the direction of the neutrino. This could be useful for experiments with fixed baselines for example.

The baseline must be within the range of possible values in this earth model. Will return vertical neutrinos otherwise.

Parameters

L	- The total baseline of the neutrino

Definition at line 99 of file EarthModelBase.cxx.

{
  if (L < fRadiusMax - fDetRadius) return 1;
  if (L > fRadiusMax + fDetRadius) return -1;
 
  return (fRadiusMax * fRadiusMax - fDetRadius * fDetRadius - L * L) /
         (2 * fDetRadius * L);
}

References OscProb::EarthModelBase::fDetRadius, and OscProb::EarthModelBase::fRadiusMax.

◆ GetEarthBins()

vector< EarthBin > EarthModelBinned::GetEarthBins ( )

virtual

Get the set of earth layers

Get the set of Earth bins

This returns the set of bins for this Earth model.

Definition at line 141 of file EarthModelBinned.cxx.

141{ return fEarthBins; }

References fEarthBins.

◆ GetMergedPaths()

vector< NuPath > EarthModelBase::GetMergedPaths ( double prec = 0.25 )

virtualinherited

Merge similar paths to reduce number of steps

This method will merge consecutive paths and take their averages until it finds a large enough gap to start a new merged path.

The merged paths will be returned, and the original detailed path will not be changed and will stay stored as an attribute.

Parameters

prec	- The precision to merge paths in g/cm^3

Returns: The vector of merged path segments

Definition at line 121 of file EarthModelBase.cxx.

{
  // The output vector
  vector<NuPath> mergedPath;
 
  // Start with the first path
  NuPath path = fNuPath[0];
 
  // Track the total length
  double totL = 0;
 
  // Loop over all paths starting from second
  for (int i = 1; i < fNuPath.size(); i++) {
    // If this path electron density is beyond the tolerance
    if (fabs(path.density * path.zoa - fNuPath[i].density * fNuPath[i].zoa) >
        prec * path.zoa) {
      // Add merged path to vector
      mergedPath.push_back(path);
 
      // Set this path as new merged path
      path = fNuPath[i];
    }
    else { // If path is within tolerance
 
      // Merge the path with current merged path
      path = AvgPath(path, fNuPath[i]);
    }
 
    // Increment total length
    totL += fNuPath[i].length;
 
  } // End of loop over paths
 
  // Add the final merged path to vector
  mergedPath.push_back(path);
 
  // If tag is true, remove small paths
  if (fRemoveSmallPaths) {
    // Start at first path
    int k = 0;
 
    // While not at the end of vector
    while (k + 1 < mergedPath.size()) {
      // If length is less than 1% of total
      if (mergedPath[k].length < 0.01 * totL) {
        // Merge path with following path
        mergedPath = MergePaths(mergedPath, k, k + 1);
      }
      // If path is long enough skip it
      else
        k++;
 
    } // End of while loop
 
  } // End of if statement
 
  // return the merged vector
  return mergedPath;
}

References OscProb::AvgPath(), OscProb::NuPath::density, OscProb::EarthModelBase::fNuPath, OscProb::EarthModelBase::fRemoveSmallPaths, OscProb::MergePaths(), and OscProb::NuPath::zoa.

◆ GetNuPath()

vector< NuPath > EarthModelBase::GetNuPath ( )

virtualinherited

Get the current neutrino path sequence

The path needs to be filled for a given cosTheta before calling this function.

Definition at line 52 of file EarthModelBase.cxx.

52{ return fNuPath; }

References OscProb::EarthModelBase::fNuPath.

Referenced by OscProb::PMNS_Avg::AvgAlgo(), OscProb::PMNS_Avg::AvgAlgoCosT(), and OscProb::PMNS_Avg::ExtrapolationProbCosT().

◆ GetRegionZoA()

double EarthModelBinned::GetRegionZoA ( int index )

virtual

Get the effective Z/A value for all bins in region specified by index, e.g. all outer-core layers. (Assumes that all bins of given index have same Z/A value)

Parameters

index - The region index

Returns: Z/A corresponding to index

Definition at line 372 of file EarthModelBinned.cxx.

{
  if (index > fmaxRegIndex) {
    cerr << "ERROR: Index " << index << " does not exist in model "
         << "(max index = " << fmaxRegIndex << "). Returning 0" << endl;
    return 0;
  }
 
  int nbins = fEarthBins.size();
 
  for (int i = 0; i < nbins; i++) {
    if (fEarthBins[i].index != index)
      continue;
 
    else
      return fEarthBins[i].zoa;
  }
 
  // End of vector reached without finding index
  cerr << "ERROR: Index " << index << " not found! Returning 0" << endl;
  return 0;
}

References fEarthBins, and fmaxRegIndex.

◆ GetTotalL()

double EarthModelBase::GetTotalL ( double cosT )

virtualinherited

Get the total baseline for a given cosTheta.

Parameters

cosT	- The cosine of the neutrino direction

Definition at line 77 of file EarthModelBase.cxx.

{
  if (fabs(cosT) > 1) return 0;
 
  double sinsqrT = 1 - cosT * cosT;
 
  return -fDetRadius * cosT +
         sqrt(fRadiusMax * fRadiusMax - fDetRadius * fDetRadius * sinsqrT);
}

References OscProb::EarthModelBase::fDetRadius, and OscProb::EarthModelBase::fRadiusMax.

◆ LoadModel()

void EarthModelBinned::LoadModel ( std::string filename )

virtual

Load an earth model from a file.

By default it loads the model stored in EarthTables/earth_binned_default.txt

The row format for the model table needs to be: longitude (deg) latitude (deg) outer depth (km) density (g/cm^3?) Z/A region_index The data in the table must be in order of decreasing depth, followed by increasing longitude, and then increasing latitude. Latitude bin widths and longitude bin widths must each be constant. In each bin of one coordinate, the bins centers for the other coordinates must be the same. This assumes that the center of the Earth is at a depth of 6371km.

Parameters

filename - The txt file containing a table of earth layers

Definition at line 214 of file EarthModelBinned.cxx.

{
  // Clear the current model
  ClearModel();
  double EarthRadius = 6371.0;
 
  // Use default if no file provided
  if (filename == "") { filename = PREM3D_DEFAULT; }
  cout << "Loading Earth model table from " << filename << "..." << endl;
 
  // Open the file
  ifstream fin;
  fin.open(filename.c_str());
  if (!fin) {
    cerr << "ERROR: File " << filename << " not found!" << endl;
    return;
  }
 
  // Variables for storing table rows
  float depth, latitude, longitude, density, zoa, index;
 
  // Keep track of previous depth/latitude/longitude
  double radius_prev = 0;
  double lat_prev    = -90.0;
  double lon_prev    = 0;
 
  // Hold onto previous different depth, so we have depth maximum for bin
  double radius_min = radius_prev;
 
  // Initialize max region index
  fmaxRegIndex = -1;
 
  // Loop over table rows
  while (fin >> longitude >> latitude >> depth >> density >> zoa >> index) {
    double outer_radius = EarthRadius - depth;
 
    // Move minimum depth (and reset latitude/longitude) if depth has changed
    // from previous one
    if (outer_radius > radius_prev) {
      radius_min = radius_prev;
      lat_prev   = -90.0;
      lon_prev   = 0.0;
      fnDepthBins++;
    }
    else if (outer_radius <
             radius_prev) { // Depths must be ordered in model file
      cerr << "ERROR: Depths are not sorted in decreasing order in the model "
              "file "
           << "(or depth is greater than " << EarthRadius << " km)." << endl;
      ClearModel();
      return;
    }
    else if (longitude > lon_prev) { // Reset latitude if longitude has changed
                                     // from previous one
      lat_prev = -90.0;
      fnLonBins++;
    }
    else if (longitude < lon_prev) { // Longitudes must be ordered in model file
                                     // (after depths)
      cerr << "ERROR: Longitudes are not sorted in increasing order (after "
              "depths) in the model file."
           << endl;
      ClearModel();
      return;
    }
    else if (latitude < lat_prev) { // Latitudes must be ordered in model file
                                    // (after longitudes)
      cerr << "ERROR: Latitudes are not sorted in increasing order (after "
              "longitudes) in the model file."
           << endl;
      ClearModel();
      return;
    }
 
    // Add this bin to the model
    AddBin(outer_radius, radius_min, latitude, longitude, density, zoa, index);
 
    // Check region index
    if (index > fmaxRegIndex) { fmaxRegIndex = index; }
 
    // Set previous coordinates for next bin
    radius_prev = outer_radius;
    lat_prev    = latitude;
    lon_prev    = longitude;
  }
 
  // Set Outermost Radius
  fRadiusMax = radius_prev;
 
  // Modify number of longitude bins to how many there actually are (instead of
  // how many times we changed the longitude bin without changing the depth bin
  // = nLonBins-1 times per depth bin)
  fnLonBins        = fnLonBins / fnDepthBins + 1;
  fInvLonBinWidth  = 0.5 * fnLonBins / M_PI; // in radians^(-1)
  fHalfLonBinWidth = M_PI / fnLonBins;       // in radians
 
  // Calculate number of latitude bins
  fnLatBins        = fEarthBins.size() / (fnLonBins * fnDepthBins);
  fInvLatBinWidth  = fnLatBins / M_PI;       // in radians^(-1)
  fHalfLatBinWidth = 0.5 * M_PI / fnLatBins; // in radians
 
  // Error if first latitude bin center deviates from about half of the
  // calculated latitude bin width
  if (abs(fHalfLatBinWidth - (fEarthBins[0].latitude + 0.5 * M_PI)) >
      fHalfLatBinWidth * 0.01) { // Warn if first latitude bin center isn't
                                 // about half of the latitude bin width
    cerr << "ERROR: Latitude of 1st bin center (" << fEarthBins[0].latitude
         << ") is not in the middle of the first bin, whose size should be "
         << 2 * fHalfLatBinWidth << " rad, as calculated from having "
         << fnLatBins << " latitude bins." << endl;
    ClearModel();
    return;
  }
 
  cout << "\t...done (" << fEarthBins.size() << " bins: " << fnDepthBins
       << " depth, " << fnLatBins << " latitude, and " << fnLonBins
       << " longitude)." << endl;
}

References AddBin(), ClearModel(), fEarthBins, fHalfLatBinWidth, fHalfLonBinWidth, fInvLatBinWidth, fInvLonBinWidth, fmaxRegIndex, fnDepthBins, fnLatBins, fnLonBins, and OscProb::EarthModelBase::fRadiusMax.

Referenced by EarthModelBinned().

◆ LonBinIndex()

int EarthModelBinned::LonBinIndex ( double longitude )

protectedvirtual

Find and return longitude bin index that contains longitude.

Parameters

longitude - longitude for which bin is found

Definition at line 655 of file EarthModelBinned.cxx.

{
  // Find difference between longitude and beginning of first lon bin
  double londiff = longitude - (fEarthBins[0].longitude - fHalfLonBinWidth);
 
  // Shift londiff to be between 0 and 2pi
  if (londiff < 0 || londiff >= 2 * M_PI)
    londiff -= floor(londiff / (2 * M_PI));
 
  // Number of binwidths after from first lon bin
  return floor(londiff * fInvLonBinWidth);
}

References fEarthBins, fHalfLonBinWidth, and fInvLonBinWidth.

Referenced by FillPath().

◆ RecordLatLonBinCrossings()

void EarthModelBinned::RecordLatLonBinCrossings	(	double	detDist_nextDbin,
		double &	DetDist,
		int &	index,
		LatBinInfo &	latI,
		LonBinInfo &	lonI
	)

protectedvirtual

Record path segments for each latitude/longitude bin crossed before reaching detDist_nextDbin

Record all the path segments as the neutrino crosses into new latitude and longitude bins until it reaches the next depth bin.

Parameters

detDist_nextDbin	- Distance from the detector at which neutrino passes into next depth bin
DetDist	- Current distance from the detector
index	- Index of current Earth bin
latI	- Information about lat bin crossings
lonI	- Information about lon bin crossings

Definition at line 586 of file EarthModelBinned.cxx.

{
  // Keep going as long as there is a lat or lon bin crossing before
  // the next depth bin crossing
  while (detDist_nextDbin < latI.detDist_nextBin ||
         detDist_nextDbin < lonI.detDist_nextBin) {
    if (latI.detDist_nextBin >
        lonI.detDist_nextBin) { // if next lat bin crossing is before next lon
                                // bin crossing
      // Add segment to next lat bin to path
      AddPath(DetDist - latI.detDist_nextBin, fEarthBins[index]);
      double latitude_crossing =
          fEarthBins[index].latitude + latI.sign * latI.dLat;
 
      // Move lat bins
      DetDist = latI.detDist_nextBin;
      index += latI.nextBin - latI.bin;
      latI.bin = latI.nextBin;
      //      cout << "Latitude bin crossing at x=" << DetDist << "km,lat=" <<
      //      latitude_crossing << "rad...now in Earth bin " << index << " = (r"
      //      << floor(index/(fnLonBins*fnLatBins)) << ", lon" << lonI.bin << ",
      //      lat" << latI.bin << ")" << endl;
 
      // Find next lat bin
      if (latI.dLat ==
          0) { // Only 1 lat bin crossing along entire neutrino trajectory
        latI.detDist_nextBin = -1;
      }
      else {
        latI.detDist_nextBin = DetDistForNextLatBin(index, latI);
        latI.nextBin         = latI.bin + latI.sign;
      }
    }
    else { // if next lon bin crossing is before (or simultaneous with) next lat
           // bin corssing
      // Add segment to next lon bin to path
      AddPath(DetDist - lonI.detDist_nextBin, fEarthBins[index]);
 
      // Move lon bins
      DetDist = lonI.detDist_nextBin;
      index += (lonI.nextBin - lonI.bin) * fnLatBins;
      lonI.bin = lonI.nextBin;
      //      cout << "Longitude bin crossing at x=" << DetDist << "km...now in
      //      Earth bin " << index << " = (r" <<
      //      floor(index/(fnLonBins*fnLatBins)) << ", lon" << lonI.bin << ",
      //      lat" << latI.bin << ")" << endl;
 
      // Find next lon bin
      if (lonI.dLon ==
          0) { // Only 1 lon bin crossing along entire neutrino trajectory
        lonI.detDist_nextBin = -1;
      }
      else {
        lonI.detDist_nextBin =
            DetDistForNextLonBin(fEarthBins[index].longitude, lonI);
      }
    }
  }
}

Referenced by FillPath().

◆ ScaleRegionDensity()

void EarthModelBinned::ScaleRegionDensity	(	int	index,
		double	factor
	)

virtual

Set Z/A of all bins with specified region index

Scale density by scaling factor for all bins in region specified by given index.

Parameters

index	- The region index
factor	- The scaling factor for changing the density

Definition at line 403 of file EarthModelBinned.cxx.

{
  if (index > fmaxRegIndex) {
    cerr << "WARNING: Index " << index << " does not exist in model "
         << "(max index = " << fmaxRegIndex << ")." << endl
         << "Doing nothing." << endl;
    return;
  }
 
  int nbins = fEarthBins.size();
 
  // Loop over all bins and change the ones
  // with the given index
  for (int i = 0; i < nbins; i++) {
    if (fEarthBins[i].index != index) continue;
 
    double density_init   = fEarthBins[i].density;
    fEarthBins[i].density = factor * density_init;
  }
}

References fEarthBins, and fmaxRegIndex.

◆ SetDetectorCoordinates()

void EarthModelBase::SetDetectorCoordinates	(	double	rad,
		double	lat,
		double	lon
	)

protectedvirtualinherited

Set the coordinates of the detector (rad = radius in km, lat/lon in deg)

Set the coordinates of the detector: radius in km, latitude in degrees, longitude in degrees

Parameters

rad	- The distance from the detector to the Earth's center in km
lat	- The latitude of the detector in deg N (between -90 and 90)
lon	- The longitude of the detector in deg E (between 0 and 360)

Definition at line 25 of file EarthModelBase.cxx.

{
  // Force radius to be non-negative
  if (rad < 0) {
    cerr << "WARNING: Negative radius detected. Setting to absolute value."
         << endl;
    rad = -rad;
  }
  fDetRadius = rad;
 
  // Force latitude to be between -90 and 90 deg
  lat -= floor((lat + 90.0) / 360.0) * 360.0;
  if (lat > 90) { lat = 180.0 - lat; }
  fDetLat = lat / 180.0 * M_PI; // convert to radians
 
  // Force longitude to be between 0 and 360 deg
  lon -= floor(lon / 360.0) * 360.0;
  fDetLon = lon / 180.0 * M_PI; // convert to radians
}

References OscProb::EarthModelBase::fDetLat, OscProb::EarthModelBase::fDetLon, and OscProb::EarthModelBase::fDetRadius.

Referenced by SetDetPos(), and OscProb::PremModel::SetDetPos().

◆ SetDetPos()

void EarthModelBinned::SetDetPos	(	double	rad,
		double	lat = `0`,
		double	lon = `0`
	)

virtual

Set the detector position (rad = radius in km, lat/lon in deg)

Set the coordinates of the detector: radius in km, latitude in degrees, longitude in degrees Also, updates the detector-coordinate-dependent parts of the trajectory constants.

Note: If lat = -90 (or 90), lon (or -lon) defines where the azimuthal angle for the neutrino's trajectory is 0.

Parameters

rad	- The distance from the detector to the Earth's center in km
lat	- The latitude of the detector in deg N (between -90 and 90)
lon	- The longitude of the detector in deg E (between 0 and 360)

Implements OscProb::EarthModelBase.

Definition at line 169 of file EarthModelBinned.cxx.

{
  SetDetectorCoordinates(rad, lat, lon);
  fC.UpdateDetPos(fDetRadius, fDetLat, fDetLon);
}

References fC, OscProb::EarthModelBase::fDetLat, OscProb::EarthModelBase::fDetLon, OscProb::EarthModelBase::fDetRadius, OscProb::EarthModelBase::SetDetectorCoordinates(), and OscProb::TrajConstants::UpdateDetPos().

Referenced by EarthModelBinned().

◆ SetRegionZoA()

void EarthModelBinned::SetRegionZoA	(	int	index,
		double	zoa
	)

virtual

Set the effective Z/A value for all bins with given region index.

Use this to change the Z/A of indexed bin, e.g. all outer-core layers

Parameters

index	- The region index
zoa	- The effective Z/A value to use

Definition at line 343 of file EarthModelBinned.cxx.

{
  if (index > fmaxRegIndex) {
    cerr << "WARNING: Index " << index << " does not exist in model "
         << "(max index = " << fmaxRegIndex << ")." << endl
         << "Doing nothing." << endl;
    return;
  }
 
  int nbins = fEarthBins.size();
 
  // Loop over all bins and change the ones
  // with the given index
  for (int i = 0; i < nbins; i++) {
    if (fEarthBins[i].index != index) continue;
 
    fEarthBins[i].zoa = zoa;
  }
}

References fEarthBins, and fmaxRegIndex.

◆ SetRemoveSmallPaths()

void EarthModelBase::SetRemoveSmallPaths ( bool rp = true )

virtualinherited

Set the boolean to tag whether to remove small paths when merging Small is defined as <1% of the total baseline

Parameters

rp	- Boolean value to set

Definition at line 188 of file EarthModelBase.cxx.

188{ fRemoveSmallPaths = rp; }

References OscProb::EarthModelBase::fRemoveSmallPaths.

Referenced by EarthModelBinned(), and OscProb::PremModel::PremModel().

Member Data Documentation

◆ fC

TrajConstants OscProb::EarthModelBinned::fC

protected

Definition at line 304 of file EarthModelBinned.h.

Referenced by DetDistForNextLatBin(), DetDistForNextLonBin(), FillPath(), and SetDetPos().

◆ fDetLat

double OscProb::EarthModelBase::fDetLat

protectedinherited

Definition at line 78 of file EarthModelBase.h.

Referenced by FillPath(), OscProb::EarthModelBase::SetDetectorCoordinates(), and SetDetPos().

◆ fDetLon

double OscProb::EarthModelBase::fDetLon

protectedinherited

Definition at line 79 of file EarthModelBase.h.

Referenced by FillPath(), OscProb::EarthModelBase::SetDetectorCoordinates(), and SetDetPos().

◆ fDetRadius

double OscProb::EarthModelBase::fDetRadius

protectedinherited

Definition at line 77 of file EarthModelBase.h.

Referenced by OscProb::PremModel::AddDetLayer(), FillPath(), OscProb::PremModel::FillPath(), OscProb::EarthModelBase::GetCosT(), OscProb::PremModel::GetDetRadius(), OscProb::EarthModelBase::GetTotalL(), OscProb::EarthModelBase::SetDetectorCoordinates(), and SetDetPos().

◆ fEarthBins

std::vector<EarthBin> OscProb::EarthModelBinned::fEarthBins

protected

Definition at line 306 of file EarthModelBinned.h.

Referenced by AddBin(), ClearModel(), DetDistForNextLatBin(), FillPath(), GetEarthBins(), GetRegionZoA(), LoadModel(), LonBinIndex(), RecordLatLonBinCrossings(), ScaleRegionDensity(), and SetRegionZoA().

◆ fErrorMessage_LonInfo

std::string OscProb::EarthModelBinned::fErrorMessage_LonInfo

protected

Part of error message containing the longitude information

Definition at line 318 of file EarthModelBinned.h.

◆ fHalfLatBinWidth

double OscProb::EarthModelBinned::fHalfLatBinWidth

protected

Definition at line 313 of file EarthModelBinned.h.

Referenced by FillPath(), and LoadModel().

◆ fHalfLonBinWidth

double OscProb::EarthModelBinned::fHalfLonBinWidth

protected

Definition at line 312 of file EarthModelBinned.h.

Referenced by FillPath(), LoadModel(), and LonBinIndex().

◆ fInvLatBinWidth

double OscProb::EarthModelBinned::fInvLatBinWidth

protected

Definition at line 311 of file EarthModelBinned.h.

Referenced by FillPath(), and LoadModel().

◆ fInvLonBinWidth

double OscProb::EarthModelBinned::fInvLonBinWidth

protected

Definition at line 310 of file EarthModelBinned.h.

Referenced by LoadModel(), and LonBinIndex().

◆ fLonError

int OscProb::EarthModelBinned::fLonError

protected

Definition at line 320 of file EarthModelBinned.h.

Referenced by EarthModelBinned().

◆ fmaxRegIndex

int OscProb::EarthModelBinned::fmaxRegIndex

protected

Definition at line 315 of file EarthModelBinned.h.

Referenced by GetRegionZoA(), LoadModel(), ScaleRegionDensity(), and SetRegionZoA().

◆ fnDepthBins

int OscProb::EarthModelBinned::fnDepthBins

protected

Definition at line 307 of file EarthModelBinned.h.

Referenced by ClearModel(), FillPath(), and LoadModel().

◆ fnLatBins

int OscProb::EarthModelBinned::fnLatBins

protected

Definition at line 309 of file EarthModelBinned.h.

Referenced by ClearModel(), FillPath(), LoadModel(), and RecordLatLonBinCrossings().

◆ fnLonBins

int OscProb::EarthModelBinned::fnLonBins

protected

Definition at line 308 of file EarthModelBinned.h.

Referenced by ClearModel(), DetDistForNextLonBin(), and LoadModel().

◆ fNuPath

std::vector<NuPath> OscProb::EarthModelBase::fNuPath

protectedinherited

Definition at line 74 of file EarthModelBase.h.

Referenced by OscProb::EarthModelBase::AddPathSegment(), FillPath(), OscProb::PremModel::FillPath(), OscProb::EarthModelBase::GetMergedPaths(), and OscProb::EarthModelBase::GetNuPath().

◆ fRadiusMax

double OscProb::EarthModelBase::fRadiusMax

protectedinherited

Definition at line 76 of file EarthModelBase.h.

Referenced by FillPath(), OscProb::EarthModelBase::GetCosT(), OscProb::EarthModelBase::GetTotalL(), LoadModel(), OscProb::PremModel::LoadModel(), and OscProb::PremModel::SetTopLayerSize().

◆ fRemoveSmallPaths

bool OscProb::EarthModelBase::fRemoveSmallPaths

protectedinherited

Definition at line 81 of file EarthModelBase.h.

Referenced by OscProb::EarthModelBase::GetMergedPaths(), and OscProb::EarthModelBase::SetRemoveSmallPaths().

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

inc/EarthModelBinned.h
src/EarthModelBinned.cxx

Classes

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ EarthModelBinned()

◆ ~EarthModelBinned()

Member Function Documentation

◆ AddBin()

◆ AddPath()

◆ AddPathSegment()

◆ ClassDef() [1/2]

◆ ClassDef() [2/2]

◆ ClearModel()

◆ DetDistForNextLatBin()

◆ DetDistForNextLonBin()

◆ FillPath()

◆ GetCosT()

◆ GetEarthBins()

◆ GetMergedPaths()

◆ GetNuPath()

◆ GetRegionZoA()

◆ GetTotalL()

◆ LoadModel()

◆ LonBinIndex()

◆ RecordLatLonBinCrossings()

◆ ScaleRegionDensity()

◆ SetDetectorCoordinates()

◆ SetDetPos()

◆ SetRegionZoA()

◆ SetRemoveSmallPaths()

Member Data Documentation

◆ fC

◆ fDetLat

◆ fDetLon

◆ fDetRadius

◆ fEarthBins

◆ fErrorMessage_LonInfo

◆ fHalfLatBinWidth

◆ fHalfLonBinWidth

◆ fInvLatBinWidth

◆ fInvLonBinWidth

◆ fLonError

◆ fmaxRegIndex

◆ fnDepthBins

◆ fnLatBins

◆ fnLonBins

◆ fNuPath

◆ fRadiusMax

◆ fRemoveSmallPaths