util Namespace Reference

Filter events based on their run/event numbers. More...

Classes
class	CopyCellHits
	A module to copy hits from selected clusers into a vector of cell hits. More...
class	EventFilterNoSlice
class	FakeSpillData
class	HashFunctions
class	HasStandardRecord
class	HoughCalc
class	MergeSubruns
class	NonEmptyCluster
	A module to copy hits from selected clusers into a vector of cell hits. More...
class	NTree
class	RemoveBeamSpills
	Reject triggers that are too close to beam spills. More...
class	RemoveBeamSpillsPrecise
class	RemoveTBSpills
	Reject triggers that are too close to beam spills. More...
class	RewriteSpillData
	A module to store a geometry in a file. More...
class	RunEventFilter
class	StoreGDML
	A module to store a geometry in a file. More...
class	TimeFilter
class	TruthExpand
class	WriteHornCurrentCosmic
	A module to store a geometry in a file. More...

Functions
def	tot_weight (compos)
def	tot_fractions (fractions)
def	elem_frac (compos, elem)
def	elem_frac_total (elem, compositions, fractions)
def	zovera (elem)
def	zoveramaterial (compos)
def	make_composition (name, fractions, compositions)
def	print_composition (composition)
template<class T >
std::unique_ptr< std::vector< T > >	GetHits (const std::vector< rb::Cluster > &clusts)
std::string	EnvExpansion (const std::string &inString)
	Function to expand environment variables. More...
static bool	sort_pair_by_first (const std::pair< double, double > &a, const std::pair< double, double > &b)
static double	find_median (const std::vector< std::pair< double, double > > &a)
static bool	IsInBeamWindow (const int run, const double time)
void	SaveObj (const TObject *obj, const std::string &filenameStub, const std::string &dirName="", const std::vector< std::string > exts={".png",".eps",".root"}, bool silent=false)
template<typename T >
T	GetValAs (const stan::math::var &val)
	explicit specialization for double return value More...
template<>
double	GetValAs (const stan::math::var &val)
	explicit specialization for double return value More...
template<>
stan::math::var	GetValAs (const stan::math::var &val)
	explicit specialization for stan::math::var return value More...
template<typename T >
std::enable_if< std::is_convertible< T, double >::value, T >::type	GetValAs (double val)
void	SetVal (double &target, const stan::math::var &source)
	Replacement for operator=() making it clear that you're 'casting' across double-stan::math::var boundary. More...
void	SetVal (stan::math::var &target, const double &source)
void	SetVal (stan::math::var &target, const stan::math::var &source)
void	SetVal (double &target, const double &source)
double	frac (double x)
	Fractional part. More...
Create and query associations
see https://cdcvs.fnal.gov/redmine/projects/art/wiki/Inter-Product_References for information about using art::Assns
template<class T , class U >
static bool	CreateAssn (art::EDProducer const &prod, art::Event &evt, std::vector< T > &a, art::Ptr< U > b, art::Assns< T, U > &assn, size_t indx=UINT_MAX, std::string const &instance=std::string())
	Create a 1 to 1 association between a new product and one already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDFilter const &filt, art::Event &evt, std::vector< T > &a, art::Ptr< U > b, art::Assns< T, U > &assn, size_t indx=UINT_MAX, std::string const &instance=std::string())
template<class T , class U >
static bool	CreateAssn (art::EDProducer const &prod, art::Event &evt, std::vector< T > &a, art::Ptr< U > b, art::Assns< T, U > &assn, size_t begin_indx, size_t end_indx, std::string const &instance=std::string())
	Create a 1 to 1 association between each of a series of new products and one already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDProducer const &prod, art::Event &evt, art::Ptr< T > &a, art::Ptr< U > b, art::Assns< T, U > &assn)
	Create a 1 to 1 association between two products already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDProducer const &prod, art::Event &evt, std::vector< T > &a, art::PtrVector< U > b, art::Assns< T, U > &assn, size_t indx=UINT_MAX, std::string const &instance=std::string())
	Create a 1 to many association between a new product and a PtrVector already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDProducer const &prod, art::Event &evt, art::Ptr< T > &a, std::vector< art::Ptr< U > > b, art::Assns< T, U > &assn)
	Create a 1 to many association between products already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDProducer const &prod, art::Event &evt, std::vector< T > &a, std::vector< art::Ptr< U > > b, art::Assns< T, U > &assn, size_t indx=UINT_MAX, std::string const &instance=std::string())
	Create a 1 to many association between a new product and a vector of Ptrs already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDProducer const &prod, art::Event &evt, std::vector< T > &a, std::vector< U > &b, art::Assns< T, U > &assn, size_t startU, size_t endU, size_t indx=UINT_MAX, std::string const &instancea=std::string(), std::string const &instanceb=std::string())
	Create a 1 to many association between new products. More...
template<class T , class U >
static bool	CreateAssn (art::EDFilter const &filt, art::Event &evt, std::vector< T > &a, std::vector< U > &b, art::Assns< T, U > &assn, size_t startU, size_t endU, size_t indx=UINT_MAX, std::string const &instancea=std::string(), std::string const &instanceb=std::string())
template<class T , class U >
static std::vector< const U * >	FindUNotAssociatedToT (art::Handle< U > b, art::Event const &evt, std::string const &label)
	Return all objects of type U that are not associated to objects of type T. More...
template<class T , class U >
static std::vector< art::Ptr< U > >	FindUNotAssociatedToTP (art::Handle< U > b, art::Event const &evt, std::string const &label)
	Return all objects of type U that are not associated to objects of type T. More...
template<class T , class U >
static bool	CreateAssn (art::EDProducer const &prod, art::Event &evt, std::vector< T > &a, art::Ptr< U > b, art::Assns< T, U > &assn, size_t indx=UINT_MAX, std::string const &instance=std::string())
	Create a 1 to 1 association between a new product and one already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDProducer const &prod, art::Event &evt, std::vector< T > &a, art::Ptr< U > b, art::Assns< T, U > &assn, size_t begin_indx, size_t end_indx, std::string const &instance=std::string())
	Create a 1 to 1 association between each of a series of new products and one already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDProducer const &prod, art::Event &evt, art::Ptr< T > &a, art::Ptr< U > b, art::Assns< T, U > &assn)
	Create a 1 to 1 association between two products already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDProducer const &prod, art::Event &evt, std::vector< T > &a, art::PtrVector< U > b, art::Assns< T, U > &assn, size_t indx=UINT_MAX, std::string const &instance=std::string())
	Create a 1 to many association between a new product and a PtrVector already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDProducer const &prod, art::Event &evt, art::Ptr< T > &a, std::vector< art::Ptr< U > > b, art::Assns< T, U > &assn)
	Create a 1 to many association between products already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDProducer const &prod, art::Event &evt, std::vector< T > &a, std::vector< art::Ptr< U > > b, art::Assns< T, U > &assn, size_t indx=UINT_MAX, std::string const &instance=std::string())
	Create a 1 to many association between a new product and a vector of Ptrs already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDProducer const &prod, art::Event &evt, std::vector< T > &a, std::vector< U > &b, art::Assns< T, U > &assn, size_t startU, size_t endU, size_t indx=UINT_MAX, std::string const &instancea=std::string(), std::string const &instanceb=std::string())
	Create a 1 to many association between new products. More...
template<class T , class U >
static bool	CreateAssn (art::EDProducer const &prod, art::Event &evt, art::Assns< T, U > &assn, std::vector< T > &a, std::vector< U > &b, size_t indxb=UINT_MAX, size_t indxa=UINT_MAX, std::string const &instancea=std::string(), std::string const &instanceb=std::string())
	Create a 1 to 1 between new products. More...
template<class T , class U >
static std::vector< const U * >	FindUNotAssociatedToT (art::Handle< U > b, art::Event const &evt, std::string const &label)
	Return all objects of type U that are not associated to objects of type T. More...
template<class T , class U >
static std::vector< art::Ptr< U > >	FindUNotAssociatedToTP (art::Handle< U > b, art::Event const &evt, std::string const &label)
	Return all objects of type U that are not associated to objects of type T. More...
template<class T , class U >
static bool	CreateAssn (art::EDFilter const &prod, art::Event &evt, std::vector< T > &a, art::Ptr< U > b, art::Assns< T, U > &assn, size_t indx=UINT_MAX, std::string const &instance=std::string())
	Create a 1 to 1 association between a new product and one already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDFilter const &prod, art::Event &evt, std::vector< T > &a, art::Ptr< U > b, art::Assns< T, U > &assn, size_t begin_indx, size_t end_indx, std::string const &instance=std::string())
	Create a 1 to 1 association between each of a series of new products and one already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDFilter const &prod, art::Event &evt, art::Ptr< T > &a, art::Ptr< U > b, art::Assns< T, U > &assn)
	Create a 1 to 1 association between two products already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDFilter const &prod, art::Event &evt, std::vector< T > &a, art::PtrVector< U > b, art::Assns< T, U > &assn, size_t indx=UINT_MAX, std::string const &instance=std::string())
	Create a 1 to many association between a new product and a PtrVector already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDFilter const &prod, art::Event &evt, art::Ptr< T > &a, std::vector< art::Ptr< U > > b, art::Assns< T, U > &assn)
	Create a 1 to many association between products already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDFilter const &prod, art::Event &evt, std::vector< T > &a, std::vector< art::Ptr< U > > b, art::Assns< T, U > &assn, size_t indx=UINT_MAX, std::string const &instance=std::string())
	Create a 1 to many association between a new product and a vector of Ptrs already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDFilter const &prod, art::Event &evt, std::vector< T > &a, std::vector< U > &b, art::Assns< T, U > &assn, size_t startU, size_t endU, size_t indx=UINT_MAX, std::string const &instancea=std::string(), std::string const &instanceb=std::string())
	Create a 1 to many association between new products. More...
template<class T , class U >
static bool	CreateAssn (art::EDFilter const &prod, art::Event &evt, art::Assns< T, U > &assn, std::vector< T > &a, std::vector< U > &b, size_t indxb=UINT_MAX, size_t indxa=UINT_MAX, std::string const &instancea=std::string(), std::string const &instanceb=std::string())
	Create a 1 to 1 between new products. More...
Simple mathematical functions
void	LinFitUnweighted (const std::vector< double > &x, const std::vector< double > &y, double &m, double &c)
	Simplified version of LinFit. More...
double	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. More...
template<class T >
T	sqr (T x)
	More efficient square function than pow(x,2) More...
template<class T >
T	cube (T x)
	More efficient cube function than pow(x,3) More...
double	pythag (double x, double y)
	2D Euclidean distance More...
double	pythag (double x, double y, double z)
	3D Euclidean distance More...
void	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. More...
template<class T >
T	ipow (T x, unsigned int n)
	More efficient exponentiation function than pow(x,n) for small n. More...

Variables
list	elemlist
bool	printmore = False
const int	kBeamWindowPaddingMicroSec = 9
const int	kBeamWindowMinMicroSec = 217
const int	kBeamWindowMaxMicroSec = 229
const int	kMinTimingSidebandBeforeMicroSec = 25
const int	kMaxTimingSidebandBeforeMicroSec = kBeamWindowMinMicroSec - kBeamWindowPaddingMicroSec
const int	kMinTimingSidebandAfterMicroSec = kBeamWindowMaxMicroSec + kBeamWindowPaddingMicroSec
const int	kMaxTimingSidebandAfterMicroSec = 475
const int	kPeakShiftMicroSec = +64
const int	kBeamWindowShiftedMinMicroSec = kBeamWindowMinMicroSec + kPeakShiftMicroSec
const int	kBeamWindowShiftedMaxMicroSec = kBeamWindowMaxMicroSec + kPeakShiftMicroSec
const int	kMaxTimingSidebandBeforeShiftedWindowMicroSec = kBeamWindowShiftedMinMicroSec - kBeamWindowPaddingMicroSec
const int	kMinTimingSidebandAfterShiftedWindowMicroSec = kBeamWindowShiftedMaxMicroSec + kBeamWindowPaddingMicroSec
const int	kLastBadTimingRun = 17945
const int	kBeamWindowMicroSec = kBeamWindowMaxMicroSec - kBeamWindowMinMicroSec
	How long is the beam window? More...
const int	kTimingSidebandMicroSec
const int	kBeamWindowBadPeriodMicroSec
	Two windows to consider here. More...
const int	kTimingSidebandBadPeriodMicroSec
	Two beam windows to cut out here. More...

Utilities acting on RawDigits
Used by Cana
typedef std::pair< unsigned int, unsigned int >	RawSlice
void	TimeSort (std::vector< art::Ptr< rawdata::RawDigit > > &d)
	Arrange the list of raw hits in time order (early to late) More...
void	CountXY (const std::vector< art::Ptr< rawdata::RawDigit > > &d, unsigned int i1, unsigned int i2, unsigned int *nx, unsigned int *ny)
	Count the number of digits in each detector view. More...
void	EventBox (const std::vector< art::Ptr< rawdata::RawDigit > > &d, unsigned int i1, unsigned int i2, unsigned int *plane1x, unsigned int *plane2x, unsigned int *cell1x, unsigned int *cell2x, unsigned int *plane1y, unsigned int *plane2y, unsigned int *cell1y, unsigned int *cell2y)
	Find boxes in plane/cell units that contain all the hits. More...
void	TimeSlice (const std::vector< art::Ptr< rawdata::RawDigit > > &d, unsigned int dt_tdc, unsigned int nhit, unsigned int nhitx, unsigned int nhity, std::vector< RawSlice > &slice)
	Find windows in time that have significant activity in the detector. More...
unsigned int	FilterFEBFlash (std::vector< art::Ptr< rawdata::RawDigit > > &rd, int adc_sat=3400, int dt_tdc=1280)
	Filter hits that are "FEB flash" candidates; that is, they occur within a specified time of an FEB hit in saturation. More...

Detailed Description

Filter events based on their run/event numbers.

Create a dummy spilldata product in cosmic files to set the isRHC field for downstream reco.

Store a geometry in a file.

Rewrite the SpillData object in an MC file to set the isRHC field.

Reject triggers that are too close to beam spills.

This is a simple tree class.

A module to filter events which have a collection of empty clusters.

Hough Calculation service.

utility services

Concatenate subrun files from same run.

Generate unique hashes for reco products.

Fake the SpillData object in an MC file to set the isRHC field.

A module to copy hits from selected clusers into a vector of cell hits.

Remove all events that occur too close to 4.2s Test Beam spill.

Filter events based on their run/subrun and event (trigger) time.

Author

messi.nosp@m.er@i.nosp@m.ndian.nosp@m.a.ed.nosp@m.u

Date

Author

lacke.nosp@m.y32@.nosp@m.fnal..nosp@m.gov

Date

Author

Teresa Lackey - lacke.nosp@m.y32@.nosp@m.fnal..nosp@m.gov

ednin.nosp@m.er@f.nosp@m.nal.g.nosp@m.ov

Date

Author

bckho.nosp@m.use@.nosp@m.fnal..nosp@m.gov

Date

Author

Justin Vasel justi.nosp@m.n.va.nosp@m.sel@g.nosp@m.mail.nosp@m..com

Date

December 2018

Author

nowak.nosp@m.@phy.nosp@m.sics..nosp@m.umn..nosp@m.edu

Date

Author

Alexandre Sousa - asous.nosp@m.a@ph.nosp@m.ysics.nosp@m..har.nosp@m.vard..nosp@m.edu

Date

Author

ahimm.nosp@m.el@f.nosp@m.nal.g.nosp@m.ov

Date

Author

jpale.nosp@m.y@an.nosp@m.l.gov

Date

Author

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

Typedef Documentation

typedef std::pair<unsigned int, unsigned int> util::RawSlice

A raw slice is just two indices: the index of the first hit in the slice, and the index of the last hit in the slice, inclusive.

Definition at line 23 of file RawUtil.h.

Function Documentation

void util::CountXY	(	const std::vector< art::Ptr< rawdata::RawDigit > > &	d,
		unsigned int	i1,
		unsigned int	i2,
		unsigned int *	nx,
		unsigned int *	ny
	)

Count the number of digits in each detector view.

Parameters

d	: The complete list of raw digits to be considered
i1	: Index of the first digit to be considered
i2	: Index of the last digit to be considered (inclusive)
nx	: On output, the number of hits in the x view
ny	: On output, the number of hits in the y view

Definition at line 38 of file RawUtil.cxx.

References visualisationForPaperMasterPlot::cmap, d, geom(), cmap::dataprov::CMap::GetPlane(), MECModelEnuComparisons::i, geo::kX, geo::kY, geo::GeometryBase::Plane(), registry_explorer::v, and geo::PlaneGeo::View().

Referenced by comi::Leana::analyze(), comi::Cana::produce(), and TimeSlice().

{
  art::ServiceHandle<cmap::CMap>    cmap;
  art::ServiceHandle<geo::Geometry> geom;

  *nx = 0;
  *ny = 0;
  unsigned int i;
  for (i=i1; i<=i2; ++i) {
    unsigned int p = cmap->GetPlane(d[i].get());
    geo::View_t  v = geom->Plane(p)->View();
    if      (v==geo::kX) ++(*nx);
    else if (v==geo::kY) ++(*ny);
  }
}

template<class T , class U >

static bool util::CreateAssn ( art::EDProducer const &  prod, art::Event &  evt, std::vector< T > &  a, art::Ptr< U >  b, art::Assns< T, U > &  assn, size_t  indx = UINT_MAX, std::string const &  instance = std::string()  )

static

Create a 1 to 1 association between a new product and one already in the event.

Parameters

a	The collection about to be added to the event
b	The product already in the event
indx	Which element of a to associate. By default the last one.
instance	instance label for product, defaulted to be an empty string

template<class T , class U >

static bool util::CreateAssn ( art::EDProducer const &  prod, art::Event &  evt, std::vector< T > &  a, art::Ptr< U >  b, art::Assns< T, U > &  assn, size_t  indx = UINT_MAX, std::string const &  instance = std::string()  )

static

Create a 1 to 1 association between a new product and one already in the event.

Parameters

a	The collection about to be added to the event
b	The product already in the event
indx	Which element of a to associate. By default the last one.
instance	instance label for product, defaulted to be an empty string

Referenced by skim::NueSkimmer::CopyMichelSlice(), skim::NueSkimmer::CopyMichelTrack(), skim::SkimmingUtils::CopyProductAndSliceAssn(), skim::NueSkimmer::CopyProngCVN(), skim::SkimmingUtils::CopyProngs(), skim::NueSkimmer::CopyShowerLID(), skim::NumuSkimmer::CopyShowerLID(), skim::NueSkimmer::CopyShowerPngAssn(), skim::SkimmingUtils::CopyShowers(), skim::NumuCCpiSkimmer::CopyTrackAssn(), skim::NumuSkimmer::CopyTrackAssn(), skim::SkimmingUtils::CopyTracks(), skim::SkimmingUtils::CopyVertex(), LSTME::FillLSTME::fillEnergies(), SliceLID::FillSliceLID::fillSliceLIDPreds(), novaddt::Clusterer::filter(), calib::RockMuonStopperSelection::filter(), calib::StopperSelection::filter(), novaddt::TriCellTrigger::filter(), novaddt::DDTTrackMerge::filter(), novaddt::UpMuTestTrigger::filter(), novaddt::Merge2DTracks::filter(), trk::TrkAssn::produce(), qeef::QeFinder::produce(), hough::HoughT::produce(), tf::TimingFit::produce(), cheat::ClusterCheater::produce(), cheat::ProngCheater::produce(), cheat::ShowerCheater::produce(), cheat::TrueEnergy::produce(), recodemo::RecoDemo::produce(), hv::HoughVertex::produce(), cheat::TrackCheater::produce(), trk::KalmanTrack::produce(), nuesand::FillNueSandbox::produce(), lem::MergeMatches::produce(), lem::UnTranspose::produce(), beamlinereco::TimeOfFlightReco::produce(), numue::TrackOverlapECalc::produce(), wsnumu::WSNumu::produce(), MergeCollections::MergeCollections::produce(), MergeG4Collections::MergeG4Collections::produce(), presel::RockPresel::produce(), regcvntf::RegCVNTF::produce(), lem::LEMSummarizer::produce(), trk::KalmanTrackMerge::produce(), nussand::FillNusSandbox::produce(), novaddt::TrackFit::produce(), presel::CosmicVeto::produce(), slid::Recluster::produce(), trackinfo::TrackInfo::produce(), numusand::FillSandbox::produce(), presel::NuePresel::produce(), hough::MultiHoughT::produce(), lem::Preselection::produce(), cvn::CVNCosmicMapper::produce(), calib::FiberCalibration::produce(), cvnprongtf::CVNProngTF::produce(), slid::SliceLIDBuilder::produce(), cvneventtf::CVNEventTF::produce(), cosrej::CosRej::produce(), beamlinereco::CkovCounterReco::produce(), MergeGenCollections::MergeGenCollections::produce(), g4n::TruthSlim::produce(), trk::CosmicTrack::produce(), lem::MakeMatches::produce(), numue::NumuEnergy::produce(), dt::ViewMerger::produce(), calib::TimingCalibration::produce(), beamlinereco::WCTrackReco::produce(), earms::ElasticArmsHS::produce(), beamlinereco::LEHitReco::produce(), dt::DiscreteTracker::produce(), calib::PCHitsList::produce(), evgen::GENIERockGen::produce(), beamlinereco::CFDHitReco::produce(), lem::FindLEMMatches::produce(), vdt::VertexDT::produce(), rwgt::MakeGENIEReweightTable::produce(), cvn::CVNMapper::produce(), ncpi0::MakeNCPi0BkgRej::produce(), lem::MakePID::produce(), murem::MRE::produce(), slid::LIDBuilder::produce(), lem::LEM::produce(), evgen::GENIEGen::produce(), jmshower::NueSel::produce(), rvp::RecVarPID::produce(), dif::DiFShowerFinder::produce(), cvntf::CVNProngEvaluatorTF::produce(), crvtx::CosmicRayVertex::produce(), slid::SPIDBuilder::produce(), xnue::XnuePID::produce(), cvn::RegCVNMapper::produce(), g4n::G4Gen::produce(), jmshower::NueSelLID::produce(), fxwgt::FluxWeightCalculator::produce(), ncid::MakeNCCosRej::produce(), bpfit::BPFEnergyEstimator::produce(), remid::RecoMuon::produce(), bpfit::BPFEnergyEstimatorOnly::produce(), xsrec::MakeXSecCCPi0Inc::produce(), bpfit::BPFPIdMaker::produce(), lem::LEMClient::produce(), cvn::CVNAddTrainingData::produce(), cosrej::MakeNueCosRej::produce(), upmuana::UpMuProb::produce(), ncid::NCNNKeras::produce(), murem::MuonRemove::produce(), murem::FindMREParent::produce(), jmshower::RecoJMShower::produce(), murem::FindParent::produce(), fuzz::FuzzyKVertex::produce(), nerd::NERDProng::produce(), gibuu::GiBUURegen::produce(), caf::CAFMaker::produce(), me::MEFinder::produce(), bpfit::BreakPoint::produce(), jmshower::RecoJMShower::RecoShowers(), and skim::SkimmingUtils::SliceMCTruthAssociation().

template<class T , class U >

static bool util::CreateAssn ( art::EDFilter const &  filt, art::Event &  evt, std::vector< T > &  a, art::Ptr< U >  b, art::Assns< T, U > &  assn, size_t  indx = UINT_MAX, std::string const &  instance = std::string()  )

static

template<class T , class U >

static bool util::CreateAssn ( art::EDProducer const &  prod, art::Event &  evt, std::vector< T > &  a, art::Ptr< U >  b, art::Assns< T, U > &  assn, size_t  begin_indx, size_t  end_indx, std::string const &  instance = std::string()  )

static

Create a 1 to 1 association between each of a series of new products and one already in the event.

Parameters

a	The collection about to be added to the event
b	The product already in the event
begin_indx	Which element of a to associate first.
end_indx	One more than the index of the last element to associate
instance	instance label for product, defaulted to be an empty string

template<class T , class U >

static bool util::CreateAssn ( art::EDProducer const &  prod, art::Event &  evt, std::vector< T > &  a, art::Ptr< U >  b, art::Assns< T, U > &  assn, size_t  begin_indx, size_t  end_indx, std::string const &  instance = std::string()  )

static

Create a 1 to 1 association between each of a series of new products and one already in the event.

Parameters

a	The collection about to be added to the event
b	The product already in the event
begin_indx	Which element of a to associate first.
end_indx	One more than the index of the last element to associate
instance	instance label for product, defaulted to be an empty string

template<class T , class U >

static bool util::CreateAssn ( art::EDProducer const &  prod, art::Event &  evt, art::Ptr< T > &  a, art::Ptr< U >  b, art::Assns< T, U > &  assn  )

static

Create a 1 to 1 association between two products already in the event.

Parameters

a	A product already in the event
b	Another product already in the event

template<class T , class U >

static bool util::CreateAssn ( art::EDProducer const &  prod, art::Event &  evt, art::Ptr< T > &  a, art::Ptr< U >  b, art::Assns< T, U > &  assn  )

static

Create a 1 to 1 association between two products already in the event.

Parameters

a	A product already in the event
b	Another product already in the event

template<class T , class U >

static bool util::CreateAssn ( art::EDProducer const &  prod, art::Event &  evt, std::vector< T > &  a, art::PtrVector< U >  b, art::Assns< T, U > &  assn, size_t  indx = UINT_MAX, std::string const &  instance = std::string()  )

static

Create a 1 to many association between a new product and a PtrVector already in the event.

Parameters

a	The collection about to be added to the event
b	The products already in the event
indx	Which element of a to associate. By default the last one.
instance	instance label for product, defaulted to be an empty string

template<class T , class U >

static bool util::CreateAssn ( art::EDProducer const &  prod, art::Event &  evt, std::vector< T > &  a, art::PtrVector< U >  b, art::Assns< T, U > &  assn, size_t  indx = UINT_MAX, std::string const &  instance = std::string()  )

static

Create a 1 to many association between a new product and a PtrVector already in the event.

Parameters

a	The collection about to be added to the event
b	The products already in the event
indx	Which element of a to associate. By default the last one.
instance	instance label for product, defaulted to be an empty string

template<class T , class U >

static bool util::CreateAssn ( art::EDProducer const &  prod, art::Event &  evt, art::Ptr< T > &  a, std::vector< art::Ptr< U > >  b, art::Assns< T, U > &  assn  )

static

Create a 1 to many association between products already in the event.

Parameters

a	A product already in the event
b	A vector of products already in the event (the many)

template<class T , class U >

static bool util::CreateAssn ( art::EDProducer const &  prod, art::Event &  evt, art::Ptr< T > &  a, std::vector< art::Ptr< U > >  b, art::Assns< T, U > &  assn  )

static

Create a 1 to many association between products already in the event.

Parameters

a	A product already in the event
b	A vector of products already in the event (the many)

template<class T , class U >

static bool util::CreateAssn ( art::EDProducer const &  prod, art::Event &  evt, std::vector< T > &  a, std::vector< art::Ptr< U > >  b, art::Assns< T, U > &  assn, size_t  indx = UINT_MAX, std::string const &  instance = std::string()  )

static

Create a 1 to many association between a new product and a vector of Ptrs already in the event.

Parameters

a	The collection about to be added to the event
b	The products already in the event
indx	Which element of a to associate. By default the last one.
instance	instance label for product, defaulted to be an empty string

template<class T , class U >

static bool util::CreateAssn ( art::EDProducer const &  prod, art::Event &  evt, std::vector< T > &  a, std::vector< art::Ptr< U > >  b, art::Assns< T, U > &  assn, size_t  indx = UINT_MAX, std::string const &  instance = std::string()  )

static

Create a 1 to many association between a new product and a vector of Ptrs already in the event.

Parameters

a	The collection about to be added to the event
b	The products already in the event
indx	Which element of a to associate. By default the last one.
instance	instance label for product, defaulted to be an empty string

template<class T , class U >

static bool util::CreateAssn ( art::EDProducer const &  prod, art::Event &  evt, std::vector< T > &  a, std::vector< U > &  b, art::Assns< T, U > &  assn, size_t  startU, size_t  endU, size_t  indx = UINT_MAX, std::string const &  instancea = std::string(), std::string const &  instanceb = std::string()  )

static

Create a 1 to many association between new products.

Parameters

a	A collection about to be added to the event
b	Another collection about to be added to the event
startU	The first element of b to associate
endU	The last element of b to associate +1 (like STL begin() and end())
indx	Which element of a to associate. By default the last one.
instancea	instance label for product a, defaulted to be an empty string
instanceb	instance label for product b, defaulted to be an empty string

template<class T , class U >

static bool util::CreateAssn ( art::EDProducer const &  prod, art::Event &  evt, std::vector< T > &  a, std::vector< U > &  b, art::Assns< T, U > &  assn, size_t  startU, size_t  endU, size_t  indx = UINT_MAX, std::string const &  instancea = std::string(), std::string const &  instanceb = std::string()  )

static

Create a 1 to many association between new products.

Parameters

a	A collection about to be added to the event
b	Another collection about to be added to the event
startU	The first element of b to associate
endU	The last element of b to associate +1 (like STL begin() and end())
indx	Which element of a to associate. By default the last one.
instancea	instance label for product a, defaulted to be an empty string
instanceb	instance label for product b, defaulted to be an empty string

template<class T , class U >

static bool util::CreateAssn ( art::EDProducer const &  prod, art::Event &  evt, art::Assns< T, U > &  assn, std::vector< T > &  a, std::vector< U > &  b, size_t  indxb = UINT_MAX, size_t  indxa = UINT_MAX, std::string const &  instancea = std::string(), std::string const &  instanceb = std::string()  )

static

Create a 1 to 1 between new products.

Parameters

a	A collection about to be added to the event
b	Another collection about to be added to the event
indxb	Which element of b to associate. By default the last one.
indxa	Which element of a to associate. By default the last one.
instancea	instance label for product a, defaulted to be an empty string
instanceb	instance label for product b, defaulted to be an empty string

template<class T , class U >

static bool util::CreateAssn ( art::EDFilter const &  filt, art::Event &  evt, std::vector< T > &  a, std::vector< U > &  b, art::Assns< T, U > &  assn, size_t  startU, size_t  endU, size_t  indx = UINT_MAX, std::string const &  instancea = std::string(), std::string const &  instanceb = std::string()  )

static

template<class T , class U >

static bool util::CreateAssn ( art::EDFilter const &  prod, art::Event &  evt, std::vector< T > &  a, art::Ptr< U >  b, art::Assns< T, U > &  assn, size_t  indx = UINT_MAX, std::string const &  instance = std::string()  )

static

Create a 1 to 1 association between a new product and one already in the event.

Parameters

a	The collection about to be added to the event
b	The product already in the event
indx	Which element of a to associate. By default the last one.
instance	instance label for product, defaulted to be an empty string

template<class T , class U >

static bool util::CreateAssn ( art::EDFilter const &  prod, art::Event &  evt, std::vector< T > &  a, art::Ptr< U >  b, art::Assns< T, U > &  assn, size_t  begin_indx, size_t  end_indx, std::string const &  instance = std::string()  )

static

Create a 1 to 1 association between each of a series of new products and one already in the event.

Parameters

a	The collection about to be added to the event
b	The product already in the event
begin_indx	Which element of a to associate first.
end_indx	One more than the index of the last element to associate
instance	instance label for product, defaulted to be an empty string

template<class T , class U >

static bool util::CreateAssn ( art::EDFilter const &  prod, art::Event &  evt, art::Ptr< T > &  a, art::Ptr< U >  b, art::Assns< T, U > &  assn  )

static

Create a 1 to 1 association between two products already in the event.

Parameters

a	A product already in the event
b	Another product already in the event

template<class T , class U >

static bool util::CreateAssn ( art::EDFilter const &  prod, art::Event &  evt, std::vector< T > &  a, art::PtrVector< U >  b, art::Assns< T, U > &  assn, size_t  indx = UINT_MAX, std::string const &  instance = std::string()  )

static

Create a 1 to many association between a new product and a PtrVector already in the event.

Parameters

a	The collection about to be added to the event
b	The products already in the event
indx	Which element of a to associate. By default the last one.
instance	instance label for product, defaulted to be an empty string

template<class T , class U >

static bool util::CreateAssn ( art::EDFilter const &  prod, art::Event &  evt, art::Ptr< T > &  a, std::vector< art::Ptr< U > >  b, art::Assns< T, U > &  assn  )

static

Create a 1 to many association between products already in the event.

Parameters

a	A product already in the event
b	A vector of products already in the event (the many)

template<class T , class U >

static bool util::CreateAssn ( art::EDFilter const &  prod, art::Event &  evt, std::vector< T > &  a, std::vector< art::Ptr< U > >  b, art::Assns< T, U > &  assn, size_t  indx = UINT_MAX, std::string const &  instance = std::string()  )

static

Create a 1 to many association between a new product and a vector of Ptrs already in the event.

Parameters

a	The collection about to be added to the event
b	The products already in the event
indx	Which element of a to associate. By default the last one.
instance	instance label for product, defaulted to be an empty string

template<class T , class U >

static bool util::CreateAssn ( art::EDFilter const &  prod, art::Event &  evt, std::vector< T > &  a, std::vector< U > &  b, art::Assns< T, U > &  assn, size_t  startU, size_t  endU, size_t  indx = UINT_MAX, std::string const &  instancea = std::string(), std::string const &  instanceb = std::string()  )

static

Create a 1 to many association between new products.

Parameters

a	A collection about to be added to the event
b	Another collection about to be added to the event
startU	The first element of b to associate
endU	The last element of b to associate +1 (like STL begin() and end())
indx	Which element of a to associate. By default the last one.
instancea	instance label for product a, defaulted to be an empty string
instanceb	instance label for product b, defaulted to be an empty string

template<class T , class U >

static bool util::CreateAssn ( art::EDFilter const &  prod, art::Event &  evt, art::Assns< T, U > &  assn, std::vector< T > &  a, std::vector< U > &  b, size_t  indxb = UINT_MAX, size_t  indxa = UINT_MAX, std::string const &  instancea = std::string(), std::string const &  instanceb = std::string()  )

static

Create a 1 to 1 between new products.

Parameters

a	A collection about to be added to the event
b	Another collection about to be added to the event
indxb	Which element of b to associate. By default the last one.
indxa	Which element of a to associate. By default the last one.
instancea	instance label for product a, defaulted to be an empty string
instanceb	instance label for product b, defaulted to be an empty string

template<class T >

T util::cube ( T  x )

inline

More efficient cube function than pow(x,3)

Definition at line 26 of file MathUtil.h.

References submit_syst::x.

Referenced by fnex::ShifterAndWeighter::CalcInterpolatedWgt(), hv::HoughVertexAlg::FillMaps(), ana::PredictionInterp::FitRatios(), calib::AttenFit::lowessFit(), calib::AttenuationFit::lowessFit(), and ana::PredictionInterp::ShiftBins().

{return x*x*x;}

def util.elem_frac	(		compos,
			elem
	)

Definition at line 20 of file util.py.

References tot_weight().

Referenced by elem_frac_total().

def elem_frac(compos, elem):
  if elem in compos:
    return compos[elem] * atomic_weight[elem] / tot_weight(compos)
  else:
    return 0

def util.elem_frac_total	(		elem,
			compositions,
			fractions
	)

Definition at line 26 of file util.py.

References elem_frac(), and tot_fractions().

Referenced by make_composition(), and print_composition().

def elem_frac_total(elem, compositions, fractions):
  frac = 0
  for material, compos in compositions.items():
    if material in fractions:
      frac += elem_frac(compos, elem) * fractions[material]
  return frac / tot_fractions(fractions)

std::string util::EnvExpansion

(

const std::string &

inString

)

Function to expand environment variables.

Definition at line 8 of file EnvExpand.cxx.

References compare_h5_caf::idx, confusionMatrixTree::out, fabricate::status, and tmp.

Referenced by wsnumu::WSNumu::beginRun(), ncpi0::MakeNCPi0BkgRej::beginRun(), ncid::MakeNCCosRej::beginRun(), bpfit::BPFEnergyEstimator::beginRun(), bpfit::BPFEnergyEstimatorOnly::beginRun(), bpfit::BPFPIdMaker::beginRun(), cosrej::MakeNueCosRej::beginRun(), ncid::NCNNKeras::beginRun(), ncid::NCNNKerasVal::beginRun(), cvntf::CVNCosmicTF::CVNCosmicTF(), cvneventtf::CVNEventTF::CVNEventTF(), cvntf::CVNProngEvaluatorTF::CVNProngEvaluatorTF(), cvnprongtf::CVNProngTF::CVNProngTF(), qeef::QeFinder::Init(), cosrej::CosRej::Init(), remid::RecoMuon::Init(), slid::DedxDistribution::Initialize(), ana::GetBDTCosRej_BPF_FHCPer1::InitTMVA(), ana::GetBDTCosRej_BPF_FHCPer2::InitTMVA(), ana::GetBDTCosRej_BPF_FHCHigh::InitTMVA(), ana::GetBDTCosRej_BPF_RHCHigh::InitTMVA(), ana::GetBDTCosRej_Kal_FHCPer1::InitTMVA(), ana::GetBDTCosRej_Kal_FHCPer2::InitTMVA(), ana::GetBDTCosRej_Kal_FHCHigh::InitTMVA(), ana::GetBDTCosRej_Kal_RHCHigh::InitTMVA(), slid::LIDAlg::LIDAlg(), slid::ParticleIDAlg::LoadDedxHistogramFiles(), jmshower::RecoJMShower::LoadDedxHistograms(), jmshower::RecoJMShower::LoadTreeWeights(), lem::MakePID::MakePID(), lem::LEMLibrary::reconfigure(), lem::FindMatchesTranspose::reconfigure(), lem::FindLEMMatches::reconfigure(), lem::LEM::reconfigure(), slid::LIDBuilder::reconfigure(), slid::SPIDBuilder::reconfigure(), rvp::RecVarPID::RecVarPID(), regcvntf::RegCVNTF::RegCVNTF(), slid::SPIDAlg::SPIDAlg(), and xnue::XnuePID::XnuePID().

  {
    std::string outString = inString;
    
    wordexp_t out;
    int status = wordexp(inString.c_str(), &out, WRDE_SHOWERR);
    if(status == 0){
      outString = "";
      for (unsigned int idx = 0; idx < out.we_wordc; ++idx){
        std::string tmp(out.we_wordv[idx]);
        outString.append(tmp);
      }
    }
    wordfree(&out);
    return outString;
  }

void util::EventBox	(	const std::vector< art::Ptr< rawdata::RawDigit > > &	d,
		unsigned int	i1,
		unsigned int	i2,
		unsigned int *	plane1x,
		unsigned int *	plane2x,
		unsigned int *	cell1x,
		unsigned int *	cell2x,
		unsigned int *	plane1y,
		unsigned int *	plane2y,
		unsigned int *	cell1y,
		unsigned int *	cell2y
	)

Find boxes in plane/cell units that contain all the hits.

Parameters

d	: The complete list of raw digits to be considered
i1	: Index of the first hit to be considered
i2	: Index of the last hit to be considered (inclusive)
plane1x	: On output, the lowest plane number in the x view
plane2x	: On output, the highest plane number in the x view
cell1x	: On output, the lowest cell number in the x view
cellx	: On output, the highest cell number in the x view
plane1y	: On output, the lowest plane number in the y view
plane2y	: On output, the highest plane number in the y view
cell1y	: On output, the lowest cell number in the y view
celly	: On output, the highest cell number in the y view

Definition at line 60 of file RawUtil.cxx.

References make_syst_table_plots::c, visualisationForPaperMasterPlot::cmap, d, geom(), cmap::dataprov::CMap::GetCell(), cmap::dataprov::CMap::GetPlane(), MECModelEnuComparisons::i, geo::kX, geo::kY, geo::GeometryBase::Plane(), registry_explorer::v, and geo::PlaneGeo::View().

{
  art::ServiceHandle<cmap::CMap>    cmap;
  art::ServiceHandle<geo::Geometry> geom;

  *plane1x = 999999;
  *plane1y = 999999;
  *cell1x  = 999999;
  *cell1y  = 999999;
  *plane2x = 0;
  *cell2x  = 0;
  *plane2y = 0;
  *cell2y  = 0;
  
  unsigned int i;
  unsigned int p, c;
  geo::View_t v;
  for (i=i1; i<=i2; ++i) {
    p = cmap->GetPlane(d[i].get());
    v = geom->Plane(p)->View();
    c = cmap->GetCell(d[i].get());
    if (v==geo::kX) {
      if (p<(*plane1x)) (*plane1x) = p;
      if (p>(*plane2x)) (*plane2x) = p;
      if (c<(*cell1x))  (*cell1x)  = c;
      if (c>(*cell2x))  (*cell2x)  = c;
    }
    else if (v==geo::kY) {
      if (p<(*plane1y)) (*plane1y) = p;
      if (p>(*plane2y)) (*plane2y) = p;
      if (c<(*cell1y))  (*cell1y)  = c;
      if (c>(*cell2y))  (*cell2y)  = c;      
    }
  }
}

unsigned int util::FilterFEBFlash	(	std::vector< art::Ptr< rawdata::RawDigit > > &	rd,
		int	adc_sat = 3400,
		int	dt_tdc = 1280
	)

Filter hits that are "FEB flash" candidates; that is, they occur within a specified time of an FEB hit in saturation.

Parameters

rd	- Input list of raw digits. On output it will be time sorted and have had FEB flash hits removed.
adc_sat	- ADC value to flag a raw hit as being in saturation, recommended value is 3400 counts
dt_tdc	- time difference between time of saturation and time of candidate "flash" hit in units of TDC counts. Recommended value is 1280 (20 usec) Note: 1920 (30 usec) is also a useful optional value.

Returns

the new size of the rd raw hit list

Note that the vector rd will be returned time sorted and equal or shorter than its original length

Definition at line 194 of file RawUtil.cxx.

References update_sam_good_runs_metadata::good, MECModelEnuComparisons::i, calib::j, and TimeSort().

{
  unsigned int i, j;

  //
  // For efficiency, time sort the hits in advance
  //
  util::TimeSort(rd);
      
  //
  // Flag all hits as good, look for ones that might be bad
  //
  std::vector<bool> isgood(rd.size());
  for (i=0; i<rd.size(); ++i) isgood[i] = true;
  for (i=0; (i+1)<rd.size(); ++i) {
    //
    // If the hit i is not in saturation, we can skip to the next
    // hit
    //
    if (rd[i]->ADC()<adc_sat) continue;
    //
    // Get ID number for the FEB ID that has the hit in saturation
    //
    unsigned int chi      = rd[i]->DaqChannel();
    unsigned int diblocki = (chi&0x0FC00000)>>22;
    unsigned int dcmi     = (chi&0x003F0000)>>16;
    unsigned int febi     = (chi&0x0000FF00)>>8;
    for (j=i+1; j<rd.size(); ++j) {
      //
      // Don't need to look beyond the time limit
      //
      if ((rd[j]->TDC()-rd[i]->TDC())>dt_tdc) break;
      //
      // Hit j is in time range of another hit which is in
      // saturation. Check if hit j comes from the same FEB as hit
      // i
      //
      unsigned int chj      = rd[j]->DaqChannel();
      unsigned int diblockj = (chj&0x0FC00000)>>22;
      unsigned int dcmj     = (chj&0x003F0000)>>16;
      unsigned int febj     = (chj&0x0000FF00)>>8;
      bool sameFEB = 
        (diblocki==diblockj) && (dcmi==dcmj) && (febi==febj);
      if (sameFEB) isgood[j] = false;
    }
  }
  //
  // Push all the good hits into the final list
  //
  std::vector< art::Ptr<rawdata::RawDigit> > good;
  good.reserve(rd.size());
  for (i=0; i<rd.size(); ++i) {
    if (isgood[i]) good.push_back(rd[i]);
  }
  rd.swap(good);
  return rd.size();
}

static double util::find_median ( const std::vector< std::pair< double, double > > &  a )

static

Definition at line 83 of file MathUtil.cxx.

References a, MECModelEnuComparisons::i, moon_position_table_new3::second, x1, submit_syst::x2, y1, and submit_syst::y2.

Referenced by LinFitTS().

  {
    unsigned int i;
    for (i=0; i<a.size(); ++i) {
      if (a[i].second>0.5) break;
    }
    if (i>1) {
      //
      // Linearly interpolate along weights to find 0.5
      //
      double x1 = a[i-1].second;
      double x2 = a[i].  second;
      double y1 = a[i-1].first;
      double y2 = a[i].  first;
      return y1 + (0.5-x1)*(y2-y1)/(x2-x1);
    }
    return a[i].first;
  }

template<class T , class U >

static std::vector<const U*> util::FindUNotAssociatedToT ( art::Handle< U >  b, art::Event const &  evt, std::string const &  label  )

static

Return all objects of type U that are not associated to objects of type T.

Label is the module label that would have produced the associations and likely the objects of type T this method assumes there is a one to many relationship between T and U for example if you want to get all rb::CellHits that are not associated to rb::Clusters std::vector<const rb::CellHit*> hits = FindUNotAssociatedToU<rb::Cluster>(art::Handle<rb::CellHit>, ...);

template<class T , class U >

static std::vector<const U*> util::FindUNotAssociatedToT ( art::Handle< U >  b, art::Event const &  evt, std::string const &  label  )

static

Return all objects of type U that are not associated to objects of type T.

Label is the module label that would have produced the associations and likely the objects of type T this method assumes there is a one to many relationship between T and U for example if you want to get all rb::CellHits that are not associated to rb::Clusters std::vector<const rb::CellHit*> hits = FindUNotAssociatedToU<rb::Cluster>(art::Handle<rb::CellHit>, ...);

template<class T , class U >

static std::vector< art::Ptr<U> > util::FindUNotAssociatedToTP ( art::Handle< U >  b, art::Event const &  evt, std::string const &  label  )

static

Return all objects of type U that are not associated to objects of type T.

Label is the module label that would have produced the associations and likely the objects of type T this method assumes there is a one to many relationship between T and U for example if you want to get all rb::CellHits that are not associated to rb::Clusters std::vector<art::Ptr<rb::CellHit> > hits = FindUNotAssociatedToTP<rb::Cluster>(art::Handle<rb::CellHit>, ...);

template<class T , class U >

static std::vector< art::Ptr<U> > util::FindUNotAssociatedToTP ( art::Handle< U >  b, art::Event const &  evt, std::string const &  label  )

static

Return all objects of type U that are not associated to objects of type T.

Label is the module label that would have produced the associations and likely the objects of type T this method assumes there is a one to many relationship between T and U for example if you want to get all rb::CellHits that are not associated to rb::Clusters std::vector<art::Ptr<rb::CellHit> > hits = FindUNotAssociatedToTP<rb::Cluster>(art::Handle<rb::CellHit>, ...);

double util::frac

(

double

x

)

Fractional part.

Definition at line 83 of file RemoveBeamSpillsPrecise_module.cc.

References makeTrainCVSamples::int.

Referenced by bin_composition_pie_chart(), chaninfo::CosmicEff::endJob(), util::RemoveBeamSpillsPrecise::filter(), tut::TutProducer::FitPhoton(), genie::INukeHadroData2018::Frac(), genie::INukeHadroData::Frac(), genie::geometry::ROOTGeomAnalyzer::GenerateVertex(), GetLimits(), SystEntry::GetLimits(), histCompare(), genie::HAIntranuke::Inelastic(), genie::HAIntranuke2018::Inelastic(), genie::geometry::PathSegment::IsTrimmedEmpty(), main(), make_cosmic_eff_table(), make_plots(), remid::ReMId::MeasurementFraction(), calib::AttenFit::MedianProfile(), calib::AttenuationFit::MedianProfile(), fuzz::FuzzyKMeanAlg::MergeClusters(), ana::PredictionSystJoint2018::PredictionSystJoint2018(), and ana::PredictionSystJointDemo::PredictionSystJointDemo().

  {
    return x-int(x);
  }

template<class T >

std::unique_ptr<std::vector<T> > util::GetHits

(

const std::vector< rb::Cluster > &

clusts

)

Definition at line 54 of file CopyCellHits_module.cc.

  {
    auto hitcol = std::make_unique<std::vector<T>>();

    for(const rb::Cluster& clust: clusts)
      for(unsigned int iCell = 0; iCell < clust.NCell(); ++iCell)
        hitcol->push_back(*clust.Cell(iCell));

    return hitcol;
  }

template<typename T >

T 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.)

explicit specialization for double return value

Definition at line 25 of file StanUtils.h.

References febshutoff_auto::val, and stan::math::var::val().

{return val.val();}

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.

References stan::math::var::val().

{return val.val();}

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.

{ return val; }

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.

{ return val; }

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, make_syst_table_plots::c, MECModelEnuComparisons::i, LinFit(), LinFitTS(), LinFitUnweighted(), m, getGoodRuns4SAM::n, 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, getGoodRuns4SAM::n, 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().

Referenced by ana::KrigeKernel::AddPoint(), comi::CosmicMetrics::analyze(), mcchk::CosmicAna::analyze(), align::Alignment::analyze(), mcchk::LeptonAna::analyze(), earms::ElasticArmsValidate::analyze(), comi::NearlineAna::analyze(), fuzz::FuzzyKValidate::analyze(), mono::Monopole::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(), 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().

  {
    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 make_syst_table_plots::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 galleryMaker::ext, and runNovaSAM::gErrorIgnoreLevel.

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.

References stan::math::var::val().

{target = source.val();}

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

inline

Definition at line 41 of file StanUtils.h.

{target = source;}

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

inline

Definition at line 42 of file StanUtils.h.

{target = source;}

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

inline

Definition at line 45 of file StanUtils.h.

{target = source;}

static bool util::sort_pair_by_first ( const std::pair< double, double > &  a, const std::pair< double, double > &  b  )

static

Definition at line 75 of file MathUtil.cxx.

Referenced by LinFitTS().

  {
    return (a.first<b.first);
  }

template<class T >

T util::sqr ( T  x )

inline

More efficient square function than pow(x,2)

Definition at line 23 of file MathUtil.h.

References submit_syst::x.

Referenced by ana::KrigeKernel::AddPoint(), novaddt::ClusterAna::analyze(), align::Alignment::analyze(), ana::AutoPlaceLegend(), ana::CalcChi2(), fnex::ShifterAndWeighter::CalcInterpolatedWgt(), cc(), ana::Dmsq32Constraint::ChiSq(), ana::ReactorExperiment::ChiSq(), ana::GaussianConstraint::ChiSq(), ana::SolarConstraints::ChiSq(), ana::AtmConstraint::ChiSq(), ana::Ssth23Constraint::ChiSq(), ana::ComparisonTableNbins(), ana::TwoSampleDecomp::Decomp(), calib::BetheBlochAnalytic::dEdx(), lem::DistanceMap::DistanceMap(), geo::DsqrToLine(), ana::ErrorBarChart(), tf::HoughScore::Eval(), FCCorrectSlice(), tdslicer::TDSlicer::FillDists(), hv::HoughVertexAlg::FillMaps(), novaddt::NuESelect::filter(), calib::AttenFit::FitQuality(), calib::AttenuationFit::FitQuality(), ana::PredictionInterp::FitRatios(), trk::CosmicTrackAlg::FitView(), trk::WindowTrackingAlg::FitWindow(), lem::dec::Cut::FOM(), ana::FitSinSq2Theta13::GetValue(), ana::FitSinSqTheta23::GetValue(), FitSinSqTheta23UO::GetValue(), ana::FitSinSqTheta23UpperOctant::GetValue(), FitSinSqTheta23LO::GetValue(), ana::FitSinSqTheta23LowerOctant::GetValue(), ana::FitSinSqTheta13Sterile::GetValue(), ana::FitSinSq2Theta23CPT::GetValue(), ana::FitSinSq2Theta23::GetValue(), ana::FitSinSq2Theta13Sterile::GetValue(), ana::FitSinSqTheta23CPT::GetValue(), ana::FitSinSqTheta23Sterile::GetValue(), ana::FitSinSq2Theta13CPT::GetValue(), ana::FitSinSqTheta14Sterile::GetValue(), ana::FitSinSq2Theta12CPT::GetValue(), FitSinSqTheta23MaxMix::GetValue(), ana::FitSinSqTheta24Sterile::GetValue(), ana::FitTanSqTheta12::GetValue(), ana::FitSinSq2Theta12::GetValue(), ana::FitSinSqTheta34Sterile::GetValue(), FitSinSqTheta23LowerOctant::GetValue(), FitSinSqTheta23UpperOctant::GetValue(), ana::MINERvA_MEC_Wgt_Var::GetWeight(), ana::Spectrum::Integral(), ipow(), geo::LinFitMinDperp(), test::LogGauss(), ana::T2KToyExperiment::LogL(), test::GaussQuadExperiment::LogLikelihood(), ana::GaussianPriorSystShifts::LogPrior(), MakeStackNME(), hough::Hough2P::Map(), hough::MultiHough2P::Map(), monoprob(), calib::BetheBlochAnalytic::MPV(), ana::MuonMass(), ana::NeutronMass(), ana::IConstrainedFitVar::Penalty(), ana::PointDistanceToBox(), mcchk::ShowerAnaCheck::PointLineDistance(), ana::PrintOscilationParameters(), ana::GaussianPriorSystShifts::Prior(), jmshower::JMTrackMerge::produce(), numusand::FillSandbox::produce(), lem::MakePID::produce(), cosrej::MakeNueCosRej::produce(), pythag(), ana::RefineSeeds(), ana::MCMCSamples::RunDiagnostics(), ana::SummedSyst::Shift(), ana::PredictionInterp::ShiftBins(), ana::SimpleFOM(), ncs::NCAna::SimpleOscProb(), lem::Library::SimpleSurvivalProb(), lem::SimpleSurvivalProb(), test_ana(), test_stanfit_statsonly(), test_stanfit_withsysts(), lem::dec::Forest::Train(), lem::dec::Forest::TrainSingleTransformed(), calib::AttenFit::TruncatedMeanProfile(), calib::AttenuationFit::TruncatedMeanProfile(), and demo::DemoSyst1::TruthShift().

{return x*x;}

void util::TimeSlice	(	const std::vector< art::Ptr< rawdata::RawDigit > > &	d,
		unsigned int	tdcwindow,
		unsigned int	nhit,
		unsigned int	nhitx,
		unsigned int	nhity,
		std::vector< RawSlice > &	slice
	)

Find windows in time that have significant activity in the detector.

Parameters

d	- The full raw digit list to consider
dt_tdc	- Sliding window size in NOvA clock ticks (64 MHz)
nhit	- Total number of hits to look for in window
nhitx	- Number of hits required in x view
nhity	- Number of hits required in y view
slice	- On output, the start and end indicies of the time windows

Note: d must be time sorted on input. See "TimeSort" above.

Find time windows with significant hit activity

Definition at line 111 of file RawUtil.cxx.

References CountXY(), d, MECModelEnuComparisons::i, calib::j, demo1::nhit, and moon_position_table_new3::second.

Referenced by comi::Leana::analyze(), comi::FEBFlash::FEBTimeSlice(), and comi::Cana::produce().

{
  //
  // If the list can't meet our minimum hit requirements, we're done
  // before we start. These checks also guarantee that the assumptions
  // we make later regarding unsigned int arithmetic is correct
  //
  if (nhit<1 || nhit<(nhitx+nhity) || d.size()<nhit) return;
  
  unsigned int i, j;
  std::vector<RawSlice> tmpslice;
  for (i=0; i<d.size(); ++i) {
    //
    // Slide forward through the hits until we pass the limit of the
    // time window
    //
    unsigned int dt = 0;
    for (j=i+1; j<d.size(); ++j) {
      dt = d[j]->TDC() - d[i]->TDC();
      if (dt>=tdcwindow) {
        //
        // The last hit will have exceeded the time window so back up by
        // one so that j is the index of the last hit to be included
        //
        --j;
        //
        // Do we have enough total hits?
        //
        if (j>=i && (j-i+1)>=nhit) {
          //
          // Do we have enough in the x and y views?
          //
          unsigned int nx=0, ny=0;
          util::CountXY(d, i, j, &nx, &ny);
          //
          // Slice meets requirements. Put it in the list.
          //
          if (nx>=nhitx && ny>=nhity) {
            RawSlice rs;
            rs.first  = i;
            rs.second = j;
            tmpslice.push_back(rs);
          }
        }
        break; // Jump out of loop on j
      } // if (dt>=tdcwindow)
    } // for (j=...
    //
    // If we've bumped into the end of the digit list, we're done
    //
    if (j==d.size()) break;
  }
  //
  // Merge overlaping slices
  //
  for (i=0; i<tmpslice.size(); ++i) {
    if (tmpslice[i].first==0 && tmpslice[i].second==0) continue;
    for (j=i+1; j<tmpslice.size(); ++j) {
      if (tmpslice[j].first <= tmpslice[i].second) {
        tmpslice[i].second = tmpslice[j].second;
        tmpslice[j].first = 0;
        tmpslice[j].second= 0;
      }
    }
  }
  //
  // Push which ever slices survived to the output
  //
  for (unsigned int i=0; i<tmpslice.size(); ++i) {
    if (!(tmpslice[i].first==0 && tmpslice[i].second==0)) {
      slice.push_back(tmpslice[i]);
    }
  }
}

void util::TimeSort

(

std::vector< art::Ptr< rawdata::RawDigit > > &

d

)

Arrange the list of raw hits in time order (early to late)

Parameters

d	: The list of digits to be sorted. Sorted on output.

Sort the list of digits to be in increasing time order, earliest to lattest

Definition at line 31 of file RawUtil.cxx.

References d, and digi_sort().

Referenced by comi::Leana::analyze(), comi::FEBFlash::FEBTimeSlice(), comi::FEBFlash::FilterFEBFlash(), FilterFEBFlash(), and comi::Cana::produce().

{
  sort(d.begin(), d.end(), digi_sort);
}

def util.tot_fractions

(

fractions

)

Definition at line 14 of file util.py.

Referenced by elem_frac_total().

def tot_fractions(fractions):
  tions = 0
  for material, fraction in fractions.items():
     tions += fraction
  return tions

def util.tot_weight

(

compos

)

Definition at line 8 of file util.py.

Referenced by elem_frac().

def tot_weight(compos):
  weight = 0
  for element, number in compos.items():
     weight += number * atomic_weight[element]
  return weight

def util.zovera

(

elem

)

Definition at line 33 of file util.py.

Referenced by zoveramaterial().

def zovera(elem):
  # Not quite correct since atomic_weight in amu is only protons +
  # neutrons up to the mass defect
  return atomic_number[elem]/atomic_weight[elem]

# takes a weight-fraction composition

def util.zoveramaterial

(

compos

)

Definition at line 39 of file util.py.

References zovera().

def zoveramaterial(compos):
  zoverasum = 0
  for elem in elemlist:
    if elem in compos:
      zoverasum += zovera(elem)*compos[elem]
  return zoverasum

Variable Documentation

list util.elemlist

Initial value:

= [ 'H', 'C', 'O', 'N', 'S', 'Cl', 'Ti', 'Sn', 'Ca', 'Na',
             'Al', 'Fe', 'Si', 'K', 'Mn', 'P', 'Ba' ]

Definition at line 3 of file util.py.

const int util::kBeamWindowBadPeriodMicroSec

Initial value:

=
    (kBeamWindowMaxMicroSec - kBeamWindowMinMicroSec) +
    (kBeamWindowShiftedMaxMicroSec - kBeamWindowShiftedMinMicroSec)

Two windows to consider here.

Definition at line 89 of file NuMITimeParams.h.

const int util::kBeamWindowMaxMicroSec = 229

Definition at line 50 of file NuMITimeParams.h.

Referenced by generate_fd_fake_events().

const int util::kBeamWindowMicroSec = kBeamWindowMaxMicroSec - kBeamWindowMinMicroSec

How long is the beam window?

Definition at line 81 of file NuMITimeParams.h.

const int util::kBeamWindowMinMicroSec = 217

Definition at line 49 of file NuMITimeParams.h.

Referenced by generate_fd_fake_events().

const int util::kBeamWindowPaddingMicroSec = 9

Definition at line 47 of file NuMITimeParams.h.

const int util::kBeamWindowShiftedMaxMicroSec = kBeamWindowMaxMicroSec + kPeakShiftMicroSec

Definition at line 67 of file NuMITimeParams.h.

const int util::kBeamWindowShiftedMinMicroSec = kBeamWindowMinMicroSec + kPeakShiftMicroSec

Definition at line 66 of file NuMITimeParams.h.

const int util::kLastBadTimingRun = 17945

Definition at line 77 of file NuMITimeParams.h.

Referenced by Exposure().

const int util::kMaxTimingSidebandAfterMicroSec = 475

Definition at line 60 of file NuMITimeParams.h.

Referenced by generate_fd_fake_events().

const int util::kMaxTimingSidebandBeforeMicroSec = kBeamWindowMinMicroSec - kBeamWindowPaddingMicroSec

Definition at line 55 of file NuMITimeParams.h.

const int util::kMaxTimingSidebandBeforeShiftedWindowMicroSec = kBeamWindowShiftedMinMicroSec - kBeamWindowPaddingMicroSec

Definition at line 71 of file NuMITimeParams.h.

const int util::kMinTimingSidebandAfterMicroSec = kBeamWindowMaxMicroSec + kBeamWindowPaddingMicroSec

Definition at line 59 of file NuMITimeParams.h.

Referenced by generate_fd_fake_events().

const int util::kMinTimingSidebandAfterShiftedWindowMicroSec = kBeamWindowShiftedMaxMicroSec + kBeamWindowPaddingMicroSec

Definition at line 72 of file NuMITimeParams.h.

const int util::kMinTimingSidebandBeforeMicroSec = 25

Definition at line 54 of file NuMITimeParams.h.

const int util::kPeakShiftMicroSec = +64

Definition at line 63 of file NuMITimeParams.h.

const int util::kTimingSidebandBadPeriodMicroSec

Initial value:

=
    (kMaxTimingSidebandBeforeMicroSec - kMinTimingSidebandBeforeMicroSec) +
    (kMaxTimingSidebandBeforeShiftedWindowMicroSec - kMinTimingSidebandAfterMicroSec) +
    (kMaxTimingSidebandAfterMicroSec - kMinTimingSidebandAfterShiftedWindowMicroSec)

Two beam windows to cut out here.

Definition at line 94 of file NuMITimeParams.h.

const int util::kTimingSidebandMicroSec

Initial value:

=
    (kMaxTimingSidebandBeforeMicroSec - kMinTimingSidebandBeforeMicroSec) +
    (kMaxTimingSidebandAfterMicroSec - kMinTimingSidebandAfterMicroSec)

How long is the part of the spill far from the start and end, and also not in the beam window?

Definition at line 84 of file NuMITimeParams.h.

bool util.printmore = False

Definition at line 6 of file util.py.

---

Generated on Fri Aug 14 2020 05:20:22 for NOvA by   1.8.11