TTStub.h

Go to the documentation of this file.

 
#ifndef L1_TRACK_TRIGGER_STUB_FORMAT_H
#define L1_TRACK_TRIGGER_STUB_FORMAT_H
 
#include "DataFormats/GeometryVector/interface/GlobalVector.h"
#include "DataFormats/L1TrackTrigger/interface/TTCluster.h"
#include "DataFormats/Common/interface/DetSetVectorNew.h"
 
template <typename T>
class TTStub {
public:
  TTStub();
  TTStub(DetId aDetId);
 
  ~TTStub();
 
 
 
  const edm::Ref<edmNew::DetSetVector<TTCluster<T> >, TTCluster<T> >& clusterRef(unsigned int hitStackMember) const;
 
  void addClusterRef(edm::Ref<edmNew::DetSetVector<TTCluster<T> >, TTCluster<T> > aTTCluster);
 
  DetId getDetId() const { return theDetId; }
  void setDetId(DetId aDetId) { theDetId = aDetId; }
 
 
  double rawBend() const;
 
  void setRawBend(int aDisplacement);
 
 
  double bendOffset() const;
 
  void setBendOffset(int anOffset);
 
  void setModuleTypePS(bool isPSModule);
 
  bool moduleTypePS() const;
 
 
  double innerClusterPosition() const;
 
  double bendFE() const;
 
  double bendBE() const;
 
  void setBendBE(float aBend);
 
  std::string print(unsigned int i = 0) const;
 
private:
  DetId theDetId;
  edm::Ref<edmNew::DetSetVector<TTCluster<T> >, TTCluster<T> > theClusterRef0;
  edm::Ref<edmNew::DetSetVector<TTCluster<T> >, TTCluster<T> > theClusterRef1;
  int theDisplacement;
  int theOffset;
  float theBendBE;
  bool thePSModule;
 
  static constexpr float dummyBend = 999999;  // Dumy value should be away from potential bends
};                                            
 
template <typename T>
TTStub<T>::TTStub() {
  theDetId = 0;
  theDisplacement = dummyBend;
  theOffset = 0;
  theBendBE = dummyBend;
}
 
template <typename T>
TTStub<T>::TTStub(DetId aDetId) {
  this->setDetId(aDetId);
 
  theDisplacement = dummyBend;
  theOffset = 0;
  theBendBE = dummyBend;
}
 
template <typename T>
TTStub<T>::~TTStub() {}
 
template <typename T>
const edm::Ref<edmNew::DetSetVector<TTCluster<T> >, TTCluster<T> >& TTStub<T>::clusterRef(
    unsigned int hitStackMember) const {
  return (hitStackMember == 0) ? theClusterRef0 : theClusterRef1;
}
 
template <typename T>
void TTStub<T>::addClusterRef(edm::Ref<edmNew::DetSetVector<TTCluster<T> >, TTCluster<T> > aTTCluster) {
  if (aTTCluster->getStackMember() == 0)
    theClusterRef0 = aTTCluster;
  else if (aTTCluster->getStackMember() == 1)
    theClusterRef1 = aTTCluster;
}
 
template <typename T>
double TTStub<T>::rawBend() const {
  return 0.5 * theDisplacement;
}
 
template <typename T>
void TTStub<T>::setRawBend(int aDisplacement) {
  theDisplacement = aDisplacement;
}
 
template <typename T>
double TTStub<T>::bendOffset() const {
  return 0.5 * theOffset;
}
 
template <typename T>
void TTStub<T>::setBendOffset(int anOffset) {
  theOffset = anOffset;
}
 
template <typename T>
void TTStub<T>::setBendBE(float aBend) {
  theBendBE = aBend;
}
 
template <typename T>
void TTStub<T>::setModuleTypePS(bool isPSModule) {
  thePSModule = isPSModule;
}  // set whether this is a PS module or not;
template <typename T>
bool TTStub<T>::moduleTypePS() const {
  return thePSModule;
}  // check if a PS module
template <typename T>
double TTStub<T>::innerClusterPosition() const {
  return this->clusterRef(0)->findAverageLocalCoordinates().x();  //CBC3-style trigger info
}
 
template <typename T>
double TTStub<T>::bendFE() const {
  if (theDisplacement == dummyBend)
    return theDisplacement;
 
  return 0.5 * (theDisplacement - theOffset);
}
 
template <typename T>
double TTStub<T>::bendBE() const {
  if (theBendBE == dummyBend)
    return this->bendFE();  // If not set make it transparent
 
  return theBendBE;
}
 
template <typename T>
std::string TTStub<T>::print(unsigned int i) const {
  std::string padding("");
  for (unsigned int j = 0; j != i; ++j) {
    padding += "\t";
  }
 
  std::stringstream output;
  output << padding << "TTStub:\n";
  padding += '\t';
  output << padding << "DetId: " << theDetId.rawId() << ", position: " << this->InnerClusterPosition();
  output << ", bend: " << this->BendFE() << '\n';
  output << ", hardware bend: " << this->BendBE() << '\n';
  output << padding << "cluster 0: address: " << theClusterRef0.get();
  output << ", cluster size: " << theClusterRef0->getHits().size() << '\n';
  output << padding << "cluster 1: address: " << theClusterRef1.get();
  output << ", cluster size: " << theClusterRef1->getHits().size() << '\n';
  return output.str();
}
 
template <typename T>
std::ostream& operator<<(std::ostream& os, const TTStub<T>& aTTStub) {
  return (os << aTTStub.print());
}
 
#endif