Selector

#include <fjcore.hh>

Collaboration diagram for Selector:

Classes
class	InvalidArea
class	InvalidWorker

Public Member Functions
	Selector ()
	Selector (SelectorWorker *worker_in)
virtual	~Selector ()
bool	pass (const PseudoJet &jet) const
bool	operator() (const PseudoJet &jet) const
unsigned int	count (const std::vector< PseudoJet > &jets) const
PseudoJet	sum (const std::vector< PseudoJet > &jets) const
double	scalar_pt_sum (const std::vector< PseudoJet > &jets) const
void	sift (const std::vector< PseudoJet > &jets, std::vector< PseudoJet > &jets_that_pass, std::vector< PseudoJet > &jets_that_fail) const
bool	applies_jet_by_jet () const
std::vector< PseudoJet >	operator() (const std::vector< PseudoJet > &jets) const
virtual void	nullify_non_selected (std::vector< const PseudoJet * > &jets) const
void	get_rapidity_extent (double &rapmin, double &rapmax) const
std::string	description () const
bool	is_geometric () const
bool	has_finite_area () const
const SharedPtr< SelectorWorker > &	worker () const
const SelectorWorker *	validated_worker () const
bool	takes_reference () const
const Selector &	set_reference (const PseudoJet &reference)
Selector &	operator&= (const Selector &b)
Selector &	operator|= (const Selector &b)

Protected Member Functions
void	_copy_worker_if_needed ()

Private Attributes
SharedPtr< SelectorWorker >	_worker

Constructor & Destructor Documentation

Selector() [1/2]

Selector ( )

inline

{}

Selector() [2/2]

Selector ( SelectorWorker *  worker_in )

inline

{_worker.reset(worker_in);}

~Selector()

virtual ~Selector ( )

inlinevirtual

{}

Member Function Documentation

_copy_worker_if_needed()

void _copy_worker_if_needed ( )

inlineprotected

                               {
    if (_worker.unique()) return;
    _worker.reset(_worker->copy());
  }

applies_jet_by_jet()

bool applies_jet_by_jet ( ) const

inline

                                  {
    return validated_worker()->applies_jet_by_jet();
  }

count()

unsigned int count

(

const std::vector< PseudoJet > &

jets

)

const

                                                                    {
  unsigned n = 0;
  const SelectorWorker * worker_local = validated_worker();
  if (worker_local->applies_jet_by_jet()) {
    for (unsigned i = 0; i < jets.size(); i++) {
      if (worker_local->pass(jets[i])) n++;
    }
  } else {
    std::vector<const PseudoJet *> jetptrs(jets.size());
    for (unsigned i = 0; i < jets.size(); i++) {
      jetptrs[i] = & jets[i];
    }
    worker_local->terminator(jetptrs);
    for (unsigned i = 0; i < jetptrs.size(); i++) {
      if (jetptrs[i]) n++;
    }
  }
  return n;
}

description()

std::string description ( ) const

inline

                                {
    return validated_worker()->description();
  }

get_rapidity_extent()

void get_rapidity_extent ( double &  rapmin, double &  rapmax  ) const

inline

                                                                 {
    return validated_worker()->get_rapidity_extent(rapmin, rapmax);
  }

has_finite_area()

bool has_finite_area ( ) const

inline

                              {
    return validated_worker()->has_finite_area();
  }

is_geometric()

bool is_geometric ( ) const

inline

                           {
    return validated_worker()->is_geometric();
  }

nullify_non_selected()

virtual void nullify_non_selected ( std::vector< const PseudoJet * > &  jets ) const

inlinevirtual

                                                                               {
    validated_worker()->terminator(jets);
  }

operator&=()

Selector & operator&=

(

const Selector &

b

)

                                                  {
  _worker.reset(new SW_And(*this, b));
  return *this;
}

operator()() [1/2]

bool operator() ( const PseudoJet &  jet ) const

inline

                                               {
    return pass(jet);
  }

operator()() [2/2]

FJCORE_BEGIN_NAMESPACE std::vector< PseudoJet > operator()

(

const std::vector< PseudoJet > &

jets

)

const

                                                                                 {
  std::vector<PseudoJet> result;
  const SelectorWorker * worker_local = validated_worker();
  if (worker_local->applies_jet_by_jet()) {
    for (std::vector<PseudoJet>::const_iterator jet = jets.begin();
         jet != jets.end(); jet++) {
      if (worker_local->pass(*jet)) result.push_back(*jet);
    }
  } else {
    std::vector<const PseudoJet *> jetptrs(jets.size());
    for (unsigned i = 0; i < jets.size(); i++) {
      jetptrs[i] = & jets[i];
    }
    worker_local->terminator(jetptrs);
    for (unsigned i = 0; i < jetptrs.size(); i++) {
      if (jetptrs[i]) result.push_back(jets[i]);
    }
  }
  return result;
}

operator|=()

Selector & operator|=

(

const Selector &

b

)

                                                  {
  _worker.reset(new SW_Or(*this, b));
  return *this;
}

pass()

bool pass ( const PseudoJet &  jet ) const

inline

                                         {
    if (!validated_worker()->applies_jet_by_jet()) {
      throw Error("Cannot apply this selector to an individual jet");
    }
    return _worker->pass(jet);
  }

scalar_pt_sum()

double scalar_pt_sum

(

const std::vector< PseudoJet > &

jets

)

const

                                                                      {
  double this_sum = 0.0;
  const SelectorWorker * worker_local = validated_worker();
  if (worker_local->applies_jet_by_jet()) {
    for (unsigned i = 0; i < jets.size(); i++) {
      if (worker_local->pass(jets[i])) this_sum += jets[i].pt();
    }
  } else {
    std::vector<const PseudoJet *> jetptrs(jets.size());
    for (unsigned i = 0; i < jets.size(); i++) {
      jetptrs[i] = & jets[i];
    }
    worker_local->terminator(jetptrs);
    for (unsigned i = 0; i < jetptrs.size(); i++) {
      if (jetptrs[i]) this_sum += jets[i].pt();
    }
  }
  return this_sum;
}

set_reference()

const Selector& set_reference ( const PseudoJet &  reference )

inline

                                                            {
    if (! validated_worker()->takes_reference()){
      return *this;
    }
    _copy_worker_if_needed();
    _worker->set_reference(reference);
    return *this;
  }

sift()

void sift	(	const std::vector< PseudoJet > &	jets,
		std::vector< PseudoJet > &	jets_that_pass,
		std::vector< PseudoJet > &	jets_that_fail
	)		const

                    {
  const SelectorWorker * worker_local = validated_worker();
  jets_that_pass.clear();
  jets_that_fail.clear();
  if (worker_local->applies_jet_by_jet()) {
    for (unsigned i = 0; i < jets.size(); i++) {
      if (worker_local->pass(jets[i])) {
    jets_that_pass.push_back(jets[i]);
      } else {
    jets_that_fail.push_back(jets[i]);
      }
    }
  } else {
    std::vector<const PseudoJet *> jetptrs(jets.size());
    for (unsigned i = 0; i < jets.size(); i++) {
      jetptrs[i] = & jets[i];
    }
    worker_local->terminator(jetptrs);
    for (unsigned i = 0; i < jetptrs.size(); i++) {
      if (jetptrs[i]) {
    jets_that_pass.push_back(jets[i]);
      } else {
    jets_that_fail.push_back(jets[i]);
      }
    }
  }
}

sum()

PseudoJet sum

(

const std::vector< PseudoJet > &

jets

)

const

                                                               {
  PseudoJet this_sum(0,0,0,0);
  const SelectorWorker * worker_local = validated_worker();
  if (worker_local->applies_jet_by_jet()) {
    for (unsigned i = 0; i < jets.size(); i++) {
      if (worker_local->pass(jets[i])) this_sum += jets[i];
    }
  } else {
    std::vector<const PseudoJet *> jetptrs(jets.size());
    for (unsigned i = 0; i < jets.size(); i++) {
      jetptrs[i] = & jets[i];
    }
    worker_local->terminator(jetptrs);
    for (unsigned i = 0; i < jetptrs.size(); i++) {
      if (jetptrs[i]) this_sum += jets[i];
    }
  }
  return this_sum;
}

takes_reference()

bool takes_reference ( ) const

inline

                               {
    return validated_worker()->takes_reference();
  }

validated_worker()

const SelectorWorker* validated_worker ( ) const

inline

                                                 {
    const SelectorWorker* worker_ptr = _worker.get();
    if (worker_ptr == 0) throw InvalidWorker();
    return worker_ptr;
  }

worker()

const SharedPtr<SelectorWorker>& worker ( ) const

inline

{return _worker;}

Member Data Documentation

_worker

SharedPtr<SelectorWorker> _worker

private

the underlying worker

---

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

• /builds/cms-analysis/general/DasAnalysisSystem/Core/Installer/Core/JetObservables/interface/fjcore.hh
• /builds/cms-analysis/general/DasAnalysisSystem/Core/Installer/Core/JetObservables/src/fjcore.cc