NamedCandCombinerBase Class Reference

#include <NamedCandCombinerBase.h>

Public Types
typedef std::vector< std::string >	string_coll

Public Member Functions
std::unique_ptr < reco::NamedCompositeCandidateCollection >	combine (const std::vector< reco::CandidatePtrVector > &, string_coll const &) const
	return all selected candidate pairs More...
std::unique_ptr < reco::NamedCompositeCandidateCollection >	combine (const reco::CandidatePtrVector &, string_coll const &) const
	return all selected candidate pairs More...
std::unique_ptr < reco::NamedCompositeCandidateCollection >	combine (const reco::CandidatePtrVector &, const reco::CandidatePtrVector &, string_coll const &) const
	return all selected candidate pairs More...
std::unique_ptr < reco::NamedCompositeCandidateCollection >	combine (const reco::CandidatePtrVector &, const reco::CandidatePtrVector &, const reco::CandidatePtrVector &, string_coll const &) const
	return all selected candidate pairs More...
std::unique_ptr < reco::NamedCompositeCandidateCollection >	combine (const reco::CandidatePtrVector &, const reco::CandidatePtrVector &, const reco::CandidatePtrVector &, const reco::CandidatePtrVector &, string_coll const &) const
	return all selected candidate pairs More...
	NamedCandCombinerBase (std::string name)
	default construct More...
	NamedCandCombinerBase (std::string name, int, int)
	construct from two charge values More...
	NamedCandCombinerBase (std::string name, int, int, int)
	construct from three charge values More...
	NamedCandCombinerBase (std::string name, int, int, int, int)
	construct from four charge values More...
	NamedCandCombinerBase (std::string name, bool checkCharge, bool checkOverlap, const std::vector< int > &)
	constructor from a selector, specifying optionally to check for charge More...
virtual	~NamedCandCombinerBase ()
	destructor More...

Private Types
typedef std::vector< std::pair < std::pair < reco::CandidatePtr, size_t > , std::vector < reco::CandidatePtrVector > ::const_iterator > >	CandStack
	temporary candidate stack More...
typedef std::vector< int >	ChargeStack

Private Member Functions
virtual void	addDaughter (reco::NamedCompositeCandidate &cmp, const reco::CandidatePtr &c, std::string name) const =0
	add candidate daughter More...
void	combine (reco::NamedCompositeCandidate &, const reco::CandidatePtr &, const reco::CandidatePtr &, std::string, std::string) const
	returns a composite candidate combined from two daughters More...
void	combine (size_t collectionIndex, CandStack &, ChargeStack &, string_coll const &names, std::vector< reco::CandidatePtrVector >::const_iterator begin, std::vector< reco::CandidatePtrVector >::const_iterator end, std::unique_ptr< reco::NamedCompositeCandidateCollection > &comps) const
	returns a composite candidate combined from two daughters More...
bool	preselect (const reco::Candidate &, const reco::Candidate &) const
	verify that the two candidate don't overlap and check charge More...
virtual bool	select (const reco::Candidate &) const =0
	select a candidate More...
virtual bool	selectPair (const reco::Candidate &c1, const reco::Candidate &c2) const =0
	select a candidate pair More...
virtual void	setup (reco::NamedCompositeCandidate &) const =0
	set kinematics to reconstructed composite More...

Private Attributes
bool	checkCharge_
	flag to specify the checking of electric charge More...
bool	checkOverlap_
	flag to specify the checking of overlaps More...
std::vector< int >	dauCharge_
	electric charges of the daughters More...
std::string	name_
	Name. More...
OverlapChecker	overlap_
	utility to check candidate daughters overlap More...

Detailed Description

Definition at line 13 of file NamedCandCombinerBase.h.

Member Typedef Documentation

typedef std::vector< std::pair<std::pair<reco::CandidatePtr, size_t>, std::vector<reco::CandidatePtrVector>::const_iterator> > NamedCandCombinerBase::CandStack

private

temporary candidate stack

Definition at line 62 of file NamedCandCombinerBase.h.

typedef std::vector<int> NamedCandCombinerBase::ChargeStack

private

Definition at line 63 of file NamedCandCombinerBase.h.

typedef std::vector<std::string> NamedCandCombinerBase::string_coll

Definition at line 15 of file NamedCandCombinerBase.h.

Constructor & Destructor Documentation

NamedCandCombinerBase::NamedCandCombinerBase

(

std::string

name

)

default construct

Definition at line 6 of file NamedCandCombinerBase.cc.

    : checkCharge_(false), checkOverlap_(true), dauCharge_(), overlap_(), name_(name) {}

NamedCandCombinerBase::NamedCandCombinerBase	(	std::string	name,
		int	q1,
		int	q2
	)

construct from two charge values

Definition at line 9 of file NamedCandCombinerBase.cc.

References dauCharge_.

    : checkCharge_(true), checkOverlap_(true), dauCharge_(2), overlap_(), name_(name) {
  dauCharge_[0] = q1;
  dauCharge_[1] = q2;
}

NamedCandCombinerBase::NamedCandCombinerBase	(	std::string	name,
		int	q1,
		int	q2,
		int	q3
	)

construct from three charge values

Definition at line 15 of file NamedCandCombinerBase.cc.

References dauCharge_.

    : checkCharge_(true), checkOverlap_(true), dauCharge_(3), overlap_(), name_(name) {
  dauCharge_[0] = q1;
  dauCharge_[1] = q2;
  dauCharge_[2] = q3;
}

NamedCandCombinerBase::NamedCandCombinerBase	(	std::string	name,
		int	q1,
		int	q2,
		int	q3,
		int	q4
	)

construct from four charge values

Definition at line 22 of file NamedCandCombinerBase.cc.

References dauCharge_.

    : checkCharge_(true), checkOverlap_(true), dauCharge_(4), overlap_(), name_(name) {
  dauCharge_[0] = q1;
  dauCharge_[1] = q2;
  dauCharge_[2] = q3;
  dauCharge_[3] = q4;
}

NamedCandCombinerBase::NamedCandCombinerBase	(	std::string	name,
		bool	checkCharge,
		bool	checkOverlap,
		const std::vector< int > &	dauCharge
	)

constructor from a selector, specifying optionally to check for charge

Definition at line 30 of file NamedCandCombinerBase.cc.

    : checkCharge_(checkCharge), checkOverlap_(checkOverlap), dauCharge_(dauCharge), overlap_() {}

NamedCandCombinerBase::~NamedCandCombinerBase ( )

virtual

destructor

Definition at line 36 of file NamedCandCombinerBase.cc.

{}

Member Function Documentation

virtual void NamedCandCombinerBase::addDaughter ( reco::NamedCompositeCandidate &  cmp, const reco::CandidatePtr &  c, std::string  name  ) const

privatepure virtual

add candidate daughter

Referenced by combine().

unique_ptr< NamedCompositeCandidateCollection > NamedCandCombinerBase::combine	(	const std::vector< reco::CandidatePtrVector > &	src,
		string_coll const &	names
	)		const

return all selected candidate pairs

Definition at line 60 of file NamedCandCombinerBase.cc.

References c, alignmentValidation::c1, checkCharge_, edm::errors::Configuration, dauCharge_, dqmiodumpmetadata::n, preselect(), select(), edm::PtrVectorBase::size(), readCalibrations2004_v2_cff::src1, readConfiguration2006_v0_cff::src2, and svgfig::stack.

Referenced by combine().

                                                                                                             {
  size_t srcSize = src.size();
  if (checkCharge_ && dauCharge_.size() != srcSize)
    throw edm::Exception(edm::errors::Configuration)
        << "NamedCandCombiner: trying to combine " << srcSize << " collections"
        << " but configured to check against " << dauCharge_.size() << " charges.";

  if (names.size() < 2)
    throw edm::Exception(edm::errors::Configuration)
        << "NamedCandCombiner: need to add 2 names, but size is " << names.size();

  unique_ptr<NamedCompositeCandidateCollection> comps(new NamedCompositeCandidateCollection);
  if (srcSize == 2) {
    CandidatePtrVector src1 = src[0], src2 = src[1];
    if (src1 == src2) {
      const int n = src1.size();
      for (int i1 = 0; i1 < n; ++i1) {
        const Candidate& c1 = *(src1[i1]);
        for (int i2 = i1 + 1; i2 < n; ++i2) {
          const Candidate& c2 = *(src1[i2]);
          if (preselect(c1, c2)) {
            NamedCompositeCandidate c;
            combine(c, src1[i1], src1[i2], names[0], names[1]);
            if (select(c))
              comps->push_back(c);
          }
        }
      }
    } else {
      const int n1 = src1.size(), n2 = src2.size();
      for (int i1 = 0; i1 < n1; ++i1) {
        const Candidate& c1 = *(src1[i1]);
        for (int i2 = 0; i2 < n2; ++i2) {
          const Candidate& c2 = *(src2[i2]);
          if (preselect(c1, c2)) {
            NamedCompositeCandidate c;
            combine(c, src1[i1], src2[i2], names[0], names[1]);
            if (select(c))
              comps->push_back(c);
          }
        }
      }
    }
  } else {
    CandStack stack;
    ChargeStack qStack;
    combine(0, stack, qStack, names, src.begin(), src.end(), comps);
  }

  return comps;
}

unique_ptr< NamedCompositeCandidateCollection > NamedCandCombinerBase::combine	(	const reco::CandidatePtrVector &	src,
		string_coll const &	names
	)		const

return all selected candidate pairs

Definition at line 113 of file NamedCandCombinerBase.cc.

References c, alignmentValidation::c1, checkCharge_, combine(), edm::errors::Configuration, dauCharge_, dqmiodumpmetadata::n, preselect(), select(), and edm::PtrVectorBase::size().

                                                                                                             {
  if (checkCharge_ && dauCharge_.size() != 2)
    throw edm::Exception(edm::errors::Configuration)
        << "NamedCandCombiner: trying to combine 2 collections"
        << " but configured to check against " << dauCharge_.size() << " charges.";

  if (names.size() < 2)
    throw edm::Exception(edm::errors::Configuration)
        << "NamedCandCombiner: need to add 2 names, but size is " << names.size();

  unique_ptr<NamedCompositeCandidateCollection> comps(new NamedCompositeCandidateCollection);
  const int n = src.size();
  for (int i1 = 0; i1 < n; ++i1) {
    const Candidate& c1 = *(src[i1]);
    for (int i2 = i1 + 1; i2 < n; ++i2) {
      const Candidate& c2 = *(src[i2]);
      if (preselect(c1, c2)) {
        NamedCompositeCandidate c;
        combine(c, src[i1], src[i2], names[0], names[1]);
        if (select(c))
          comps->push_back(c);
      }
    }
  }

  return comps;
}

unique_ptr< NamedCompositeCandidateCollection > NamedCandCombinerBase::combine	(	const reco::CandidatePtrVector &	src1,
		const reco::CandidatePtrVector &	src2,
		string_coll const &	names
	)		const

return all selected candidate pairs

Definition at line 142 of file NamedCandCombinerBase.cc.

References combine(), and alcazmumu_cfi::src.

                                                                                                             {
  vector<CandidatePtrVector> src;
  src.push_back(src1);
  src.push_back(src2);
  return combine(src, names);
}

unique_ptr< NamedCompositeCandidateCollection > NamedCandCombinerBase::combine	(	const reco::CandidatePtrVector &	src1,
		const reco::CandidatePtrVector &	src2,
		const reco::CandidatePtrVector &	src3,
		string_coll const &	names
	)		const

return all selected candidate pairs

Definition at line 151 of file NamedCandCombinerBase.cc.

References combine(), and alcazmumu_cfi::src.

                                                                                                             {
  vector<CandidatePtrVector> src;
  src.push_back(src1);
  src.push_back(src2);
  src.push_back(src3);
  return combine(src, names);
}

unique_ptr< NamedCompositeCandidateCollection > NamedCandCombinerBase::combine	(	const reco::CandidatePtrVector &	src1,
		const reco::CandidatePtrVector &	src2,
		const reco::CandidatePtrVector &	src3,
		const reco::CandidatePtrVector &	src4,
		string_coll const &	names
	)		const

return all selected candidate pairs

Definition at line 162 of file NamedCandCombinerBase.cc.

References combine(), and alcazmumu_cfi::src.

                                                                                                             {
  vector<CandidatePtrVector> src;
  src.push_back(src1);
  src.push_back(src2);
  src.push_back(src3);
  src.push_back(src4);
  return combine(src, names);
}

void NamedCandCombinerBase::combine ( reco::NamedCompositeCandidate &  cmp, const reco::CandidatePtr &  c1, const reco::CandidatePtr &  c2, std::string  n1, std::string  n2  ) const

private

returns a composite candidate combined from two daughters

Definition at line 50 of file NamedCandCombinerBase.cc.

References addDaughter(), and setup().

                                                        {
  addDaughter(cmp, c1, n1);
  addDaughter(cmp, c2, n2);
  setup(cmp);
}

void NamedCandCombinerBase::combine ( size_t  collectionIndex, CandStack &  stack, ChargeStack &  qStack, string_coll const &  names, std::vector< reco::CandidatePtrVector >::const_iterator  begin, std::vector< reco::CandidatePtrVector >::const_iterator  end, std::unique_ptr< reco::NamedCompositeCandidateCollection > &  comps  ) const

private

returns a composite candidate combined from two daughters

Definition at line 175 of file NamedCandCombinerBase.cc.

References addDaughter(), cms::cuda::assert(), c, reco::Candidate::charge(), checkCharge_, checkOverlap_, combine(), dauCharge_, mps_fire::i, cuy::ii, overlap_, submitPVResolutionJobs::q, select(), setup(), edm::PtrVectorBase::size(), and alcazmumu_cfi::src.

                                                                                                {
  if (collBegin == collEnd) {
    static const int undetermined = 0, sameDecay = 1, conjDecay = -1, wrongDecay = 2;
    int decayType = undetermined;
    if (checkCharge_) {
      assert(qStack.size() == stack.size());
      for (size_t i = 0; i < qStack.size(); ++i) {
        int q = qStack[i], dq = dauCharge_[i];
        if (decayType == undetermined) {
          if (q != 0 && dq != 0) {
            if (q == dq)
              decayType = sameDecay;
            else if (q == -dq)
              decayType = conjDecay;
            else
              decayType = wrongDecay;
          }
        } else if ((decayType == sameDecay && q != dq) || (decayType == conjDecay && q != -dq)) {
          decayType = wrongDecay;
        }
        if (decayType == wrongDecay)
          break;
      }
    }
    if (decayType != wrongDecay) {
      NamedCompositeCandidate c;
      int ii = 0;
      for (CandStack::const_iterator i = stack.begin(); i != stack.end(); ++i, ++ii) {
        addDaughter(c, i->first.first, names[ii]);
      }
      setup(c);
      if (select(c))
        comps->push_back(c);
    }
  } else {
    const CandidatePtrVector& src = *collBegin;
    size_t candBegin = 0, candEnd = src.size();
    for (CandStack::const_iterator i = stack.begin(); i != stack.end(); ++i)
      if (src == *i->second)
        candBegin = i->first.second + 1;
    for (size_t candIndex = candBegin; candIndex != candEnd; ++candIndex) {
      const CandidatePtr& candPtr(src[candIndex]);

      bool noOverlap = true;
      const Candidate& cand = *candPtr;
      for (CandStack::const_iterator i = stack.begin(); i != stack.end(); ++i)
        if (checkOverlap_ && overlap_(cand, *(i->first.first))) {
          noOverlap = false;
          break;
        }
      if (noOverlap) {
        stack.push_back(make_pair(make_pair(candPtr, candIndex), collBegin));
        if (checkCharge_)
          qStack.push_back(cand.charge());
        combine(collectionIndex + 1, stack, qStack, names, collBegin + 1, collEnd, comps);
        stack.pop_back();
        qStack.pop_back();
      }
    }
  }
}

bool NamedCandCombinerBase::preselect ( const reco::Candidate &  c1, const reco::Candidate &  c2  ) const

private

verify that the two candidate don't overlap and check charge

Definition at line 38 of file NamedCandCombinerBase.cc.

References reco::Candidate::charge(), checkCharge_, checkOverlap_, dauCharge_, overlap_, and selectPair().

Referenced by combine().

                                                                                    {
  if (checkCharge_) {
    int dq1 = dauCharge_[0], dq2 = dauCharge_[1], q1 = c1.charge(), q2 = c2.charge();
    bool matchCharge = (q1 == dq1 && q2 == dq2) || (q1 == -dq1 && q2 == -dq2);
    if (!matchCharge)
      return false;
  }
  if (checkOverlap_ && overlap_(c1, c2))
    return false;
  return selectPair(c1, c2);
}

virtual bool NamedCandCombinerBase::select ( const reco::Candidate &  ) const

privatepure virtual

select a candidate

Referenced by combine().

virtual bool NamedCandCombinerBase::selectPair ( const reco::Candidate &  c1, const reco::Candidate &  c2  ) const

privatepure virtual

select a candidate pair

Referenced by preselect().

virtual void NamedCandCombinerBase::setup ( reco::NamedCompositeCandidate &  ) const

privatepure virtual

set kinematics to reconstructed composite

Referenced by combine(), and o2olib.O2OTool::execute().

Member Data Documentation

bool NamedCandCombinerBase::checkCharge_

private

flag to specify the checking of electric charge

Definition at line 81 of file NamedCandCombinerBase.h.

Referenced by combine(), and preselect().

bool NamedCandCombinerBase::checkOverlap_

private

flag to specify the checking of overlaps

Definition at line 83 of file NamedCandCombinerBase.h.

Referenced by combine(), and preselect().

std::vector<int> NamedCandCombinerBase::dauCharge_

private

electric charges of the daughters

Definition at line 85 of file NamedCandCombinerBase.h.

Referenced by combine(), NamedCandCombinerBase(), and preselect().

std::string NamedCandCombinerBase::name_

private

Name.

Definition at line 89 of file NamedCandCombinerBase.h.

OverlapChecker NamedCandCombinerBase::overlap_

private

utility to check candidate daughters overlap

Definition at line 87 of file NamedCandCombinerBase.h.

Referenced by combine(), and preselect().