CentralityProjection.hh

// -*- C++ -*-
#ifndef RIVET_CENTRALITYPROJECTION_HH
#define RIVET_CENTRALITYPROJECTION_HH
 
#include "Rivet/Projections/PercentileProjection.hh"
#include "Rivet/Tools/RivetYODA.hh"
#include <map>
 
namespace Rivet {
 
class CentralityProjection: public SingleValueProjection {
public:
 
  CentralityProjection() { setName("CentralityProjection"); }
 
 
  DEFAULT_RIVET_PROJ_CLONE(CentralityProjection);
 
 
  void add(const SingleValueProjection & p, string pname) {
    _projNames.push_back(pname);
    declare(p, pname);
  }
 
  void project(const Event& e) {
    _values.clear();
    for ( string pname : _projNames )
      _values.push_back(apply<SingleValueProjection>(e, pname)());
    if ( !_values.empty() ) set(_values[0]);
  }
 
  bool empty() const {
    return _projNames.empty();
  }
 
  double operator[](int i) const {
    return _values[i];
  }
 
  // Standard comparison function.
  CmpState compare(const Projection& p) const {
    const CentralityProjection* other = dynamic_cast<const CentralityProjection*>(&p);
    if (other->_projNames.size() == 0) return CmpState::NEQ;
    // cholm: This is not enough.  The contained projections may be
    // different but have the same names.  We need to compare the
    // projections directly.
    for (string pname : _projNames) {
      auto& proj = getProjection(pname);
      bool hasPname = true;
      for (string p2name : other->_projNames){
        if (pname != p2name) hasPname = false;
      }
      if (!hasPname) return CmpState::NEQ;
 
      auto& oth = other->getProjection(pname);
      if (proj.compare(oth) != CmpState::EQ) return CmpState::NEQ;
    }
    return CmpState::EQ;
  }
 
  vector<string> projections() const {
    return _projNames;
  }
 
private:
 
  vector<string> _projNames;
 
  vector<double> _values;
 
};
 
}
 
#endif