NOvA: NOvASoft

val

Definition: febshutoff_auto.py:277

template<>

double util::GetValAs ( const stan::math::var & val )

inline

explicit specialization for double return value

Either no-op or convert stan::math::var to double. Exists so GetVal<T>(var) can be used with one signature inside a function templated over both stan::math::var & double. (see, e.g., CAFAna/Fit/StanFitter.cxx.)

Definition at line 25 of file StanUtils.h.

25 {return val.val();}

val

Definition: febshutoff_auto.py:277

template<>

stan::math::var util::GetValAs ( const stan::math::var & val )

inline

explicit specialization for stan::math::var return value

explicit specialization for double return value

Definition at line 29 of file StanUtils.h.

References febshutoff_auto::val.

29 { return val; }

val

Definition: febshutoff_auto.py:277

template<typename T >

std::enable_if<std::is_convertible<T, double>::value, T>::type util::GetValAs ( double val )

inline

Companion to GetValAs<>(stan::math::var) to provide ability to use GetValAs<double>(double) without implicitly converting to a stan::math::var.

Definition at line 36 of file StanUtils.h.

References febshutoff_auto::val.

36 { return val; }

Referenced by ana::KrigeKernel::AddPoint(), comi::CosmicMetrics::analyze(), mcchk::CosmicAna::analyze(), align::Alignment::analyze(), mcchk::LeptonAna::analyze(), earms::ElasticArmsValidate::analyze(), comi::NearlineAna::analyze(), mono::Monopole::analyze(), fuzz::FuzzyKValidate::analyze(), geo::AverageCellPathLength(), numue::NumuEAna::beginRun(), hough::Hough2P::BuildMap(), hough::MultiHough2P::BuildMap(), slid::ParticleIDAlg::CalcTrkHitPath(), geo::GeometryBase::CountCellsOnLine(), geo::GeometryBase::DEdge(), lem::DistanceMap::DistFunc(), me::TrkME::DistToTrk(), comi::Leana::DumpMuon(), lem::EventSummary::EventSummary(), sn::SupernovaAna::FillPlaneSeperations(), filter::Filter::FillTrackVariables(), comi::Leana::FindClosestMuon(), dt::DiscreteTracker::FindVertex(), dt::ViewMerger::FindVertex(), xsrec::MakeXSecCCPi0Inc::GetBPI(), evd::RecoBaseDrawer::GetClusterOutlinesConvexHull(), tdslicer::TDSlicer::GetDist(), nerd::NERDProng::HitToHitDistance(), me::MEFinder::HitToHitDistance(), geo::InitializePathTable(), ipow(), calib::PCHitsList::IsGoodTrack(), osc::EarthModel::LineProfile(), fuzz::FuzzyKMeanAlg::MakeAngles(), geo::GeometryBase::MassBetweenPoints(), fuzz::ViewMatchAlg::Matching(), nerd::ViewMatchAlg::Matching(), geo::GeometryBase::MaterialsBetweenPoints(), numue::NumuEAlg::NumuEAlg(), ana::KrigeKernel::operator()(), mcchk::ShowerAnaCheck::PointLineDistance(), nussand::FillNusSandbox::produce(), jmshower::JMTrackMerge::produce(), comi::Cana::produce(), photrans::PhotonTransport::produce(), jmshower::JMClusterMerge::produce(), hough::MultiHough2P::RefinePeak(), hough::Hough2P::RhoTheta(), hough::MultiHough2P::RhoTheta(), hough::MultiHoughT::Scrub(), earms::ElasticArmsHS::Scrub(), vdt::VertexDT::Scrub(), fuzz::FuzzyKVertex::Scrub(), trk::RLFit::SeedWeights(), photrans::ImprovedTransport::StepAlongHit(), dt::ViewMerger::TotalChargePerView(), htk::Track3D::Track3D(), mono::Track3D::Track3D(), and me::MEFinder::TrkMEDist().

val

Definition: febshutoff_auto.py:277

template<class T >

T util::ipow	(	T	x,
		unsigned int	n
	)

inline

More efficient exponentiation function than pow(x,n) for small n.

Definition at line 29 of file MathUtil.h.

References b, plot_validation_datamc::c, MECModelEnuComparisons::i, LinFit(), LinFitTS(), LinFitUnweighted(), m, pythag(), runNovaSAM::ret, sqr(), std::sqrt(), T, w, submit_syst::x, submit_syst::y, and test::z.

Referenced by ana::AtmConstraint::BiCubicInterp(), rsim::LegacyPulseShaper::CreateTrace(), and calib::ThresholdCorrMap::~ThresholdCorrMap().

   {
     T ret = 1; 
     if (n == 0) return ret;
     for(unsigned int i = 1; i <= n; ++i) ret *= x; 
     return ret;
   }

static bool util::IsInBeamWindow	(	const int	run,
		const double	time
	)

inlinestatic

Definition at line 100 of file NuMITimeParams.h.

Referenced by Exposure(), presel::CosmicVeto::produce(), and presel::CosmicCVNVeto::produce().

   {
     // In the bad period and in the shifted window
     if(run <= kLastBadTimingRun &&
        time > 1000*kBeamWindowShiftedMinMicroSec &&
        time < 1000*kBeamWindowShiftedMaxMicroSec)
       return true;
 
     // Or in any period and in the main window
     return (time > 1000*kBeamWindowMinMicroSec &&
             time < 1000*kBeamWindowMaxMicroSec);
   }

double util::LinFit	(	const std::vector< double > &	x,
		const std::vector< double > &	y,
		const std::vector< double > &	w,
		double &	m,
		double &	c
	)

Find the best-fit line to a collection of points in 2-D by minimizing the squared vertical distance from the points to the line.

Parameters

x	- input vector of x coordinates
y	- input vector of y coordinates
w	- input vector of weights for the points
m	- output gradient of the fit line
c	- output y-intercept of the fit line

Returns: The chi^2 value defined by chi^2 = sum_i[w_i d^2_i]

In the common case of unweighted data with Gaussian errors, you should set the points weights to 1/sigma^2 for each point.

Parameters

x	- input vector of x coordinates
y	- input vector of y coordinates
w	- input vector of weights for the points
m	- output gradient of the fit line
c	- output y-intercept of the fit line

Returns: The chi^2 value defined by chi^2 = sum_i[w_i d^2_i]

Definition at line 36 of file MathUtil.cxx.

References ana::assert(), chi2(), d, and MECModelEnuComparisons::i.

Referenced by upmuana::UpMuAnalysis::analyze(), lem::MakePID::AvgAndFit(), caldp::TCTrack::CalculateFiberVelocity(), caldp::TCTrack::CalculateMuonVelocity(), ipow(), geo::LinFit(), upmuana::LlrUpmu::LLR(), upmuana::UpMuAnalysis::LLR(), upmuana::UpMuRecoAna::LLR(), calib::AttenFit::lowessFit(), calib::AttenuationFit::lowessFit(), and pythag().

   {
     // Before going ahead, make sure we have sensible arrays
     assert(x.size() == y.size());
     assert(x.size() == w.size());
     assert(x.size() >= 2);
 
     // Accumulate the sums for the fit
     double Sw   = 0;
     double Swx  = 0;
     double Swy  = 0;
     double Swxy = 0;
     double Swy2 = 0;
     double Swx2 = 0;
     for(unsigned int i = 0; i < w.size(); ++i) {
       Sw   += w[i];
       Swx  += w[i]*x[i];
       Swy  += w[i]*y[i];
       Swx2 += w[i]*x[i]*x[i];
       Swxy += w[i]*x[i]*y[i];
       Swy2 += w[i]*y[i]*y[i];
     }
     const double d = Sw*Swx2 - Swx*Swx;
     m = (Sw*Swxy  - Swx*Swy)/d;
     c = (Swy*Swx2 - Swx*Swxy)/d;
 
     const double chi2 =
       Swy2 - 2.0*m*Swxy - 2.0*c*Swy + 2.0*m*c*Swx +
       c*c*Sw + m*m*Swx2;
 
     return chi2;
   }

void util::LinFitTS	(	const std::vector< double > &	x,
		const std::vector< double > &	y,
		const std::vector< double > &	w,
		double &	m,
		double &	b,
		int	wmode
	)

Best fit line to points using Theil-Sens median method.

An implementation of the Theil-Sens straight line estimator (http://en.wikipedia.org/wiki/Theil-Sen_estimator)

Theil-Sens sets the slope to be the median slope of data-point pairs and the intercept to the median value for data points computed using the median slope. Theil-Sens is more robust against the presence of noise.

The weighting method is controlled by "wmode":

wmode=0 : pairs of points will be assigned the same weights (that is, unweighted)
wmode=1 : pairs of points will be assigned weights equal to sqrt(w[i]*w[j])
wmode=2 : pairs of points will be assigned weights sqrt(w1*w1*d^2) where d is the distance between the points.

Parameters

x	- input vector of x coordinates
y	- input vector of y coordinates
w	- input vector of weights
m	- on return, the slope value
b	- on return, the intercept value
wmode	- weight mode

Definition at line 104 of file MathUtil.cxx.

References ana::assert(), dx, dy, find_median(), MECModelEnuComparisons::i, calib::j, sort_pair_by_first(), std::sqrt(), and w.

Referenced by bpfit::TrackBasis::FindAxis(), and ipow().

   {
     unsigned int i, j;
   
     //
     // Check that we have at least two points and that the x and y
     // vectors sizes match
     //
     unsigned int n = x.size();
     assert(n>1);
     assert(n==y.size());
     
     //
     // Reserve a vector of slope,weight pairs. Reserve the space we need
     // up front to improve efficiency
     //
     std::vector<std::pair<double,double> > mw;
     mw.reserve(n*(n-1)-1);
 
     //
     // Find the slopes of all pairs of points x,y. Depending on calling
     // options, weight the pairs by their separation distance.
     //
     double dx, dy, w;
     double wnorm = 0.0;
     for (i=0; (i+1)<n; ++i) {
       for (j=i+1; j<n; ++j) {
         dx = x[j]-x[i];
         dy = y[j]-y[i];
         if (dx!=0.0) {
           m = dy/dx;
           switch (wmode) {
           case 1:  w = sqrt(wt[i]*wt[j]);               break;
           case 2:  w = sqrt(wt[i]*wt[j]*(dx*dx+dy*dy)); break;
           default: w = 1.0;                             break;
           }
           if (w>0.0) {
             mw.push_back( std::pair<double,double>(m,w) );
             wnorm += w;
           }
         }
       }
     }
     std::sort(mw.begin(), mw.end(), sort_pair_by_first);
 
     //
     // Normalize weights to accumulate along the interval between 0 and 1
     //
     double sumw = 0.0;
     wnorm = 1.0/wnorm;
     for (i=0; i<mw.size(); ++i) {
       mw[i].second = wnorm*mw[i].second + sumw;
       sumw = mw[i].second;
     }
     
     m = find_median(mw);
     
     //
     // Build a vector or intercept, weight pairs
     //
     std::vector<std::pair<double,double> > bw;
     bw.reserve(n);
 
     //
     // Now compute the intercepts
     //
     wnorm = 0.0;
     w     = 1.0;
     for (i=0; i<n; ++i) {
       b = y[i] - m*x[i];
       bw.push_back( std::pair<double,double>(b,w) );
       wnorm += w;
     }
     std::sort(bw.begin(), bw.end(), sort_pair_by_first);
   
     //
     // Normalize the weights to accumulate along a range between 0 and
     // 1
     //
     sumw = 0.0;
     wnorm = 1.0/wnorm;
     for (i=0; i<bw.size(); ++i) {
       bw[i].second = wnorm*bw[i].second + sumw;
       sumw = bw[i].second;
     }
   
     b = find_median(bw); 
   }

void util::LinFitUnweighted	(	const std::vector< double > &	x,
		const std::vector< double > &	y,
		double &	m,
		double &	c
	)

Simplified version of LinFit.

All weights are assumed 1. In the absence of ability to weight, the returned chi-square doesn't mean much and is omitted.

Definition at line 8 of file MathUtil.cxx.

References ana::assert(), d, and MECModelEnuComparisons::i.

Referenced by novaddt::ClusterAna::analyze(), lem::MakePID::AvgAndFit(), novaddt::NuESelect::filter(), ipow(), and pythag().

   {
     // Before going ahead, make sure we have sensible arrays
     assert(x.size() == y.size());
     assert(x.size() >= 2);
 
     // Accumulate the sums for the fit
     double Sx  = 0;
     double Sy  = 0;
     double Sxy = 0;
     double Sy2 = 0;
     double Sx2 = 0;
     const unsigned int I = x.size();
     for(unsigned int i = 0; i < I; ++i) {
       Sx  += x[i];
       Sy  += y[i];
       Sx2 += x[i]*x[i];
       Sxy += x[i]*y[i];
       Sy2 += y[i]*y[i];
     }
     const double d = I*Sx2 - Sx*Sx;
     m = (I*Sxy  - Sx*Sy)/d;
     c = (Sy*Sx2 - Sx*Sxy)/d;
   }

def util.make_composition	(	name,
		fractions,
		compositions
	)

Definition at line 46 of file util.py.

References elem_frac_total().

Referenced by air.air_composition(), barite.barite_composition(), fdbedrock.fdbedrock_composition(), fdbermrock.fdbermrock_composition(), glue.glue_composition(), pvc.pvc_composition(), snow.snow_composition(), and soil.soil_composition().

 def make_composition(name, fractions, compositions):
   the_composition = { }
 
   for elem in elemlist:
     the_composition[elem] = elem_frac_total(elem, compositions, fractions)
 
   return the_composition

def util.print_composition ( composition )

Definition at line 55 of file util.py.

References elem_frac_total(), novadaq::HexUtils.format(), and print.

Referenced by printscintfd.scintfd_composition().

 def print_composition(composition):
   for elem in elemlist:
     if elem in composition and composition[elem] > 0:
       print("    <fraction n=\"{0:.7f}\" ref={1:<10s}/>"
         .format(composition[elem],
                 "\"{0:s}\"".format(atomic_names[elem]))),
       if elem == 'Cl':
          print("<!-- Cl-35: {0:.4f}, Cl-37: {1:.4f} -->".
            format(composition[elem]*cl35massfrac,
                   composition[elem]*cl37massfrac))
       else:
          print("")
   if printmore:
     for elem in elemlist:
       if elem in composition and composition[elem] > 0:
         print("const double {0:s}_{1:<2s} = {2:f};"
           .format(name, elem, elem_frac_total(elem, compositions, fractions)))

double util::pythag	(	double	x,
		double	y
	)

inline

2D Euclidean distance

Definition at line 29 of file MathUtil.h.

References sqr(), and std::sqrt().

   {
     return sqrt(sqr(x)+sqr(y));
   }

double util::pythag	(	double	x,
		double	y,
		double	z
	)

inline

3D Euclidean distance

Definition at line 35 of file MathUtil.h.

References plot_validation_datamc::c, LinFit(), LinFitUnweighted(), m, sqr(), std::sqrt(), w, submit_syst::x, and submit_syst::y.

   {
     return sqrt(sqr(x)+sqr(y)+sqr(z));
   }

void util::SaveObj	(	const TObject *	obj,
		const std::string &	filenameStub,
		const std::string &	dirName = `""`,
		const std::vector< std::string >	exts = `{".png", ".eps", ".root"}`,
		bool	silent = `false`
	)

inline

Definition at line 21 of file ROOTHelpers.h.

References dirName, galleryMaker::ext, runNovaSAM::gErrorIgnoreLevel, and string.

Referenced by drawSystsShiftingNDdata(), and EHadVisMECpairs().

                                                {".png", ".eps", ".root"},
              bool silent=false)
   {
       std::string fullFname = (dirName.size() ? (dirName + "/") : "") + filenameStub;
       auto prevOutputFlag = gErrorIgnoreLevel;
       if (silent)
           gErrorIgnoreLevel = kWarning;
       for (const auto & ext : exts)
           obj->SaveAs( (fullFname + ext).c_str() );
       if (silent)
           gErrorIgnoreLevel = prevOutputFlag;
   }

void util::SetVal	(	double &	target,
		const stan::math::var &	source
	)

inline

Replacement for operator=() making it clear that you're 'casting' across double-stan::math::var boundary.

Definition at line 40 of file StanUtils.h.

40 {target = source.val();}

const XML_Char * target

Definition: expat.h:268

const char * source

Definition: lz4.h:436

void util::SetVal	(	stan::math::var &	target,
		const double &	source
	)

inline

Definition at line 41 of file StanUtils.h.

41 {target = source;}

const XML_Char * target

Definition: expat.h:268

const char * source

Definition: lz4.h:436

void util::SetVal	(	stan::math::var &	target,
		const stan::math::var &	source
	)

inline

Definition at line 42 of file StanUtils.h.

42 {target = source;}

const XML_Char * target

Definition: expat.h:268

const char * source

Definition: lz4.h:436

void util::SetVal	(	double &	target,
		const double &	source
	)

inline

Definition at line 45 of file StanUtils.h.

45 {target = source;}

const XML_Char * target

Definition: expat.h:268