calib Namespace Reference

CDPStorage service. More...

Classes
class	AbsCache
	Look up absolute attenuation constants. More...
class	AbsCalib
class	ADCShapeFitAna
	TODO. More...
class	ADCShapeFitTable
class	AssessCalib
	Make TTree with reconstructed and true energies. More...
class	AttenCache
class	AttenCurve
class	AttenFit
class	AttenuationFit
class	BetheBlochAnalytic
class	BetheBlochFit
class	BetheBlochTables
class	CalibAna
struct	CalibAnaParams
class	Calibrator
struct	CalibratorParams
class	CDPStorage
struct	ChannelSet
	Provide a simple utility function for our sets. More...
class	CosmicCalib
class	CosmicTrends
class	DCMTimingOffset
class	DetRespDrift
class	DriftCache
class	DriftCorrection
class	DriftResponseCalc
class	EnergyLossVsDistance
	Integrate energy losses to calculate deposit near a track end. More...
class	EnergyStandardCandles
class	FiberCalibration
class	FindOutliers
	Simple module to find modules with unusual calibration constants. More...
class	HitEfficiency
class	IBetheBloch
class	MakeAttenuationProfiles
class	MichelCandidate
	Information about a reconstructed Michel electron candidate. More...
class	MuondEdx
class	MuondEdxAna
class	MuonTrackHits
class	ParticleCorrections
	Make plots of threshold effect from PCHits files. More...
class	PCHitAggregator
class	PCHitsList
class	PCHitTransposer
class	PEResponse
class	ResizeDetector
class	RockMuonStopperSelection
	Selects stopping cosmics. More...
struct	ShapeTableParams
class	StopperFilter
class	StopperSelection
	Selects stopping cosmics. More...
class	StopperThreshold
class	SumAttenuationProfiles
	Sum up AttenProfilesMap objects. More...
class	SumRunsCalib
	Sum up AttenProfilesMap objects. More...
class	SumSubrunsCalib
	Sum up AttenProfilesMap objects. More...
class	SystematicUncertaintyScaleAna
class	TestParticleCorrections
	Make plots of threshold effect from PCHits files. More...
class	ThresholdAna
	Make plots of threshold and shielding effects from PCHits files. More...
class	ThresholdCorrMap
class	ThroughgoingSelection
	Selects throughgoing cosmics. More...
class	TimingCache
class	TimingCalFilter
class	TimingCalibration
class	TrueEContrib
	Information about one of the true particles that contribute to a candidate Michel electron. More...
class	TrueMichel
	When a Michel candidate has a contribution from a true Michel electron, we want more info about it. More...
class	TrueNeutronCapture
	When a Michel candidate has a contribution from a neutron capture, that's also interesting. More...

Typedefs
typedef std::pair< TVector3, TVector3 >	zBounds
typedef std::map< double, zBounds >	zBoundMap

Enumerations
enum	_quality { kAll = 0, kTriCell, kMaxQuality }
enum	_oneDHistNames {   kFractionUsableX = 0, kFractionUsableY, kRecoCosTheta, kRecoAz,   kPlanesCrossed, kDCosZ, kDCosX, kDCosY,   kNumTracks }
enum	_twoDHistNames {   kStopperCountX = 0, kTotalCountX, kStopperCountY, kTotalCountY,   kCosThetaVsAz, kCosThetaVsAzTru, kCosThetaVsPlanes, kAzVsPlanes,   kDeltaAzVsAz, kDeltaZenVsZen, kTotalHitCountX, kTotalHitCountY }
enum	_oneDHists
enum	_twoDHists
enum	Material { kPolyethylene }
enum	EFEBType { kFEB4p1, kFEB5p2 }
	Enumeration for the FEB 4.2 and 5.1 which have different clocks. More...
enum	EPathQuality { kXYAdjacents, kZAdjacents, kAverage, kBadTrack }
	Methods used to estimate path length of a track through a cell. More...

Functions
double	corr (TGraph *g, double thresh)
bool	ltTPt (BetheBlochTables::T_pt pt, double T)
bool	ltXPt (EnergyLossVsDistance::x_pt pt, double x)
const char *	getDetString (novadaq::cnv::DetId det)
	Utility function to get detector name as a string for file manipulations. More...
bool	HasXYAdjacents (int plane, int cell, const ChannelSet &hmap)
	Internal helper for BestPathEstimates. Takes account of bad channels. More...
bool	HasZAdjacents (int plane, int cell, const ChannelSet &hmap, const art::ServiceHandle< geo::Geometry > geom)
std::vector< double >	BestPathEstimates (std::vector< geo::OfflineChan > const &chans, std::map< unsigned int, TVector3 > const &directions, std::vector< EPathQuality > &quals, std::vector< geo::OfflineChan > const &extras)
TVector3 const	DirectionAtPlane (const std::map< unsigned int, TVector3 > &directions, unsigned int plane)
	Return the direction at a plane using the map provided by rb::Track. More...
void	FindBelowThresholdCalibCandidates (const std::vector< geo::OfflineChan > &trkchans, const std::map< unsigned int, TVector3 > &directions, std::vector< EPathQuality > &quals, std::vector< double > &paths, std::vector< geo::OfflineChan > &chans)
	Find empty cells that would have contributed to the calibration if they'd been hit. We assume they fell below threshold. More...
void	GetXYZD (geo::OfflineChan chan, double w, double *xyzd)
	Return position in world coordninates and distance to the readout. More...
void	FindZBoundaries (std::set< double > &planeZBounds)
	Find the boundaries in the z direction of planes in the detector. More...
zBoundMap	MakeZBoundaryMap (std::set< double > const &planeZBounds, std::vector< TVector3 > const &trajectory)
	Return a map of the z position of each trajectory point on a track to the bounding positions of where the track passes through that plane. In the case that a track stops in the plane, then the end of the track is the second bounding point. More...
zBounds	ZBounds (zBoundMap const &bounds, double const &hitZ)
	Return the bounding points for a given z position along a track. More...
float	PathLengthInCell (zBoundMap const &zBounds, TVector3 const &recoHitLoc, std::pair< uint32_t, uint32_t > const &pc)
	Return the path length of a track in the cell in question. More...
std::vector< std::string >	globWrapper (const std::string &pattern)
std::string	getCSVFilenameByParsingDirectory (int fCurrentRun, std::string prePattern, std::string postPattern)
bool	doesDirectoryExist (std::string dirSting)
	Return true if the path in dirString points to a directory. More...
std::vector< double >	BestPathEstimates (const std::vector< geo::OfflineChan > &chans, const std::map< unsigned int, TVector3 > &directions, std::vector< EPathQuality > &quals, const std::vector< geo::OfflineChan > &extras={})
	Calculate the best path length estimate for each hit in a track, and indicate how they were obtained. More...
double	GetExpectations (double t0, double riseTime, double fallTime, double preAmp, const int16_t *obs, double *exps, double &base, int mode)
	Helper function for ADCShapeFit inner loop. More...
uint16_t	ADCShapeFit (int16_t adc1, int16_t adc2, int16_t adc3, double riseTime, double fallTime, double preAmp, bool &goodTime, int fMode)
template<class T >
T	FOURTH (T x)
std::ostream &	operator<< (std::ostream &os, const AttenCurve &res)

Variables
int	kStatsLimit = 1
const double	Me = 510.998910e3
const double	Mmu = 105.658367e6
const double	K = 0.307075
const double	j = 0.200
static const double	GeV2MeV = CLHEP::GeV / CLHEP::MeV
static const double	sCmPerNsec = 29.9792458
static const double	sCmPerNsec = 29.9792458
const int	kChunk = 2000
const unsigned int	kNumFineTimingADCPoints = 4
const double	kZeroOffsetSamples = -1
const int	kOffsetStep = 16
const double	kSamplesPerOffset = 1./(256*64)

Detailed Description

CDPStorage service.

Hold timing constants.

Hold drift constants from current run.

Store the results of the attenuation fits.

Helper for AttenCurve.

Function to perform, and table to cache, timing fits to ADC values.

Look up absolute attenuation constants.

Calibration service.

Service to store calibration data products (CDP) in the SQLite3 metadatabase of a file.

Author

brebe.nosp@m.l@fn.nosp@m.al.go.nosp@m.v

Christopher Backhouse - bckho.nosp@m.use@.nosp@m.calte.nosp@m.ch.e.nosp@m.du

bckho.nosp@m.use@.nosp@m.calte.nosp@m.ch.e.nosp@m.du

Date

Author

Chris Backhouse - bckho.nosp@m.use@.nosp@m.calte.nosp@m.ch.e.nosp@m.du

Typedef Documentation

typedef std::map<double, zBounds> calib::zBoundMap

Definition at line 107 of file CalibUtil.h.

typedef std::pair<TVector3, TVector3> calib::zBounds

Definition at line 106 of file CalibUtil.h.

Enumeration Type Documentation

enum calib::_oneDHistNames

Enumerator
kFractionUsableX
kFractionUsableY
kRecoCosTheta
kRecoAz
kPlanesCrossed
kDCosZ
kDCosX
kDCosY
kNumTracks

Definition at line 41 of file CosmicTrends_module.cc.

                     {
    kFractionUsableX = 0,
    kFractionUsableY,
    kRecoCosTheta,
    kRecoAz,
    kPlanesCrossed,
    kDCosZ,
    kDCosX,
    kDCosY,
    kNumTracks
  };

enum calib::_oneDHists

Definition at line 50 of file StopperThreshold_module.cc.

                 {
  };

enum calib::_quality

Enumerator
kAll
kTriCell
kMaxQuality

Definition at line 35 of file CosmicTrends_module.cc.

               {
    kAll = 0,
    kTriCell,
    kMaxQuality
  };

enum calib::_twoDHistNames

Enumerator
kStopperCountX
kTotalCountX
kStopperCountY
kTotalCountY
kCosThetaVsAz
kCosThetaVsAzTru
kCosThetaVsPlanes
kAzVsPlanes
kDeltaAzVsAz
kDeltaZenVsZen
kTotalHitCountX
kTotalHitCountY

Definition at line 53 of file CosmicTrends_module.cc.

                     {
    kStopperCountX = 0,
    kTotalCountX,
    kStopperCountY,
    kTotalCountY,
    kCosThetaVsAz,
    kCosThetaVsAzTru,
    kCosThetaVsPlanes,
    kAzVsPlanes,
    kDeltaAzVsAz,
    kDeltaZenVsZen,
    kTotalHitCountX,
    kTotalHitCountY
  };

enum calib::_twoDHists

Definition at line 53 of file StopperThreshold_module.cc.

                 {
  };

enum calib::EFEBType

Enumeration for the FEB 4.2 and 5.1 which have different clocks.

Enumerator
kFEB4p1
kFEB5p2

Definition at line 25 of file CalibUtil.h.

                {
    kFEB4p1,
    kFEB5p2
  };

enum calib::EPathQuality

Methods used to estimate path length of a track through a cell.

The recommended method to perform a calibration is to accumulate separate histograms or averages for each cell in each quality level. If there is insufficient statistics in "xy" mode (there will be zero for cells along the sides of the detector), fall back to the "z" mode calculations. If there is insufficient stats here too (should only happen in the detector corners) fall back (reluctantly) to the kAverage calculations.

Enumerator
kXYAdjacents	There are adjacent hits on the same plane. This means the track must have entered in one side wall of the cell and gone out the other. The path length estimate is likely very precise.
kZAdjacents	There are no adjacent cells in the same plane, but the cells of the same index in the upstream and downstream planes are hit. There is high confidence that the track went in the front wall of the cell and out the back. The path length estimate should be good. The kXYAdjacents case is preferred only because it is more common.
kAverage	The cell has no special properties, and the path length has been estimated using the geo::AverageCellPathLength method. The result is likely pretty poor. Only use cells with this estimate if you have no choice.
kBadTrack	Something was wrong with the track object, the pathlength will be zero. Do not use this cell.

Definition at line 40 of file CalibUtil.h.

                   {
    /// There are adjacent hits on the same plane. This means the track must
    /// have entered in one side wall of the cell and gone out the other. The
    /// path length estimate is likely very precise.
    kXYAdjacents,
    /// There are no adjacent cells in the same plane, but the cells of the
    /// same index in the upstream and downstream planes are hit. There is high
    /// confidence that the track went in the front wall of the cell and out
    /// the back. The path length estimate should be good. The kXYAdjacents
    /// case is preferred only because it is more common.
    kZAdjacents,
    /// The cell has no special properties, and the path length has been
    /// estimated using the \ref geo::AverageCellPathLength method. The result
    /// is likely pretty poor. Only use cells with this estimate if you have no
    /// choice.
    kAverage,
    /// Something was wrong with the track object, the pathlength will be
    /// zero. Do not use this cell.
    kBadTrack
  };

enum calib::Material

Enumerator
kPolyethylene

Definition at line 16 of file BetheBloch.h.

               {
    kPolyethylene
  };

Function Documentation

uint16_t calib::ADCShapeFit	(	int16_t	adc1,
		int16_t	adc2,
		int16_t	adc3,
		double	riseTime,
		double	fallTime,
		double	preAmp,
		bool &	goodTime,
		int	mode
	)

Scans a pulseheight shape across the given ADC values and returns the best offset. Offset is in internal units. Use OffsetToTNS to convert to an absolute time in nanoseconds.

Rise and fall time should be in units of the spacing between samples

Definition at line 147 of file ADCShapeFit.cxx.

References ana::assert(), GetExpectations(), MECModelEnuComparisons::i, kNumFineTimingADCPoints, kSamplesPerOffset, kZeroOffsetSamples, norm, PandAna.reco_validation.add_data::offset, sqr(), and getGoodRuns4SAM::t0.

Referenced by calib::ADCShapeFitTable::TNS().

  {
    // The observations, in chronological order
    const int16_t obs[kNumFineTimingADCPoints] = {0, adc1, adc2, adc3};
    
    double bestchisq = 1e10; // infinity
    // Sane default
    uint16_t bestoffset = -kZeroOffsetSamples/kSamplesPerOffset;
    goodTime = false;
    
    // Scan through possible offsets of the peak, looking for the best match
    uint16_t offset = 0;
    do{
      // In TDC
      const double t0 = (double(offset)*kSamplesPerOffset+kZeroOffsetSamples);
      
      // Expectations
      double exps[kNumFineTimingADCPoints];
      double junk;
      const double norm = GetExpectations(t0, riseTime, fallTime, preAmp, obs, exps, junk, fMode);
      
      if(norm < 0) continue;
      
      // Assuming equal, uncorrelated, errors on all points. (Including
      // correlations was not found to improve resolution).
      double chisq = 0;
      for(unsigned int i = 0; i < kNumFineTimingADCPoints; ++i)
        chisq += sqr(obs[i]-exps[i]);
      assert(chisq >= 0);

      if(chisq < bestchisq){
        bestchisq = chisq;
        bestoffset = offset;
        goodTime = true;
      }
    } while((offset += kOffsetStep) != 0);
    
    if(bestoffset == 0 || bestoffset == 256*256-kOffsetStep){
      /*
        std::cerr << "Best time offset is at edge of range. "
        << "If this happens repeatedly there's a "
        << "timing problem. Details: "
        << adc0 << " " << adc1 << " " << adc2 << std::endl;
      */
      bestoffset = -kZeroOffsetSamples/kSamplesPerOffset;
      goodTime = false;
    }
    
    return bestoffset;
  }

std::vector<double> calib::BestPathEstimates	(	const std::vector< geo::OfflineChan > &	chans,
		const std::map< unsigned int, TVector3 > &	directions,
		std::vector< EPathQuality > &	quals,
		const std::vector< geo::OfflineChan > &	extras = {}
	)

Calculate the best path length estimate for each hit in a track, and indicate how they were obtained.

Parameters

	trk	The track whose cells should be used
[out]	quals	How the path length of each hit was determined. Please read the documentation for EPathQuality
	extra	Other cells that should be considered to be on the track (optional). Results for these will be at the end of returned vectors.

Returns

Path lengths (in cm). Indices correspond to those passed to rb::Track::Cell

std::vector<double> calib::BestPathEstimates	(	std::vector< geo::OfflineChan > const &	chans,
		std::map< unsigned int, TVector3 > const &	directions,
		std::vector< EPathQuality > &	quals,
		std::vector< geo::OfflineChan > const &	extras
	)

Definition at line 98 of file CalibUtil.cxx.

References std::abs(), ana::assert(), geo::AverageCellPathLength(), getBrightness::cell, geo::PlaneGeo::Cell(), DirectionAtPlane(), dx, dy, dz, geom(), geo::CellGeo::HalfD(), geo::CellGeo::HalfW(), HasXYAdjacents(), HasZAdjacents(), MECModelEnuComparisons::i, std::isnan(), kAverage, kBadTrack, geo::kX, kXYAdjacents, geo::kY, kZAdjacents, TB_WatchdogFx::paths, geo::GeometryBase::Plane(), NDAPDHVSetting::plane, qual, POTSpillRate::view, and geo::PlaneGeo::View().

Referenced by calib::PCHitsList::ProcessTrack(), and calib::PCHitsList::ProcessTrackForFLSHits().

  {
    const size_t trkN    = chans.size();
    const size_t extrasN = extras.size();
    const size_t hitMax  = trkN+extrasN;

    std::vector<double> paths;
    paths.resize(hitMax);

    quals.clear();
    quals.resize(hitMax);

    art::ServiceHandle<geo::Geometry> geom;

    ChannelSet hmap;
    for(size_t i = 0; i < trkN; ++i) hmap.insert(chans[i]);
    hmap.insert(extras.begin(), extras.end());


    // Look for ones that have perpendicular hits either side
    for(size_t hitIdx = 0; hitIdx < hitMax; ++hitIdx){
      int plane, cell;
      geo::View_t view;
      if(hitIdx < trkN){
        plane = chans[hitIdx].Plane();
        cell = chans[hitIdx].Cell();
        view = geom->Plane(plane)->View();
      }
      else{
        plane = extras[hitIdx-trkN].Plane();
        cell  = extras[hitIdx-trkN].Cell();
        view  = geom->Plane(plane)->View();
      }

      EPathQuality qual = kAverage;

      // Mark as xy if it satisfies the criteria. Or if not then maybe as
      // z. Otherwise falls back to the default kAverage.
      if(HasXYAdjacents(plane, cell, hmap)){
        qual = kXYAdjacents;
      }
      else{
        if(HasZAdjacents(plane, cell, hmap, geom)){
          qual = kZAdjacents;
        }
      }

      quals[hitIdx] = qual;

      // get the direction for this plane
      TVector3 dr = calib::DirectionAtPlane(directions, plane);

      const double dx = std::abs(dr.X());
      const double dy = std::abs(dr.Y());
      const double dz = std::abs(dr.Z());
      if(std::isnan(dx) || std::isnan(dy) || std::isnan(dz) ||
         (view == geo::kX && dx == 0) ||
         (view == geo::kY && dy == 0) ||
         (qual == kZAdjacents && dz == 0)){
        paths[hitIdx] = 0;
        quals[hitIdx] = kBadTrack;
        continue;
      }

      const geo::CellGeo* cellgeo = geom->Plane(plane)->Cell(cell);
      const double width = 2*cellgeo->HalfW();
      const double depth = 2*cellgeo->HalfD();

      switch(qual){
      case kXYAdjacents:
        paths[hitIdx] = (view == geo::kX) ? width/dx : width/dy;
        break;
      case kZAdjacents:
        paths[hitIdx] = depth/dz;
        break;
      case kAverage:
        paths[hitIdx] = geo::AverageCellPathLength(view, dx, dy, dz);
        break;
      default:
        assert(0 && "Shouldn't happen");
      } // end switch
    } // end for hitIdx

    return paths;
  }

double calib::corr	(	TGraph *	g,
		double	thresh
	)

Definition at line 110 of file TestParticleCorrections_module.cc.

References MECModelEnuComparisons::i, submit_syst::x, and submit_syst::y.

Referenced by calib::TestParticleCorrections::analyze(), calib::AttenFit::ApplyThresholdCorrection(), and calib::AttenuationFit::ApplyThresholdCorrection().

  {
    for(int i = 0; i < g->GetN(); ++i){
      double x, y;
      g->GetPoint(i, x, y);

      if(x > thresh) return 100/y;
    }

    return 1; // Uh oh
  }

TVector3 const calib::DirectionAtPlane	(	const std::map< unsigned int, TVector3 > &	directions,
		unsigned int	plane
	)

Return the direction at a plane using the map provided by rb::Track.

Definition at line 188 of file CalibUtil.cxx.

Referenced by BestPathEstimates(), and FindBelowThresholdCalibCandidates().

  {
    TVector3 dr;

    if(directions.count(plane) > 0){
      dr = directions.find(plane)->second;
    }
    else{

      // the plane is not in the map, so now need to 
      // determine the direction of the track in z, 
      // and then use that result to determine whether
      // to use the upper_bound or lower_bound methods
      // remember that maps are ordered by the < operator
      // of the key, in this case an unsigned int
      // if the desired plane is outside the bounds of
      // the map, just take the end point vector of the
      // map in the direction of travel.
      
      auto ubitr = directions.upper_bound(plane);
      auto lbitr = directions.lower_bound(plane);
    
      // the direction in z better not change or
      // this track has problems
      float dZ = directions.begin()->second.Z();
      if( dZ > 0.){
        if( ubitr != directions.end() )
          dr = ubitr->second;
        else
          dr = directions.rbegin()->second;
      }
      if( dZ < 0. ){
        if( lbitr != directions.end() )
          dr = lbitr->second;
        else
          dr = directions.begin()->second;
      }
    } // end no key corresponding to plane in the map
    
    return dr;
  }

bool calib::doesDirectoryExist

(

std::string

dirSting

)

Return true if the path in dirString points to a directory.

Parameters

dirString

path to the directory to check

Definition at line 759 of file CalibUtil.cxx.

Referenced by calib::AttenCache::GetCSVPath().

   {
      struct stat info;

      if(stat( dirSting.c_str(), &info ) != 0)
         return false;
      else if(info.st_mode & S_IFDIR)
         return true;
      else
         return false;
   }

void calib::FindBelowThresholdCalibCandidates	(	const std::vector< geo::OfflineChan > &	trkchans,
		const std::map< unsigned int, TVector3 > &	directions,
		std::vector< EPathQuality > &	quals,
		std::vector< double > &	paths,
		std::vector< geo::OfflineChan > &	chans
	)

Find empty cells that would have contributed to the calibration if they'd been hit. We assume they fell below threshold.

TODO: Can only currently find "xy" quality candidates

Parameters

[out]	quals	How the path length of each cell was determined. Please read the documentation for EPathQuality
[out]	paths	Estimated path length for each selected cell
[out]	chans	Which cells were selected

Definition at line 232 of file CalibUtil.cxx.

References std::abs(), getBrightness::cell, geo::PlaneGeo::Cell(), calib::ChannelSet::CellExists(), DirectionAtPlane(), dx, dy, dz, geom(), geo::CellGeo::HalfW(), HasXYAdjacents(), std::isnan(), geo::kX, kXYAdjacents, geo::kY, getGoodRuns4SAM::n, geo::GeometryBase::Plane(), NDAPDHVSetting::plane, POTSpillRate::view, and geo::PlaneGeo::View().

Referenced by calib::PCHitsList::ProcessTrackForBelowThresholdHits().

  {
    // In case user passed in junk
    quals.clear();
    paths.clear();
    chans.clear();

    const int hitMax = trkchans.size();

    art::ServiceHandle<geo::Geometry> geom;

    ChannelSet hmap;
    for(int n = 0; n < hitMax; ++n) hmap.insert(trkchans[n]);

    for(int hitIdx = 0; hitIdx < hitMax; ++hitIdx){
      const int plane = trkchans[hitIdx].Plane();
      const geo::View_t view = geom->Plane(plane)->View();

      auto const dr = calib::DirectionAtPlane(directions, plane);
      
      const double dx = std::abs(dr.X());
      const double dy = std::abs(dr.Y());
      const double dz = std::abs(dr.Z());
      
      if(std::isnan(dx) || std::isnan(dy) || std::isnan(dz)) continue;
      
      if((view == geo::kX && dx == 0) || (view == geo::kY && dy == 0)){
        continue;
      }

      // Need to search between each cell and the next hit cell in the same
      // plane
      int cell = trkchans[hitIdx].Cell();
      while(true){
        ++cell;

        // If it's hit, then it isn't thresholded. And that ends our search
        // because we'll pick it up and start there next.
        if(hmap.CellExists(plane, cell)) break;

        if(HasXYAdjacents(plane, cell, hmap)){
          const geo::CellGeo* cellgeo = geom->Plane(plane)->Cell(cell);
          const double width = 2*cellgeo->HalfW();

          quals.push_back(kXYAdjacents);
          paths.push_back((view == geo::kX) ? width/dx : width/dy);
          chans.push_back(geo::OfflineChan(plane, cell));
        }
        else{
          // Definition of the XY criteria mean that nothing else in this range
          // can work either
          break;
        }
      } // end while
    }
  }

void calib::FindZBoundaries

(

std::set< double > &

planeZBounds

)

Find the boundaries in the z direction of planes in the detector.

Parameters

[out]

planeZBounds

is a set of those values that is filled by the function

Definition at line 332 of file CalibUtil.cxx.

References geo::PlaneGeo::Cell(), geom(), geo::CellGeo::GetCenter(), geo::CellGeo::HalfD(), geo::GeometryBase::NPlanes(), and geo::GeometryBase::Plane().

Referenced by calib::StopperThreshold::FillHist(), trk::CosmicTrackAna::FillTrackHistograms(), calib::StopperThreshold::FillTree(), numusand::NumuSandFxs::getAveTrackdEdxLast4Cells(), numusand::NumuSandFxs::getAveTrackdEdxLast6Cells(), numusand::NumuSandFxs::getAveTrackdEdxLast8Cells(), trackinfo::TrackInfoFxs::getAveTrackdEdxLastCells(), calib::PCHitsList::produce(), and calib::StopperThreshold::testPath().

  {
    // loop over all the planes in the geometry and put their upper z boundary
    // into a set
    std::set<double> bounds;
    bounds.insert(0.);
    double xyz[3] = {0.};
    
    art::ServiceHandle<geo::Geometry> geom;
    double planeZDepth  = 2.*geom->Plane(0)->Cell(0)->HalfD();
    
    for(size_t p = 0; p < geom->NPlanes(); ++p){
      geom->Plane(p)->Cell(0)->GetCenter(xyz);
      bounds.insert(xyz[2] + 0.5*planeZDepth);
    }
    
    planeZBounds.swap(bounds);
    
    return;
  }

template<class T >

T calib::FOURTH

(

T

x

)

Definition at line 35 of file AttenCurve.cxx.

References submit_syst::x.

Referenced by calib::AttenCurve::MeanPEPerCmAt().

{return x*x*x*x;}

std::string calib::getCSVFilenameByParsingDirectory	(	int	fCurrentRun,
		std::string	prePattern,
		std::string	postPattern
	)

Definition at line 706 of file CalibUtil.cxx.

References ana::assert(), om::cout, globWrapper(), path, submit_syst::pattern, and string.

Referenced by calib::AttenCache::GetCSVPath(), calib::TimingCache::LoadFromDatabase(), and calib::AbsCache::LoadFromVldDatabase().

                                                                                                         {
  //This function just finds all the CSV files that match the pattern
  // and thens earches through these files to find which one covers the fCurrentRun
  std::string pattern=prePattern+std::string("*")+postPattern;  
  std::vector<std::string> answers=globWrapper(pattern);
  int startRun=0; int endRun=0;

  //Check if there were any matches
  if(answers.size()==0) {
    std::cout << "We didn't find anything that matches the pattern for calibration CSV files\n";
    std::cout << pattern << "\n";
    assert(0 && "Shouldn't happen");
  }
  
  //Loop through the matches
  for(auto path : answers) {
    if(path.size() > prePattern.size() + postPattern.size()) {
      std::string epStr=path.substr(prePattern.size(),path.size()-(prePattern.size()+postPattern.size()));
      //      std::cout << epStr.c_str() << "\n";
      if(epStr.c_str()[2]=='-') {
        //Start run = 0
        startRun=0;
      }
      else {
        size_t hyphenPlace = epStr.find("-");
        startRun=stoi( epStr.substr(2,hyphenPlace-2));
      }
      if(epStr.c_str()[epStr.size()-2]=='-') {
        endRun=0;       
      }
      else {
        size_t hyphenPlace = epStr.find("-");
        //      std::cout << "Substring: " << epStr.substr(hyphenPlace+2) << "\n";
        endRun=stoi(epStr.substr(hyphenPlace+2 ));
      }
            
    }
    //    std::cout << startRun << "\t" << endRun << "\n";
    if(fCurrentRun>=startRun && (endRun==0 || fCurrentRun<=endRun)) {
      //      std::cout << fCurrentRun << "\t" << path << "\n";
      return path;
    }
    
  }
 
  std::cout << "We didn't find anything that matches the pattern for calibration CSV files\n";
  std::cout << "This shouldn't happen and might mean that the calibration CSV files are incomplete.\n";
  std::cout << "Looking for run: " << fCurrentRun << " using pattern:\n";
  std::cout << pattern << "\n";
  assert(0 && "Shouldn't happen");
  return std::string("");
}

const char * calib::getDetString

(

novadaq::cnv::DetId

det

)

Utility function to get detector name as a string for file manipulations.

Definition at line 29 of file CalibUtil.cxx.

References ana::assert(), novadaq::cnv::kFARDET, novadaq::cnv::kNEARDET, and novadaq::cnv::kTESTBEAM.

Referenced by calib::AttenCache::GetCSVPath(), calib::TimingCache::LoadFromDatabase(), and calib::AbsCache::LoadFromVldDatabase().

  {
    switch(det) {
    case novadaq::cnv::kFARDET: return "fd";
    case novadaq::cnv::kNEARDET: return "nd";
    case novadaq::cnv::kTESTBEAM: return "tb";
    default:
      assert (!"The default case of getDetString switch was reached.");
      return "NeverHere";
    }          
  }

double calib::GetExpectations ( double  t0, double  riseTime, double  fallTime, double  preAmp, const int16_t *  obs, double *  exps, double &  base, int  mode  )

inline

Helper function for ADCShapeFit inner loop.

Also used independently to calculate the best fit adc peak height (the return value).

Definition at line 64 of file ADCShapeFit.cxx.

References stan::math::exp(), MECModelEnuComparisons::i, kNumFineTimingADCPoints, kOffsetStep, getGoodRuns4SAM::n, norm, confusionMatrixTree::t, getGoodRuns4SAM::t0, W, X, and Z.

Referenced by ADCShapeFit(), and calib::ADCShapeFitTable::TNS().

  {
    // There are only a few thousand distinct inputs to this function per
    // combination of riseTime, fallTime and preAmp. Cache all possible
    // outputs.  This saves about 40% of the run time of CalHit for ND and FD
    // jobs, for which this cache needs to be built only once.  For TB jobs,
    // two kinds of FEBs are present, so the cache is rebuilt many times as we
    // see hits from each kind.  This is *still* faster than not having a
    // cache, although obviously a little dumb since we could save both sets of
    // cached data with a little more work.

    // The calculation of cache_size is slightly fragile because
    // kSamplesPerOffset and kZeroOffsetSamples are defined as doubles even
    // though they are representing integer concepts (also the meaning of
    // kSamplesPerOffset is the reciprocal of its name).  But I think the rest
    // of the code also breaks if kZeroOffsetSamples isn't an integer or if
    // kSamplesPerOffset isn't the reciprocal of an integer.
    const int steps_per_offset = 1 / kSamplesPerOffset / kOffsetStep;
    const int num_offsets = (kNumFineTimingADCPoints - 1) - kZeroOffsetSamples;
    const int cache_size = steps_per_offset * num_offsets;

    static double cache_ideal[cache_size] = {0};
    static double cache_3param[cache_size] = {0};

    static double cache_riseTime = -1, cache_fallTime = -1, cache_preAmp = -1;

    if(cache_ideal[0] == 0 || riseTime != cache_riseTime ||
       fallTime != cache_fallTime || preAmp != cache_preAmp){
      for(int i = 0; i < cache_size; i++){
        const double t_minus_t0 = double(i+1)/steps_per_offset;

        // This is the ideal ASIC formula from SimpleReadout
        cache_ideal[i] = exp(-t_minus_t0/fallTime)*(1-exp(-t_minus_t0/riseTime));

        //new three parameters function
        cache_3param[i] = (fallTime * preAmp)*(
          (exp(-t_minus_t0/fallTime) / ((preAmp-fallTime)*(fallTime-riseTime))) -
          (exp(-t_minus_t0/preAmp)   / ((preAmp-fallTime)*(preAmp - riseTime))) +
          (exp(-t_minus_t0/riseTime) / ((preAmp-riseTime)*(riseTime-fallTime))) );
      }
    }

    cache_riseTime = riseTime;
    cache_fallTime = fallTime;
    cache_preAmp = preAmp;

    for(unsigned int t = 0; t < kNumFineTimingADCPoints; ++t){
      if(t <= t0){
        exps[t] = 0;
      }
      else{
        const int cachei = (t-t0) * steps_per_offset - 1;
        exps[t] = mode == 0?cache_ideal[cachei]: cache_3param[cachei];
      }
    }
    
    // We can calculate the best fit baseline and normalization at this offset
    // analytically (just write the chisq expression, and take derivatives with
    // norm or base), like so:
    double U, V, W, X, Z;
    U = V = W = X = Z = 0;
    for(unsigned int i = 0; i < kNumFineTimingADCPoints; ++i){
      U += exps[i];
      V += 1;
      W += obs[i];
      X += exps[i]*exps[i];
      Z += obs[i]*exps[i];
    }
    const double norm = (W*U-V*Z)/(U*U-X*V);
    base = (W*X-Z*U)/(X*V-U*U);
    
    // Correct all the expectations for the best guess baseline and norm
    for(unsigned int n = 0; n < kNumFineTimingADCPoints; ++n){
      exps[n] = norm*exps[n]+base;
    }
    
    return norm;
  }

void calib::GetXYZD	(	geo::OfflineChan	chan,
		double	w,
		double *	xyzd
	)

Return position in world coordninates and distance to the readout.

Parameters

cellhit	A hit on a track
w	The unknown coordinate from the opposite view
xyzd[4]	Returns x,y,z,d where d is the distance to readout

Definition at line 294 of file CalibUtil.cxx.

References plot_validation_datamc::c, getBrightness::cell, geo::OfflineChan::Cell(), geo::PlaneGeo::Cell(), geo::GeometryBase::DistToElectronics(), geom(), geo::CellGeo::GetCenter(), geo::kX, geo::PlaneGeo::Ncells(), geo::GeometryBase::NPlanes(), geo::OfflineChan::Plane(), geo::GeometryBase::Plane(), NDAPDHVSetting::plane, geo::PlaneGeo::View(), w, and geo::CellGeo::WorldToLocal().

Referenced by slid::NuEEnergyAlg::CellEnergy(), calib::PCHitsList::CellHitToPCHit(), calhit::CalHitAna::FillTruthInfo(), slid::NuEEnergyAlg::HadronicDepEnergy(), calib::Calibrator::MakeRecoHit(), and jmshower::RecoJMShower::RecoShowers().

                                                            {
    // Return (via 'xyzd' argument) position of deposition in world
    // coordinates and the distance to the readout, assuming deposition
    // has cell-local-z position = w.

    art::ServiceHandle<geo::Geometry> geom;

    UInt_t plane = chan.Plane();
    UInt_t cell  = chan.Cell();
    if ( plane >= geom->NPlanes() ) {
      throw cet::exception("BAD_PLANE_NUMBER")
        << "plane " << plane << " of " << geom->NPlanes() << " planes\n"
        << __FILE__ << ":" << __LINE__ << "\n";
    }
    const geo::PlaneGeo* p = geom->Plane(plane);
    if ( cell >= p->Ncells() ) {
      throw cet::exception("BAD_CELL_NUMBER")
        << "cell " << cell << " of " << p->Ncells()
        << " in plane " << plane << "\n"
        << __FILE__ << ":" << __LINE__ << "\n";
    }
    const geo::CellGeo* c = p->Cell(cell);

    // Should be replaced with alignment tables or whatnot.  Okay for now.

    // w is not localZ, which makes this a lot messier than just
    // c.GetCenter(xyzd,w) and c.DistToReadOut(w)
    c->GetCenter(xyzd);
    if (geom->Plane(plane)->View()==geo::kX)
      xyzd[1] = w;
    else
      xyzd[0] = w;
    Double_t localxyz[3];
    c->WorldToLocal(xyzd,localxyz);
    xyzd[3] = geom->DistToElectronics(localxyz[2], *c);
  }

std::vector< std::string > calib::globWrapper

(

const std::string &

pattern

)

Definition at line 676 of file CalibUtil.cxx.

References allTimeWatchdog::endl, site_stats_from_log::filenames, MECModelEnuComparisons::i, test_Tier::return_value, and ss.

Referenced by getCSVFilenameByParsingDirectory().

                                                             {
    using namespace std;

    // glob struct resides on the stack
    glob_t glob_result;
    memset(&glob_result, 0, sizeof(glob_result));

    // do the glob operation
    int return_value = glob(pattern.c_str(), GLOB_TILDE, NULL, &glob_result);
    if(return_value != 0) {
        globfree(&glob_result);
        stringstream ss;
        ss << "glob(" << pattern.c_str() << ") failed with return_value " << return_value << endl;
        throw std::runtime_error(ss.str());
    }

    // collect all the filenames into a std::list<std::string>
    vector<string> filenames;
    for(size_t i = 0; i < glob_result.gl_pathc; ++i) {
        filenames.push_back(string(glob_result.gl_pathv[i]));
    }

    // cleanup
    globfree(&glob_result);

    // done
    return filenames;
}

bool calib::HasXYAdjacents	(	int	plane,
		int	cell,
		const ChannelSet &	hmap
	)

Internal helper for BestPathEstimates. Takes account of bad channels.

Definition at line 54 of file CalibUtil.cxx.

References getBrightness::cell, calib::ChannelSet::CellExists(), geom(), chaninfo::BadChanList::IsBad(), geo::PlaneGeo::Ncells(), geo::GeometryBase::Plane(), and fillBadChanDBTables::step.

Referenced by BestPathEstimates(), and FindBelowThresholdCalibCandidates().

  {
    art::ServiceHandle<geo::Geometry> geom;
    art::ServiceHandle<chaninfo::BadChanList> bcl;

    // Look first below and then above this cell
    for(int step = -1; step <= +1; step += 2){
      int curCell = cell;
      while(true){
        curCell += step;

        // Ran out of detector
        if(curCell < 0 ||
           curCell >= int(geom->Plane(plane)->Ncells())) return false;

        // If this channel is bad we can keep on looking in this direction
        if(bcl->IsBad(plane, curCell)) continue;

        // If there's a hit this side move on to the other side. If there's
        // isn't then this cell fails the test.
        if(hmap.CellExists(plane, curCell))
          break;
        else
          return false;

      } // end while
    } // end for step
    return true;
  }

bool calib::HasZAdjacents	(	int	plane,
		int	cell,
		const ChannelSet &	hmap,
		const art::ServiceHandle< geo::Geometry >	geom
	)

Definition at line 87 of file CalibUtil.cxx.

References getBrightness::cell, calib::ChannelSet::CellExists(), and geo::GeometryBase::NextPlaneInView().

Referenced by BestPathEstimates().

  {
    return (!hmap.CellExists(plane, cell-1) &&
            !hmap.CellExists(plane, cell+1) &&
            hmap.CellExists(geom->NextPlaneInView(plane, +1), cell) &&
            hmap.CellExists(geom->NextPlaneInView(plane, -1), cell));
  }

bool calib::ltTPt	(	BetheBlochTables::T_pt	pt,
		double	T
	)

Definition at line 94 of file BetheBloch.cxx.

References T, and calib::BetheBlochTables::T_pt::T.

Referenced by calib::BetheBlochTables::dEdx().

  {
    return pt.T < T;
  }

bool calib::ltXPt	(	EnergyLossVsDistance::x_pt	pt,
		double	x
	)

Definition at line 35 of file EnergyLossVsDistance.cxx.

References calib::EnergyLossVsDistance::x_pt::x, and submit_syst::x.

Referenced by calib::EnergyLossVsDistance::GetEnergyLoss().

  {
    return pt.x < x;
  }

zBoundMap calib::MakeZBoundaryMap	(	std::set< double > const &	planeZBounds,
		std::vector< TVector3 > const &	trajectory
	)

Return a map of the z position of each trajectory point on a track to the bounding positions of where the track passes through that plane. In the case that a track stops in the plane, then the end of the track is the second bounding point.

Parameters

planeZBounds	A set of the z positions bounding each plane in the detector
trajectory	The trajectory points of the track

Definition at line 354 of file CalibUtil.cxx.

References std::abs(), geo::PlaneGeo::Cell(), dir, geom(), geo::CellGeo::HalfD(), geo::LiveGeometry::IsPointLive(), LOG_DEBUG, make_pair(), geo::GeometryBase::Plane(), X, and Z.

Referenced by calib::StopperThreshold::FillHist(), trk::CosmicTrackAna::FillTrackHistograms(), calib::StopperThreshold::FillTree(), numusand::NumuSandFxs::getAveTrackdEdxLast4Cells(), numusand::NumuSandFxs::getAveTrackdEdxLast6Cells(), numusand::NumuSandFxs::getAveTrackdEdxLast8Cells(), trackinfo::TrackInfoFxs::getAveTrackdEdxLastCells(), calib::PCHitsList::ProcessTrackTrajectory(), and calib::StopperThreshold::testPath().

  {
    zBoundMap zToPlaneBounds;

    std::vector<TVector3> localTraj(trajectory);

    // drop duplicate entries that are right next to each other to avoid zero
    // vectors
    auto itr1 = localTraj.begin();
    auto itr2 = localTraj.begin();
    while(itr1 != localTraj.end()){
      // set the second iterator to be the next entry in the vector
      itr2 = itr1;
      ++itr2;
      if(itr2 == localTraj.end()) break;

      // if the TVector3s are the same, erase itr2 and set
      // itr1 to be the return value, ie the position after
      // the original itr2.  Otherwise increase itr1
      if(std::abs((*itr1).X() - (*itr2).X()) < 0.1  &&
         std::abs((*itr1).Y() - (*itr2).Y()) < 0.1  &&
         std::abs((*itr1).Z() - (*itr2).Z()) < 0.1){
        LOG_DEBUG("CalibUtil") << "erasing " << (*itr1).X() << " " << (*itr1).Y() << " " << (*itr1).Z();
        itr1 = localTraj.erase(itr2);
      }
      else ++itr1;      
    }
    
    double deltaZ = 0.;
    double lowZ  = 0.;
    double highZ = 0.;
    
    auto litr = planeZBounds.begin();
    auto hitr = planeZBounds.begin();
    
    TVector3 dir;
    TVector3 lowBound;
    TVector3 highBound;
    
    art::ServiceHandle<geo::LiveGeometry> liveGeo;
    art::ServiceHandle<geo::Geometry> geom;
    double planeZDepth  = 2.*geom->Plane(0)->Cell(0)->HalfD();
    
    for(size_t tp = 0; tp < localTraj.size(); ++tp){
      
      LOG_DEBUG("CalibUtils") 
      << tp << "/" << localTraj.size()
      << " localTraj: " << localTraj[tp].X()
      << " " << localTraj[tp].Y()
      << " " << localTraj[tp].Z();
      
      // make sure the localTraj point is inside the detector
      if( !liveGeo->IsPointLive(localTraj[tp]) ){
        LOG_DEBUG("CalibUtils") << tp << " is not valid";
        continue;
      }

      // find the intersection of the localTrajectory with the boundary
      // of the plane it represents
      if(tp < localTraj.size() - 1) dir = localTraj[tp+1] - localTraj[tp];
      else                          dir = localTraj[tp]   - localTraj[tp-1];
      
      // find the plane boundaries for this point
      litr = planeZBounds.lower_bound(localTraj[tp].Z() - planeZDepth);
      hitr = planeZBounds.upper_bound(localTraj[tp].Z());
      
      // in the muon catcher, the high side and low side iterators could be the same
      if(hitr == litr){
        if(litr != planeZBounds.begin() ) --litr;
        else ++hitr;
      }
      lowZ = *litr;
      highZ = *hitr;
      
      LOG_DEBUG("CalibUtils")
      << tp << " " << localTraj[tp].Z()
      << " low z: " << lowZ << " high z: " << highZ
      << " localTraj point: ("
      << localTraj[tp].X() << " " << localTraj[tp].Y() << " " << localTraj[tp].Z() << ")";
    
      // make sure we don't go past the detector boundaries
      deltaZ = localTraj[tp].Z() - lowZ;
      lowBound.SetXYZ(localTraj[tp].X() - deltaZ*dir.X()/dir.Z(),
                      localTraj[tp].Y() - deltaZ*dir.Y()/dir.Z(),
                      lowZ);
      
      LOG_DEBUG("CalibUtils")
      << "is bounded by " << deltaZ << " " << dir.X()/dir.Z() << " " << dir.Y()/dir.Z()
      << " (" << lowBound.X() << " " << lowBound.Y() << " " << lowBound.Z() << ")";
      
      deltaZ = highZ - localTraj[tp].Z();
      highBound.SetXYZ(localTraj[tp].X() + deltaZ*dir.X()/dir.Z(),
                       localTraj[tp].Y() + deltaZ*dir.Y()/dir.Z(),
                       highZ);
      
      LOG_DEBUG("CalibUtils")
      << "and " << deltaZ << " ("
      << highBound.X() << " " << highBound.Y() << " " << highBound.Z() << ")";
      
      zToPlaneBounds[localTraj[tp].Z()] = std::make_pair(lowBound, highBound);
      
    }
    
    return zToPlaneBounds;
  }

std::ostream & calib::operator<<	(	std::ostream &	os,
		const AttenCurve &	res
	)

Definition at line 149 of file AttenCurve.cxx.

References calib::AttenCurve::atten_length, calib::AttenCurve::background, calib::AttenCurve::chan, calib::AttenCurve::chisq, calib::AttenCurve::coeff_exp, calib::AttenCurve::coeff_high, calib::AttenCurve::coeff_low, calib::AttenCurve::det, calib::AttenCurve::edge_high, calib::AttenCurve::edge_low, allTimeWatchdog::endl, novadaq::cnv::DetInfo::GetName(), calib::AttenCurve::initialized, calib::AttenCurve::interp_pts, and getGoodRuns4SAM::n.

Referenced by calib::AttenCurve::AttenCurve().

  {
    os << "Attenuation fit results for "
       << novadaq::cnv::DetInfo::GetName(res.det)
       << ", " << res.chan << ": ";

    if(!res.initialized){
      os << " Uninitialized." << std::endl;
      return os;
    }

    os << res.atten_length << "cm " << res.coeff_exp << " amplitude on "
       << res.background << " background. Rolloffs start at -"
       << res.edge_low << "cm and +" << res.edge_high << "cm with size "
       << res.coeff_low << " and " << res.coeff_high
       << " fit quality " << res.chisq << std::endl;
    os << "Interpolation points are: [ ";
    const int N = res.interp_pts.size();
    for(int n = 0; n < N; ++n)
      os << "(" << res.interp_pts[n].w << ", "
         << res.interp_pts[n].factor << ") ";
    os << "]" << std::endl;
    return os;
  }

float calib::PathLengthInCell	(	zBoundMap const &	zBounds,
		TVector3 const &	recoHitLoc,
		std::pair< uint32_t, uint32_t > const &	pc
	)

Return the path length of a track in the cell in question.

Parameters

zBounds	The z poisition boundaries for each trajectory point on the track
recoHitLoc	The 3D position of the rb::RecoHit to ensure the trajectory passes through it
pc	A std::pair corresponding to the plane (p) and cell (c) of the hit

Definition at line 498 of file CalibUtil.cxx.

References std::abs(), allTimeWatchdog::boundaries, geo::PlaneGeo::Cell(), d, Dot(), geom(), geo::CellGeo::GetCenter(), geo::CellGeo::HalfD(), geo::CellGeo::HalfL(), geo::CellGeo::HalfW(), MECModelEnuComparisons::i, geo::kY, LOG_VERBATIM, Mag(), geo::GeometryBase::Plane(), demo5::surf, Unit(), geo::PlaneGeo::View(), and ZBounds().

Referenced by calib::StopperThreshold::FillHist(), trk::CosmicTrackAna::FillTrackHistograms(), calib::StopperThreshold::FillTree(), numusand::NumuSandFxs::getAveTrackdEdxLast4Cells(), numusand::NumuSandFxs::getAveTrackdEdxLast6Cells(), numusand::NumuSandFxs::getAveTrackdEdxLast8Cells(), trackinfo::TrackInfoFxs::getAveTrackdEdxLastCells(), calib::PCHitsList::ProcessTrackTrajectory(), and calib::StopperThreshold::testPath().

  {
    art::ServiceHandle<geo::Geometry> geom;
    
    double xyz[3] = {0.};
    geom->Plane(pc.first)->Cell(pc.second)->GetCenter(xyz);
    TVector3 cellCenter = TVector3(xyz);
    TVector3 cellExtent = TVector3(geom->Plane(pc.first)->Cell(pc.second)->HalfW(),
                                   geom->Plane(pc.first)->Cell(pc.second)->HalfL(),
                                   geom->Plane(pc.first)->Cell(pc.second)->HalfD());
    if(geom->Plane(pc.first)->View() == geo::kY)
      cellExtent = TVector3(geom->Plane(pc.first)->Cell(pc.second)->HalfL(),
                            geom->Plane(pc.first)->Cell(pc.second)->HalfW(),
                            geom->Plane(pc.first)->Cell(pc.second)->HalfD());
    
    // find the trajectory points of the track that bound this
    // hit in z and determine where the hit is expected to be
    // based on the direction of the track between the trajectory
    // points
    calib::zBounds boundaries = ZBounds(zBounds, xyz[2]);

    
    TVector3 lowerPlaneBound = boundaries.first;
    TVector3 upperPlaneBound = boundaries.second;
    
    // now determine where the trajectory intersects the cell boundaries
    // evaluate the point where the line intersects the plane of each
    // boundary and see if that point is within the cell
    // see http://en.wikipedia.org/wiki/Line–plane_intersection
    
    float pathLength = 0.;
    float d = 0.;
    // all vectors are in order of -x, +x, -y, +y, -z, +z
    
    // determine a point on each plane bounding the cell
    // define the edges of the cell using its center and extent values
    auto pointsList = {TVector3(cellCenter.X() - cellExtent.X(), cellCenter.Y(),                  cellCenter.Z()),
                       TVector3(cellCenter.X() + cellExtent.X(), cellCenter.Y(),                  cellCenter.Z()),
                       TVector3(cellCenter.X(),                  cellCenter.Y() - cellExtent.Y(), cellCenter.Z()),
                       TVector3(cellCenter.X(),                  cellCenter.Y() + cellExtent.Y(), cellCenter.Z()),
                       TVector3(cellCenter.X(),                  cellCenter.Y(),                  cellCenter.Z() - cellExtent.Z()),
                       TVector3(cellCenter.X(),                  cellCenter.Y(),                  cellCenter.Z() + cellExtent.Z())};
    std::vector<TVector3> pointsInPlanes(pointsList);
    
    auto normalList = {TVector3(-1.,  0.,  0.),
                       TVector3( 1.,  0.,  0.),
                       TVector3( 0., -1.,  0.),
                       TVector3( 0.,  1.,  0.),
                       TVector3( 0.,  0., -1.),
                       TVector3( 0.,  0.,  1.) };
    std::vector<TVector3> normalVects(normalList);
    
    std::vector<TVector3> intersections;
    TVector3 intersect;
    
    // vector describing the boundaries of this cell
    auto boundList = {pointsInPlanes[0].X() - 1.e-4, pointsInPlanes[1].X() + 1.e-4,
                      pointsInPlanes[2].Y() - 1.e-4, pointsInPlanes[3].Y() + 1.e-4,
                      pointsInPlanes[4].Z() - 1.e-4, pointsInPlanes[5].Z() + 1.e-4};
    std::vector<double> cellBounds(boundList);
    
    // check that the reco hit is between the bounds, return 0 if not
    if(recoHitLoc.X() < cellBounds[0] || recoHitLoc.X() > cellBounds[1] ||
       recoHitLoc.Y() < cellBounds[2] || recoHitLoc.Y() > cellBounds[3] ||
       recoHitLoc.Z() < cellBounds[4] || recoHitLoc.Z() > cellBounds[5])
      return 0.;
    
    // the recoHitLoc is the determined 3D position for the given hit
    // the plane bounds are the 3D positions where the track crosses the
    // plane containing this hit in the upstream and downstream locations
  
    // the vector from the upstream and downstream locations gives the direction
    // from one side of the plane to the other.  Grab the location of the hit
    // and then walk along the direction vector until we step out of the cell
    // be sure to check the boundary of the cell in both the z direction and
    // in the width of the cell
    TVector3 traj = (upperPlaneBound - lowerPlaneBound).Unit();
    
    // loop over the different planes bounding the cell and find the intersection points
    // go in the reverse order and remove any surfaces where the intersection is outside
    // of the bounds of the cell
    for(size_t surf = 0; surf < normalVects.size(); ++surf){

      bool repeatIntersection = false;

      // check that you can do the calculation, if not, there is no
      // intersectoin with that surface and we remove it.
      if( std::abs(traj.Dot(normalVects[surf])) > 0. ){
        d = (pointsInPlanes[surf] - lowerPlaneBound).Dot(normalVects[surf])/traj.Dot(normalVects[surf]);
        intersect = d*traj + lowerPlaneBound;
        
        // LOG_VERBATIM("CalibUtils") << "intersection: "
        //                                   << intersect.X() << " "
        //                                   << intersect.Y() << " "
        //                                   << intersect.Z() << " surf "
        //                                   << surf << " "
        //                                   << normalVects[surf].X() << " "
        //                                   << normalVects[surf].Y() << " "
        //                                   << normalVects[surf].Z() << " "
        //                                   << d << " "
        //                                   << d*traj.X() << " "
        //                                   << d*traj.Y() << " "
        //                                   << d*traj.Z();

        // check that the intersection is between the bounds of the cell
        // if not, remove the intersection, allow the boundaries to be fuzzy by
        // 0.1 cm to account for rounding errors
        if(intersect.X() > cellBounds[0] && intersect.X() < cellBounds[1] &&
           intersect.Y() > cellBounds[2] && intersect.Y() < cellBounds[3] &&
           intersect.Z() > cellBounds[4] && intersect.Z() < cellBounds[5]){

          // check that the intersection is not already in the vector
          // that can happen if the intersection is in a corner of the cell, then
          // two surfaces have the same intersection
          for(auto p : intersections){
            if(std::abs(p.X() - intersect.X()) < 0.01 &&
               std::abs(p.Y() - intersect.Y()) < 0.01 &&
               std::abs(p.Z() - intersect.Z()) < 0.01 ){
                // LOG_VERBATIM("CalibUtils") << "intersection point repeats " << intersect.X()
                //                               << " " << intersect.Y() << " " << intersect.Z();
              repeatIntersection = true;
              break;
            }
          } // end loop to look for a repeat intersection
          if(!repeatIntersection) intersections.push_back(intersect);

        } // end if there is a legit intersection
      }// end if the denominator is non-zero
    }// end loop over surfaces
    
    // better have just 2 intersections at this point
    // possible to have only one, if the track appears to stop in the cell, then use the reco hit location as
    // one end point
    if(intersections.size() > 2){
      LOG_VERBATIM("CalibUtils")
      << "reco hit location: "
      << recoHitLoc.X() << " " << recoHitLoc.Y() << " " << recoHitLoc.Z()
      <<"\ncell center: "
      << cellCenter.X() << " " << cellCenter.Y() << " " << cellCenter.Z()
      << "\ncell boundaries: "
      << cellBounds[0] << " " << cellBounds[1] << " "
      << cellBounds[2] << " " << cellBounds[3] << " "
      << cellBounds[4] << " " << cellBounds[5];
      

      LOG_VERBATIM("CalibUtils")
      << "upper bound: "
      << upperPlaneBound.X() << " "
      << upperPlaneBound.Y() << " "
      << upperPlaneBound.Z() << "\nlower bound: "
      << lowerPlaneBound.X() << " "
      << lowerPlaneBound.Y() << " "
      << lowerPlaneBound.Z() << "\ntrajectory: "
      << traj.X() << " " << traj.Y() << " " << traj.Z();

      for(auto i : intersections)
        LOG_VERBATIM("CosmicTrackUtilitites")
        << "intersection point: "
        << i.X() << " " << i.Y() << " " << i.Z();
    
      throw cet::exception("CalibUtils")
      << "too many cell surfaces intersected "
      << "by trajectory: " << intersections.size();
    }
    else if(intersections.size() == 1)
      pathLength = (intersections[0] - recoHitLoc).Mag();
    else if(intersections.size() < 1)
      pathLength = 0.;
    else
      pathLength = (intersections[0] - intersections[1]).Mag();
    
    return pathLength;
  }

zBounds calib::ZBounds	(	zBoundMap const &	bounds,
		double const &	hitZ
	)

Return the bounding points for a given z position along a track.

Parameters

bounds	The z position boundaries for each trajectory point on the track
hitZ	The z position of the trajectory point in question

Definition at line 462 of file CalibUtil.cxx.

References geo::PlaneGeo::Cell(), geom(), geo::CellGeo::HalfD(), and geo::GeometryBase::Plane().

Referenced by PathLengthInCell().

  {
    if(bounds.empty())
      throw cet::exception("CalibUtil")
      << "bounds map has no entries, cannot "
      << "find bounding points for hit z location: "
      << hitZ;
    
    // for(auto itr = bounds.begin(); itr != bounds.end(); ++itr)
    //   LOG_VERBATIM("CalibUtils") << "hit z: " << hitZ << " " << itr->first << " lower "
    //                                     << itr->second.first.X() << " "
    //                                     << itr->second.first.Y() << " "
    //                                     << itr->second.first.Z() << " upper "
    //                                     << itr->second.second.X() << " "
    //                                     << itr->second.second.Y() << " "
    //                                     << itr->second.second.Z();
    art::ServiceHandle<geo::Geometry> geom;
    double planeZDepth  = 2.*geom->Plane(0)->Cell(0)->HalfD();
    
    zBoundMap::const_iterator lbitr = bounds.lower_bound(hitZ - planeZDepth);
    
    // if we did not find an iterator, then the z position passed is
    // off the edge of the track, use the last entry in the map
    if(lbitr == bounds.end() )
      return zBounds(bounds.rbegin()->second.first, bounds.rbegin()->second.second);
    
    return zBounds(lbitr->second.first, lbitr->second.second);
    
  }

Variable Documentation

const double calib::GeV2MeV = CLHEP::GeV / CLHEP::MeV

static

Definition at line 43 of file EnergyStandardCandles_module.cc.

Referenced by calib::EnergyStandardCandles::FillMichelRecoInfo(), calib::EnergyStandardCandles::FillTrueMichelInfo(), and calib::EnergyStandardCandles::FillTruthInfo().

const double calib::j = 0.200

Definition at line 29 of file BetheBloch.cxx.

Referenced by stan::math::matrix_exp_action_handler::action(), add_and_normalize_LLhistos(), nova::database::Table::AddDistinctColumn(), nova::dbi::Table::AddDistinctColumn(), nutools::dbi::Table::AddDistinctColumn(), genie::flux::GNuMIFlux::AddFile(), earms::GridSearch::AddHoughIntersections(), nova::database::Table::AddOrderColumn(), nova::dbi::Table::AddOrderColumn(), nutools::dbi::Table::AddOrderColumn(), genie::BLI2DNonUnifGrid::AddPoint(), fuzz::FuzzyKVertex::AddProng(), earms::GridSearch::AddVtxPoints(), om::FEBRateAnalysis::AnaFile(), AnalyseBinningSchemes(), novaddt::SingletonRejectionAna::analyze(), calhit::CalHitAna::analyze(), rsim::MakeNoiseSpectrumFile::analyze(), mcchk::CloseInTime::analyze(), G4MismatchAna::analyze(), zcl::SMMTriggerAna::analyze(), mcchk::ShowerAnaCheck::analyze(), slicer::S4DParamCalc::analyze(), beamlinereco::ToFSingleCounterAnalysis::analyze(), sn::SNSlicerAna::analyze(), slicer::IdenticalSlicerAna::analyze(), testbeam::TestBeamCommissioning::analyze(), pa::HitEva::analyze(), vf::TrackEva::analyze(), validation::NoiseClusterAnalysis::analyze(), comi::NumiFilteringAna::analyze(), showere::ShowerEnergyAna::analyze(), slicer::SlicerAna::analyze(), remid::ReMIdDedxRock::analyze(), comi::NearlineAna::analyze(), fuzz::FuzzyKValidate::analyze(), remid::ReMIdDedxFD::analyze(), remid::ReMIdDedxStudies::analyze(), beamlinereco::ToFAnalysisMini::analyze(), bpfit::BreakPointProtonAna::analyze(), LightLevels::analyze(), air::AirKalmanAna::analyze(), ncs::GenieTruth::analyze(), ncs::Xeff::analyze(), nnbar::RecoAnalysis::analyze(), beamlinereco::ToFPositionRecoAnalysis::analyze(), htk::HoughTrack::analyze(), comi::FEBFlash::analyze(), AnaPlotMaker(), append(), stan::math::append_col(), stan::math::append_row(), stan::math::apply_scalar_unary< F, T >::apply(), stan::model::assign(), om::PlotOptions::AutoScale(), evd::TZProjPad::AutoZoomTruth(), bpfit::BreakPoint::AverageXY(), chaninfo::BadChanList::BadChanList(), beamlinereco::ToFSingleCounterAnalysis::beginJob(), beamlinereco::ToFAnalysisMini::beginJob(), beamlinereco::ToFPositionRecoAnalysis::beginJob(), DataCheck::HardwareStatusCheck::beginSubRun(), comi::DataCheck::beginSubRun(), ana::best_spline_fcn0(), ana::best_spline_make_mode_graph(), ana::best_spline_seeds(), me::MEFinder::BestSlcMatch(), ana::AtmConstraint::BiCubicInterp(), bin_composition_pie_chart(), BuildEmuEnuCosThetaPdf(), osc::PMNS_Sterile::BuildHms(), geo::GeometryBase::BuildMaps(), nova::database::Table::BulkInsertInDB(), caf_numu_fd_validation_data(), caf_numu_fd_validation_MC(), caf_numu_fd_validation_MC_no_tau(), bpfit::Lutz::CalcD(), bpfit::Lutz::Calcq(), ana::MultiverseCorrelation::calculate_correlation_matrix(), ana::MultiverseCorrelation::calculate_covariance_matrix(), CalculateCovarianceMatrix(), caldp::TCTrack::CalculateFiberVelocity(), caldp::TCTrack::CalculateMuonVelocity(), CalculateTotalCovariance(), cafrwgt::CAFReweight::CalcWeightVector(), bpfit::Lutz::Calcx(), bpfit::Lutz::CalcZeta(), trk::KalmanTrack::CellToPlaneSort(), trk::KalmanTrack::CellToPlaneSortHits(), stan::math::algebra_solver_vari< Fs, F, T, Fx >::chain(), stan::math::cholesky_block::chain(), stan::math::cholesky_scalar::chain(), osc::_OscCalcDMP< T >::ChannelCacheIdx(), osc::OscCalcPMNSOptEigen::ChannelCacheIdx(), stan::test::unit::check_adaptation(), stan::test::unit::check_different(), fuzz::FuzzyKMeanAlg::CheckUnique(), nova::database::Table::CheckValidXMLDef(), nova::dbi::Table::CheckValidXMLDef(), bpfit::Lutz::Chi2Beta(), bpfit::Lutz::Chi2BetaJ(), ana::LikelihoodCovMxExperiment::ChiSq(), ana::OscCovMxExperiment::ChiSq(), stan::math::chol2inv(), stan::math::cholesky_block::cholesky_block(), stan::math::cholesky_corr_constrain(), stan::math::cholesky_corr_free(), stan::math::cholesky_decompose(), stan::math::cholesky_scalar::cholesky_scalar(), genie::utils::math::CholeskyDecomposition(), earms::GridSearch::ChooseBestProngDir(), slicer::PointManager::CleanUpNeighborhood(), me::MEFinder::ClusterMEHits(), stan::math::columns_dot_product(), cmf::CovarianceBinUtility::CompactMatrix(), compare_cos_numi(), compare_fits(), CompareMCCompPrediction(), stan::math::LDLT_alloc< R, C >::compute(), keras::LayerFlatten::compute_output(), keras::LayerMaxPooling::compute_output(), keras::LayerActivation::compute_output(), keras::LayerConv2D::compute_output(), keras::LayerDense::compute_output(), fuzz::FuzzyKMeanAlg::ComputeA(), bpfit::dEdxCalculator::computeDEDX(), fuzz::FuzzyKMeanAlg::ComputeDij(), genie::DFRKinematicsGenerator::ComputeMaxXSec(), genie::DISKinematicsGenerator::ComputeMaxXSec(), genie::SKKinematicsGenerator::ComputeMaxXSec(), genie::DMDISKinematicsGenerator::ComputeMaxXSec(), fuzz::FuzzyKMeanAlg::ComputeUij(), CondenseRunList(), cafrwgt::CAFReweight::Configure(), g4n::G4Alg::ConfigUserActionManager(), confusionMatrix(), confusionMatrixProng(), osc::conjugate_elements(), om::PlotViewer::ContentProjectionTH2F(), ContourComparisonPlot(), keras::conv_single_depth_same(), keras::conv_single_depth_valid(), ConvertToGINuke(), ConvertToGST(), om::HitMaps::CopyHistContent(), nnbar::NNbarUtilities::correlationTCell(), nnbar::NNbarUtilities::correlationTPlane(), cmf::CovarianceTools::CorrToCov(), airshower::AirSlicer::CountActiveDCM(), chaninfo::BadChanList::CountDCMHits(), stan::math::cov_exp_quad(), stan::math::cov_exp_quad_vari< T_x, T_sigma, T_l >::cov_exp_quad_vari(), stan::math::cov_exp_quad_vari< T_x, double, T_l >::cov_exp_quad_vari(), cmf::CovarianceTools::CovToCorr(), cmf::CovarianceTools::CovToFracCov(), nova::database::Table::CreateFromDB(), nova::database::Table::CreateFromXML(), nova::dbi::Table::CreateFromXML(), rsim::ReadoutSim::CreateRawDigits(), CVNCuts(), cmf::CMFDecorrelator::CycleMatrixComponents(), CylindricalSmoothing(), d3sigma_calc(), d4sigma_calc(), d4sigma_hist(), d4sigma_plot(), DCMOffsetCalculator(), caldp::DCMSummary::DCMOffsetCountIndx(), caldp::DCMSummary::DCMOffsetSumIndx(), caldp::DCMSummary::DCMOffsetSumSquareIndx(), ana::MinuitFitter::DecodePars(), ana::StanFitter::DecodePars(), DecorrelateFD(), DecorrelateND(), stan::math::coupled_ode_system< F, double, var >::decouple_states(), stan::math::coupled_ode_system< F, var, double >::decouple_states(), stan::math::coupled_ode_system< F, var, var >::decouple_states(), genie::alvarezruso::ARSampledNucleus::Density(), genie::alvarezruso::ARSampledNucleus::DensityOfCentres(), stan::math::determinant(), stan::math::diag_post_multiply(), stan::math::diag_pre_multiply(), ValidCalibPDF::DiblockTex(), diffapdhv(), stan::io::random_var_context::dim_size(), stan::math::divide(), novaddt::HoughTrackMaker::do_like_zukai(), fuzz::FuzzyKMeanAlg::DoClustering(), nueccinc_test::NueCCIncGlobalFitter::doFullFit(), slicemergeviews::SliceMergeViews::DoMerge(), evd::PlotView::Draw(), evd::MCTrueView::Draw(), drawBinLines(), DrawBins(), DrawHiddenParameter(), evd::RecoBaseDrawer::DrawHoughResults2D(), drawIntensityEffect_2019(), drawLongTerm(), drawLongTerm_2019(), DrawPulls(), DrawSurface(), drawVsPOT(), nova::dbi::RunHistory::Dump(), stan::math::internal::ops_partials_edge< double, std::vector< Eigen::Matrix< var, R, C > > >::dump_operands(), stan::math::internal::ops_partials_edge< double, std::vector< std::vector< var > > >::dump_operands(), stan::math::internal::ops_partials_edge< double, std::vector< Eigen::Matrix< var, R, C > > >::dump_partials(), stan::math::internal::ops_partials_edge< double, std::vector< std::vector< var > > >::dump_partials(), stan::math::internal::ops_partials_edge< Dx, std::vector< Eigen::Matrix< fvar< Dx >, R, C > > >::dx(), stan::math::internal::ops_partials_edge< Dx, std::vector< std::vector< fvar< Dx > > > >::dx(), ana::ICrossSectionAnalysis::DXDY(), ana::ICrossSectionAnalysis::DXDYDZ(), efficiency(), efficiencySA(), ana::EigenMatrixXdFromTMatrixD(), mcchk::ShowerAnaCheck::EMMoliereRadius(), cmf::CovarianceBinUtility::EmptyBins(), mcchk::ShowerAnaCheck::EMShowerWidth(), rsim::MakeNoiseSpectrumFile::endJob(), comi::DataCheck::endJob(), bpfit::BPFdEdxHistoMaker::endJob(), calib::DCMTimingOffset::endJob(), beamlinereco::ToFPositionRecoAnalysis::endJob(), calib::AbsCalib::endRun(), calib::DCMTimingOffset::endRun(), comi::ChanOcc::endSubRun(), calib::TimingCalFilter::endSubRun(), calib::DCMTimingOffset::endSubRun(), ana::Kriger::EnsureMatrix(), ErrorBand(), osc::_PMNS< T >::EvalEqn5(), om::HitMaps::EvalFEBShutOff(), rb::Cluster::Exclude(), stan::math::exp_action_chain_vd(), ana::ExPIDPlot(), ExPIDPlot(), fake_future_data(), fcn(), fcn2Var(), FD_plots(), rsim::IFPGAAlgorithm::FetchThresholds(), genie::GiBUURESFormFactor::FormFactors::FFRes(), geo::LiveGeometry::FillBadBoxes(), nutools::dbi::Table::FillChanRowMap(), nova::dbi::Table::FillChanRowMap(), ana::NumuCCIncPionTemplateFitter::FillCovarianceBetweenSysts(), ana::nueccinc::NueCCIncTemplateFitter::FillCovarianceBetweenSysts(), cmf::ChiSqrCalculator::FillCovarianceMatrix(), ana::nueccinc::NueCCIncTemplateFitter::FillCovarianceMatrix(), ana::NumuCCIncPionTemplateFitter::FillCovarianceMatrix(), ana::NumuCCIncPionTemplateFitter::FillCovarianceMatrixExtra(), nueccinc_test::NueCCIncGlobalFitter::FillCovarianceMatrixFull(), nueccinc_test::NueCCIncGlobalFitter::FillCovarianceMatrixReduced(), genie::alvarezruso::ARSampledNucleus::FillDensities(), tdslicer::TDSlicer::FillDists(), FillHists(), hv::HoughVertexAlg::FillMaps(), caf::FillNumuInfo(), nueccinc_test::NueCCIncGlobalFitter::FillParameterCovariance(), sn::SupernovaAna::FillPlaneSeperations(), ana::PredictionInterp::ShiftedPreds::FillRemaps(), nueccinc_test::NueCCIncGlobalFitter::FillStatisticalCovarianceMatrixFull(), nueccinc_test::NueCCIncGlobalFitter::FillStatisticalCovarianceMatrixReduced(), ana::nueccinc::NueCCIncTemplateFitter::FillStatisticCovarianceMatrix(), ana::NumuCCIncPionTemplateFitter::FillStatisticCovarianceMatrix(), ana::FrequentistSurface::FillSurfacePoint(), novaddt::NuMuTrigger::filter(), novaddt::ActivityTrigger::filter(), novaddt::ActivityTriggerAna::filter(), comi::NumiFiltering::filter(), novaddt::ClusterConvert::filter(), novaddt::SlowMMTrigger::filter(), calib::MuondEdx::filter(), calib::DetRespDrift::filter(), showere::ShowerEnergyFilterMC::filter(), calib::MuonTrackHits::filter(), calib::MuondEdxAna::filter(), comi::FEBFlash::FilterFEBFlash(), util::FilterFEBFlash(), novaddt::ContainedSlice::filterForContainedHitLists(), novaddt::SingletonRejection::filterNoise(), earms::GridSearch::FindBestVtx(), beamlinereco::CFDHitFinder< T >::FindCFDHits(), dq::FlasherFinder::FindInstigators(), bpfit::Path::FindLayers(), beamlinereco::LEHitFinder< T >::FindLEHits(), lem::FindMatches(), lem::FindMatchesAlg::FindMatchesHeads(), slicer::PointManager::FindNeighbors(), airshower::AirSlicer::FindNeighbors(), FindNewDQRuns(), FindNewDQRunsND(), fuzz::FuzzyKVertex::FindOrphanedHits(), nerd::NERDProng::FindOrphanedHits(), beamlinereco::LEHitFinder< T >::FindRawHitLogic(), beamlinereco::CFDHitFinder< T >::FindRawHitLogic(), earms::ElasticArmsHS::FindSeed(), art::TriggerNamesService::findTrigPath(), fuzz::FuzzyKMeanAlg::FindUnclustered(), trident::DimuonSliceAna::FindVertex(), bpfit::DimuonFitter::FindVertexZ(), trk::KalmanTrackAna::FindVisibleProngs(), cheat::RecoCheckAna::FindVisibleProngs(), fuzz::FuzzyKValidate::FindVisibleProngs3D(), fuzz::FuzzyKVertex::FindVisibleProngs3D(), stan::math::finite_diff_hessian(), trk::RLFit::Fit(), bpfit::Lutz::Fit(), ana::MinuitFitter::FitHelperSeeded(), bpfit::BreakPoint::FitTracks(), trk::CosmicTrackAlg::FitView(), novaddt::TrackFit::FitView(), evd::SimulationDrawer::FLSHit2D(), evd::SimulationDrawer::FLSHit3D(), FOMPlot(), for(), cmf::CovarianceTools::FracCovToCov(), FracToFull(), fragmentAngularDistribution(), fragmentAngularDistributionGM(), fragmentEnergyDistributionDifferentAngles(), fragmentYieldsPlot(), cosrej::CosRejFxs::FScatterEstim(), g4n::G4Alg::G4Alg(), stan::math::gaussian_dlm_obs_lpdf(), generate_fc_binlists(), stan::lang::write_array_visgen::generate_initialize_array(), stan::lang::init_local_var_visgen::generate_initialize_array(), genie::NNBarOscPrimaryVtxGenerator::GenerateDecayProducts(), genie_syst_make(), genie_syst_pca(), genie_syst_shifts(), genie_syst_universe(), genie::alvarezruso::ARWavefunction::get(), get_mass(), cet::sqlite::detail::get_result(), get_rms(), cosrej::CosRejFxs::getBBC(), geo::LiveGeometry::GetBCInfo(), evd::GeometryDrawer::GetBox(), evd::RecoBaseDrawer::GetClusterOutlines(), getColors(), nutools::dbi::Table::GetColsFromDB(), GetCommandLineArgs(), ana::NumuCCIncPionTemplateFitter::getCorrelationBetweenSysts(), ana::nueccinc::NueCCIncTemplateFitter::getCorrelationBetweenSysts(), nueccinc_test::NueCCIncGlobalFitter::getCorrelationMatrix(), nueccinc_test::NueCCIncGlobalFitter::getCorrelationMatrixReduced(), ana::NumuCCIncPionTemplateFitter::getCorrelationMatrixTemplateBins(), ana::nueccinc::NueCCIncTemplateFitter::getCorrelationMatrixTemplateBins(), ana::covmx::CovarianceMatrix::GetCorrMxTH2(), nueccinc_test::NueCCIncGlobalFitter::getCovarianceMatrix(), nueccinc_test::NueCCIncGlobalFitter::getCovarianceMatrixReduced(), ana::NumuCCIncPionTemplateFitter::getCovarianceMatrixTemplateBins(), ana::nueccinc::NueCCIncTemplateFitter::getCovarianceMatrixTemplateBins(), ana::covmx::CovarianceMatrix::GetCovMxAbsoluteTH2(), ana::covmx::CovarianceMatrix::GetCovMxRelativeTH2(), GetCrossSection(), nuesand::FillNueSandbox::GetECF(), GetExtrap(), nueccinc_test::NueCCIncGlobalFitter::getFitParameterCorrelation(), nueccinc_test::NueCCIncGlobalFitter::getFitParameterCovariance(), ana::covmx::CovarianceMatrix::GetFullCorrMx(), ana::covmx::CovarianceMatrix::GetFullCorrMxTH2(), ana::covmx::CovarianceMatrix::GetFullCovMxTH2(), ana::AtmConstraint::GetGridMatrix(), novaddt::MoonShadow::GetHisto(), moonshadowana::MoonShadowAna::GetHisto(), moonshadowana::MoonShadowAnaHough::GetHisto(), airshower::AirSlicer::GetHoughAngles(), airshower::AirSlicer::GetHoughMap(), airshower::AirSlicer::GetHoughRhos(), genie::alvarezruso::AlvarezRusoCOHPiPDXSec::GetLeptonMass(), evd::SimulationDrawer::GetLimits(), nnbar::NNbarUtilities::getMultipleCellFraction(), om::HitMaps::GetNanoSliceSummary(), ana::Multiverse::GetNSigmaShift(), ana::GetNSigmaShift(), osc::OscCalcSterileBeam::GetParamsHash(), GetPartList_4DB(), tdslicer::TDSlicer::GetPtInfo(), gibuu::RecordLoader::GetRecord(), ana::LikelihoodCovMxExperiment::GetReducedGradAndHess(), geo::LiveGeometry::GetRHInfo(), nova::database::Table::GetRowByColSet(), nova::database::Table::GetRowByPKey(), getStabilitySpectra(), osc::OscCalcSterile::GetState(), nueccinc_test::NueCCIncGlobalFitter::GetTemplateWeightsAndErrors(), evd::SimulationDrawer::GetTimeLimits(), getTimePeakPlots(), gov::fnal::cd::rms::util::UUIDGenerator::getUUIDHex(), evd::SimulationDrawer::GetVertexPoints(), genie::geometry::ROOTGeomAnalyzer::GetWeight(), nnbar::NNbarUtilities::getXyAsymmetry(), fuzz::FuzzyKValidate::GeVCalc(), goFNBasis(), goodness_of_fit(), stan::math::gp_dot_prod_cov(), stan::math::gp_periodic_cov(), stan::math::gp_periodic_cov_vari< T_x, T_sigma, T_l, T_p >::gp_periodic_cov_vari(), stan::math::gp_periodic_cov_vari< T_x, double, T_l, T_p >::gp_periodic_cov_vari(), stan::math::grad_hessian(), ana::GraphWithPoissonErrors2(), vdt::gsFCN(), genie::alvarezruso::AlvarezRusoCOHPiPDXSec::H(), om::IPC::HandleCurrentWatchListRequests(), DecTreeLoader::HandlePOT(), om::WatchListBox::HandleRemoveFromList(), heatMap(), stan::math::hessian(), om::HitMaps::HitMaps(), util::HoughCalc::HoughCalc(), remid::RecoMuon::Init(), daqdataformats::DCMSimulator::initFEBList(), genie::GRV98LO::Initialize(), cmf::ChiSqrCalculator::InitializeCovarianceMatrix(), genie::INukeHadroData2018::IntBounce(), genie::INukeHadroData::IntBounce(), stan::math::inverse(), nueccinc_test::NueCCIncGlobalFitter::InvertCovarianceMatrix(), dq::FlasherFinder::IsInstigator(), joint_fit_2017_fc_submit(), joint_fit_future_bestfit_univ(), joint_fit_future_contour_univ(), fuzz::FuzzyKMeanAlg::Jpfuz(), keras::KerasModel::KerasModel(), ana::kNue2017BasicPartFunc(), hough::IslandsTH2::LabelIslands(), genie::NievesQELCCPXSec::leviCivita(), levy_func_problem(), ana::LikelihoodCovMxExperiment::LikelihoodCovMxNewton(), lin_solve(), util::LinFitTS(), stan::math::lkj_corr_cholesky_rng(), stan::math::lmgamma(), genie::NievesQELCCPXSec::LmunuAnumu(), nerd::NERDEval::load_anchors(), genie::flux::GNuMIFlux::LoadBeamSimData(), nutools::dbi::Table::LoadConditionsTable(), evd::MCTrueView::LoadEvent(), nova::dbi::RunHistory::LoadFEBMasksFromDAQDB(), nova::database::Table::LoadFromCSV(), nova::dbi::Table::LoadFromCSV(), nutools::dbi::Table::LoadFromCSV(), nova::database::Table::LoadFromDB(), nova::dbi::Table::LoadFromDB(), nutools::dbi::Table::LoadFromDB(), ana::FrequentistSurface::LoadFromMulti(), nova::database::Table::LoadFromSSV(), g4n::LoadNeutronFates(), nutools::dbi::Table::LoadNonConditionsTable(), nova::dbi::Table::LoadNonValidityTable(), nova::dbi::RunHistory::LoadPixelInfo(), genie::GiBUURESFormFactor::FormFactors::LoadTables(), nova::dbi::Table::LoadValidityTable(), readFlux::Loop(), lsqr_fprime(), lu_factorize(), main(), make1DsAndRatio(), make_angle_plot(), make_fc_mass_and_oct_nersc_2018(), make_fc_mass_and_oct_nersc_2019(), make_fc_mh_nersc_2018(), make_fc_mh_nersc_2019(), make_fc_nus_surfs_nersc_2019(), make_fc_oct_nersc_2018(), make_fc_oct_nersc_2019(), make_fc_slices_nersc_2018(), make_fc_slices_nersc_2018_stats(), make_fc_slices_nersc_2019(), make_fc_surfaces_2020(), make_fc_surfaces_2020_validation(), make_fc_surfaces_nersc_2018(), make_fc_surfaces_nersc_2018_stats(), make_fc_surfaces_nersc_2019(), stan::math::make_nu(), make_pi0_xcheck(), make_pid(), ana::make_simple_res_plot(), make_template(), make_UU_plot(), MakeAverageTrueEnergySurface(), genie::geometry::GeomVolSelectorFiducial::MakeBox(), dt::View::MakeChunkCombos(), nerd::NERDProng::MakeCluster(), nutools::dbi::Table::MakeConditionsCSVString(), MakeDQValidityCSV(), MakeDQValidityCSVND(), g4rwgt::MakeG4WeightTable::MakeG4WeightTable(), makeHWwatchlist(), osc::EarthModel::MakeLayers(), MakeNus17CosBkgd(), MakeNus18CosBkgd(), evtsum::EventSummary::MakeOutput(), makePlots(), MakePlots(), genie::geometry::GeomVolSelectorRockBox::MakeRockBox(), MakeSummaryTable(), MakeSurface(), MakeTestStandPlots_AllRuns(), MakeTestStandPlots_NewRuns(), om::HistoSet::MakeTH1FCopies(), om::HistoSet::MakeTH2FCopies(), airshower::AirSlicer::MakeTrackSlices(), nova::dbi::Table::MakeValidityCSVString(), makeXSecPlots2D(), makeXSecPlots_TemplateFit(), hough::Hough2P::Map(), hough::MultiHough2P::Map(), nova::dbi::RunHistory::MapHardwareToLocation(), lem::MatchableEvent::MatchableEvent(), fuzz::ViewMatchAlg::Matching(), nerd::ViewMatchAlg::Matching(), trk::KalmanTrackMerge::MatchTracks(), stan::io::reader< T >::matrix_lb(), stan::io::reader< T >::matrix_lb_constrain(), stan::io::writer< T >::matrix_lb_unconstrain(), stan::io::reader< T >::matrix_lub(), stan::io::reader< T >::matrix_lub_constrain(), stan::io::writer< T >::matrix_lub_unconstrain(), stan::io::reader< T >::matrix_ub(), stan::io::reader< T >::matrix_ub_constrain(), stan::io::writer< T >::matrix_ub_unconstrain(), stan::io::writer< T >::matrix_unconstrain(), genie::geometry::ROOTGeomAnalyzer::MaxPathLengthsBoxMethod(), genie::COHKinematicsGenerator::MaxXSec_BergerSehgal(), genie::COHKinematicsGenerator::MaxXSec_BergerSehgalFM(), genie::COHKinematicsGenerator::MaxXSec_ReinSehgal(), evd::MCTrueView::MCTrueView(), evd::SimulationDrawer::MCTruthShortText(), evd::SimulationDrawer::MCTruthTrajectoriesAnyD(), evd::SimulationDrawer::MCTruthVectors2D(), evd::SimulationDrawer::MCTruthVectors3D(), earms::ElasticArmsHS::MCVertex(), stan::math::mdivide_left(), stan::math::mdivide_left_ldlt(), stan::math::mdivide_left_spd(), stan::math::mdivide_left_tri(), stan::math::mdivide_left_tri_low(), stan::math::mdivide_right(), stan::math::mdivide_right_tri_low(), mec_nux_tester_2020(), mec_tuning(), mec_tuning_fitter_2020(), median_contours(), fuzz::FuzzyKMeanAlg::MergeClusters(), om::MicroErrors::MicroErrors(), keras::missing_activation_impl(), nerd::NERDEval::mold_input(), osc::_PMNS< T >::Multi(), stan::math::multi_normal_cholesky_lpdf(), stan::math::multi_normal_lpdf(), stan::math::multi_normal_prec_lpdf(), stan::math::multi_student_t_lpdf(), stan::math::multiply(), stan::math::multiply_lower_tri_self_transpose(), myBarChart(), nueccinc_test::NueCCIncGlobalFitter::myFunction(), ana::nueccinc::NueCCIncTemplateFitter::myFunction2Vars(), ana::NumuCCIncPionTemplateFitter::myFunction2Vars(), ana::nueccinc::NueCCIncTemplateFitter::myFunction3Vars(), ana::NumuCCIncPionTemplateFitter::myFunction3Vars(), genie::alvarezruso::ARSampledNucleus::N(), om::NanoErrors::NanoErrors(), NDFDCVNBDTCutSelector(), NDFDCVNCutSelector(), slicer::Slicer::NeighborSlice(), NewNearlinePlots(), evgen::NuMISpillTimeStructure::NewSpill(), hough::IslandsTH2::Nislands(), nova::dbi::RunHistory::NLiveDCMs(), NormalizeHists(), nuebar_signif(), nueccinc_test::NueCCIncGlobalFitter::NueCCIncGlobalFitter(), nuint09_1pi3(), nuint09_coh3(), nuint09_qel4(), nuint09_qel5(), bpfit::Lutz::NullResult(), NuSTreeMaker(), OnMonAnaHistos(), OnMonAnaHistosFEB_IssueRates(), OnMonAnaHistosPIX(), OnMonPlotMaker(), stan::math::internal::map_rect_reduce< F, var, var >::operator()(), genie::alvarezruso::ARWavefunction::operator()(), stan::math::internal::map_rect_reduce< F, double, var >::operator()(), stan::math::internal::map_rect_combine< F, T_shared_param, T_job_param >::operator()(), stan::test::unit::instrumented_writer::operator()(), stan::math::internal::map_rect_reduce< F, var, double >::operator()(), stan::math::coupled_ode_system< F, double, var >::operator()(), stan::lang::expression_visgen::operator()(), stan::math::coupled_ode_system< F, var, double >::operator()(), stan::math::coupled_ode_system< F, var, var >::operator()(), stan::lang::data_only_expression::operator()(), operator*(), nova::database::operator<<(), nutools::dbi::operator<<(), nova::dbi::operator<<(), nerd::PixelPIDMaps::operator==(), air::AirKalmanAna::OppSignTrkCount(), stan::math::ordered_logistic_rng(), stan::math::ordered_probit_rng(), ana::OverlayCutFromNuTruthCut(), osc::OscCalcPMNS_CPT::P(), osc::OscCalcPMNS_NSI::P(), osc::_OscCalcPMNS< T >::P(), osc::_OscCalcPMNSOpt< T >::P(), osc::OscCalcSterile::P(), PackMatrix(), evdb::ParameterSetEditFrame::ParameterSetEditFrame(), evd::PlotView::Parse(), ParseFluxFileConfig(), partial_pivot(), PeripheralCuts(), permute(), slid::ParticleIDAlg::Pi0Mass(), genie::HAIntranuke::PiBounce(), genie::HAIntranuke2018::PiBounce(), plot(), plot_abstree(), plot_diff(), plot_input_data(), plot_multiplicity_prob(), plot_nd_spectra_2018(), plot_pi0_xcheck(), plot_pid(), plot_residPerPlane(), plot_residPerViewV(), plot_residPerViewZ(), plot_timing_resolution(), plotapdhv(), PlotGenRatios(), PlotSignalBackground(), plotTime(), Plotting_DataAndPrediction(), genie::HAIntranuke::PnBounce(), genie::HAIntranuke2018::PnBounce(), novaddt::UpMuAna::populateFLSmap(), geo::LiveGeometry::postBeginSubRun(), pots(), ppfx_smooth_weights_make(), tensorflow::TensorflowHandler::Predict(), ana::covmx::CovarianceMatrix::Predict(), nerd::NERDEval::predict_fifo(), genie::utils::intranuke::PreEquilibrium(), genie::utils::intranuke2018::PreEquilibrium(), slicer::PointManager::PreparekDistInfo(), tdslicer::TDSlicer::Prims(), genie::alvarezruso::ARWavefunction::print(), print_decay_channels(), stan::lang::print_signature(), daqdataformats::RawDAQData::printBuffer(), nova::dbi::RunHistory::PrintChanInfo(), nova::database::Table::PrintColumns(), nutools::dbi::Table::PrintColumns(), nova::dbi::Table::PrintColumns(), novaddt::RemoveOneDSlices::printDDTSlice(), novaddt::RemoveSpatialNoise::printDDTSlice(), novaddt::ContainedSlice::printDDTSlices(), PrintErrorSurface(), osc::OscCalcPMNSOptEigen::PrintMatrixAddresses(), evdb::PrintDialog::PrintToFile(), vf::VertexFinder::produce(), filter::TruthFilter::produce(), slicer::Slicer4D::produce(), MergeCollections::MergeCollections::produce(), MergeG4Collections::MergeG4Collections::produce(), trk::KalmanTrackMerge::produce(), novaddt::TrackFit::produce(), jmshower::JMTrackMerge::produce(), numusand::FillSandbox::produce(), calib::FiberCalibration::produce(), slid::SliceLIDBuilder::produce(), cvn::CVNCosmicMapper::produce(), zcl::SPCluster::produce(), g4n::TruthSlim::produce(), cosrej::CosRej::produce(), airshower::AirSlicer::produce(), calib::TimingCalibration::produce(), earms::ElasticArmsHS::produce(), comi::Cana::produce(), sn::SNSlicer::produce(), vdt::VertexDT::produce(), lem::LEM::produce(), crvtx::CosmicRayVertex::produce(), cvntf::CVNProngEvaluatorTF::produce(), cvn::RegCVNMapper::produce(), xnue::XnuePID::produce(), cheat::MCCheater::produce(), jmshower::NueSelLID::produce(), g4rwgt::MakeG4WeightTable::produce(), slicemergeviews::SliceMergeViews::produce(), tdslicer::TDSlicer::produce(), ProducingSA(), cvn::ProngSummary::ProngSummary(), osc::PMNS_Sterile::PropMatter(), osc::_PMNSOpt< T >::PropMatter(), osc::_PMNS< T >::PropMatter(), osc::_PMNSOpt< T >::PropVacuum(), osc::_PMNS< T >::PropVacuum(), stan::math::qr_R(), stan::math::qr_thin_R(), stan::math::quad_form_diag(), genie::alvarezruso::ARSampledNucleus::Radius(), lem::dec::Forest::RandomOrthoMatrix(), Rebin(), reco_minus_true_panels(), jmshower::RecoJMShower::RecoShowers(), ana::PredictionExtendToPeripheral::ReduceHelper(), ana::PredictionExtendToPeripheral::ReduceHelperNC(), novaddt::DBSlicer::regionQuery(), ana::TrivialCrossSectionAnalysis::RelativeUncertainty(), nerd::NERDEval::remove_overlap(), murem::MuonRemove::RemoveByProngCVN(), nova::database::Table::RemoveDistinctColumn(), nova::dbi::Table::RemoveDistinctColumn(), nutools::dbi::Table::RemoveDistinctColumn(), RemoveEmptyRowsAndColumns(), trk::KalmanTrack::RemoveHitsFromSignal(), nova::database::Table::RemoveOrderColumn(), nova::dbi::Table::RemoveOrderColumn(), nutools::dbi::Table::RemoveOrderColumn(), nova::database::Table::RemoveRow(), nova::dbi::Table::RemoveRow(), nutools::dbi::Table::RemoveRow(), util::HoughCalc::Reset(), osc::_PMNS< T >::Reset(), hough::MultiHough2P::ReweightHits(), genie::alvarezruso::integrationtools::RG201D(), genie::alvarezruso::integrationtools::RG202D(), genie::alvarezruso::integrationtools::RG481D(), genie::alvarezruso::integrationtools::RG482D(), RockFilter_A(), RockFilter_D(), calib::RockMuonStopperSelection::RockMuonStopperSelection(), rootgINukeVal(), osc::PMNS_Sterile::RotateH(), stan::math::rows_dot_product(), run_evgen_test(), nerd::NERDEval::run_graph(), RunCalibration(), RunFitter(), stan::model::rvalue(), evgen::SingleGen::Sample(), SaveDataToRootFile(), ana::covmx::CovarianceMatrix::SaveTo(), SaveToPsFile(), SaveToRootFile(), stan::io::dump_reader::scan_chars(), stan::io::dump_reader::scan_number(), hough::MultiHoughT::Scrub(), earms::ElasticArmsHS::Scrub(), vdt::VertexDT::Scrub(), fuzz::FuzzyKVertex::Scrub(), nueccinc_test::NueCCIncGlobalFitter::searchFitInfo(), fuzz::FuzzyKMeanAlg::SeedA(), novaddt::TrackFit::SeedWeights(), trk::RLFit::SeedWeights(), stan::math::segment(), sensitivity_plot(), genie::alvarezruso::ARWavefunction::set(), stan::mcmc::base_hmc< Model, diag_e_metric, expl_leapfrog, BaseRNG >::set_stepsize_jitter(), osc::PMNS_Sterile::SetAngle(), caldp::DCMSummary::SetDCMOffsetCountIndx(), caldp::DCMSummary::SetDCMOffsetSumIndx(), caldp::DCMSummary::SetDCMOffsetSumSquareIndx(), genie::utils::style::SetDefaultStyle(), osc::PMNS_Sterile::SetDelta(), osc::_PMNS< T >::SetDeltaMsqrs(), SetErrors(), evgen::IsoGen::setInSurfID(), genie::geometry::GeomVolSelectorRockBox::SetMinimumWall(), osc::_PMNS< T >::SetMix(), osc::_PMNS< T >::SetMixBWCP(), osc::OscCalcSterile::SetRho(), genie::geometry::GeomVolSelectorRockBox::SetRockBoxInclusion(), genie::geometry::GeomVolSelectorRockBox::SetRockBoxMinimal(), bpfit::Lutz::SetScatteringPlane(), osc::OscCalcSterile::SetState(), cmf::CMFDecorrelator::SetTemplateMatrix(), evdb::ParameterSetEditRow::SetupListBox(), geo::LiveGeometry::SetupLiveGeo(), genie::alvarezruso::integrationtools::SG20R(), genie::alvarezruso::integrationtools::SG48R(), sg_coeff(), sha1_forRMS_hmac(), keras::DataChunk2D::show_values(), novaddt::DDTTrackMerge::simpleMerge(), novaddt::Merge2DTracks::simpleMerge(), slicer_production_validation(), comi::FEBFlash::SliceStatistics(), bpf::SliceSummary::SliceSummary(), hough::Hough2P::SmoothMap(), hough::MultiHough2P::SmoothMap(), osc::PMNS_NSI::SolveHam(), osc::PMNS_Sterile::SolveHam(), osc::_PMNSOpt< T >::SolveHam(), genie::alvarezruso::AlvarezRusoCOHPiPDXSec::SolveWavefunctions(), osc::_PMNS< T >::SortEigenvalues(), Spec2DtoHist(), specprod_numuccinc(), dt::DiscreteTracker::SpliceChains(), SplitFakeData(), stan::math::stan_print(), calib::StopperSelection::StopperSelection(), om::FEBRateAnalysis::StoreContent(), SuppressND(), genie::GHepRecord::SwapParticles(), systematics_extrap_comp_from_pred_interp(), systematics_summary_from_pred_interp(), ana::systsQ3Q0(), nova::dbi::Table::Table(), airshower::AirSlicer::TemporalClusters(), nnbar::NNbarUtilities::temporalExpand(), TEST(), TEST_F(), geo::GeometryTest::testCellPos(), testfom(), cmf::CovarianceTools::TH2ToMat(), calib::ThroughgoingSelection::ThroughgoingSelection(), util::TimeSlice(), ana::TMatrixDFromEigenMatrixXd(), stan::math::to_array_1d(), stan::math::to_array_2d(), stan::math::to_fvar(), stan::math::to_matrix(), stan::math::to_var(), ana::TrivialCrossSectionAnalysis::TotalErrors(), nnbar::NNbarUtilities::totalVisibleEnergyInView(), ana::ReweightableSpectrum::ToTH2(), ana::GenieMultiverseSpectra::ToTH2(), om::TQPlots::TQPlots(), geo::CoordinateTransformation::transformBeamToDetectorCoordinates(), geo::CoordinateTransformation::transformDetectorToBeamCoordinates(), transpose(), TrimGraph(), slicemergeviews::SliceMergeViews::TrimNoise(), tdslicer::TDSlicer::TrimNoise(), novaddt::Merge2DTracks::twoViewMerge(), ana::MultiverseCorrelation::Unifyinghists(), evgen::GFlavorOsc::UnityProbMatrix(), UnpackMatrix(), evdb::ParameterSetEditRow::UnpackParameter(), stan::mcmc::softabs_metric< Model, BaseRNG >::update_metric_gradient(), om::PlotViewer::UpdateCompare(), om::FEBRatesByDiblock::UpdateRatePlots(), uptime(), om::HistoSet::UTCResetTH2F(), ValidateDBMasks(), Validation(), validationscript(), stan::math::value_of(), stan::math::value_of_rec(), cvnneutronprongtf::CVNNeutronProngTF::vector_to_tensor(), cvnprongtf::CVNProngTF::vector_to_tensor(), dq::FlasherFinder::Veto(), zcl::FmmTrackerValidation::vfit(), zcl::FmmTrackerAna::vfit(), evdb::WindowMenu::WindowMenu(), stan::math::wishart_rng(), stan::mcmc::dense_e_point::write_metric(), novaddt::DDTEvd::WriteHitListInfo(), moonshadowana::MoonShadowAna::WriteHitListInfo(), moonshadowana::MoonShadowAnaHough::WriteHitListInfo(), cmf::CovarianceMatrixMaker::writeResults(), nova::dbi::Table::WriteToCSV(), nutools::dbi::Table::WriteToCSV(), nova::database::Table::WriteToDB(), nova::dbi::Table::WriteToDB(), nutools::dbi::Table::WriteToDB(), bpfit::Lutz::X(), zheevh3(), zhetrd3(), ana::BeamSystOrWeightBase::~BeamSystOrWeightBase(), ana::FixGibuuWeight::~FixGibuuWeight(), genie::GiBUURESFormFactor::FormFactors::~FormFactors(), ana::GeniePCASyst::~GeniePCASyst(), and ana::NumuSummedSmallGENIESyst::~NumuSummedSmallGENIESyst().

const double calib::K = 0.307075

Definition at line 28 of file BetheBloch.cxx.

const int calib::kChunk = 2000

Definition at line 39 of file ADCShapeFit.cxx.

Referenced by calib::ADCShapeFitTable::ADCShapeFitTable(), and calib::ADCShapeFitTable::Table().

const unsigned int calib::kNumFineTimingADCPoints = 4

Definition at line 45 of file ADCShapeFit.cxx.

Referenced by ADCShapeFit(), GetExpectations(), and calib::ADCShapeFitTable::TNS().

const int calib::kOffsetStep = 16

Definition at line 53 of file ADCShapeFit.cxx.

Referenced by GetExpectations().

const double calib::kSamplesPerOffset = 1./(256*64)

Definition at line 54 of file ADCShapeFit.cxx.

Referenced by ADCShapeFit().

int calib::kStatsLimit = 1

Definition at line 58 of file AttenuationFit_plugin.cc.

Referenced by calib::AttenFit::endJob(), calib::AttenFit::GetBestHistogram(), calib::AttenuationFit::GetBestHistogram(), and calib::AttenuationFit::writeResults().

const double calib::kZeroOffsetSamples = -1

Definition at line 50 of file ADCShapeFit.cxx.

Referenced by ADCShapeFit(), and calib::ADCShapeFitTable::TNS().

const double calib::Me = 510.998910e3

Definition at line 25 of file BetheBloch.cxx.

const double calib::Mmu = 105.658367e6

Definition at line 26 of file BetheBloch.cxx.

Referenced by calib::BetheBlochAnalytic::BetaGamma().

const double calib::sCmPerNsec = 29.9792458

static

Definition at line 132 of file DCMTimingOffset_module.cc.

Referenced by caldp::TCTrack::CalculateFiberVelocity(), and caldp::TCTrack::CalculateMuonVelocity().

const double calib::sCmPerNsec = 29.9792458

static

Definition at line 141 of file TimingCalibration_module.cc.