SimTrackManager.h

Go to the documentation of this file.

#ifndef Notification_SimTrackManager_h
#define Notification_SimTrackManager_h
// -*- C++ -*-
//
// Package:     Notification
// Class  :     SimTrackManager
//
//
// Original Author:
//         Created:  Fri Nov 25 17:36:41 EST 2005
//

// system include files
#include <map>
#include <vector>

// user include files
#include "SimG4Core/Notification/interface/TrackWithHistory.h"
#include "SimG4Core/Notification/interface/TrackContainer.h"

#include "SimDataFormats/Forward/interface/LHCTransportLinkContainer.h"

// forward declarations

class G4SimEvent;

class SimTrackManager {
public:
  class StrictWeakOrdering {
  public:
    bool operator()(TrackWithHistory*& p, const unsigned int& i) const { return p->trackID() < i; }
  };
  //      enum SpecialNumbers {InvalidID = 65535};
  typedef std::pair<int, math::XYZVectorD> MapVertexPosition;
  typedef std::vector<std::pair<int, math::XYZVectorD> > MapVertexPositionVector;
  typedef std::map<int, MapVertexPositionVector> MotherParticleToVertexMap;
  typedef MotherParticleToVertexMap VertexMap;

  SimTrackManager(bool iCollapsePrimaryVertices = false);
  virtual ~SimTrackManager();

  // ---------- const member functions ---------------------
  const TrackContainer* trackContainer() const { return m_trksForThisEvent; }

  // ---------- member functions ---------------------------
  void storeTracks(G4SimEvent* simEvent);

  void reset();
  void deleteTracks();
  void cleanTkCaloStateInfoMap();

  void cleanTracksWithHistory();

  void addTrack(TrackWithHistory* iTrack, bool inHistory, bool withAncestor) {
    std::pair<int, int> thePair(iTrack->trackID(), iTrack->parentID());
    idsave.push_back(thePair);
    if (inHistory) {
      m_trksForThisEvent->push_back(iTrack);
    }
    if (withAncestor) {
      std::pair<int, int> thisPair(iTrack->trackID(), 0);
      ancestorList.push_back(thisPair);
    }
  }

  void addTkCaloStateInfo(uint32_t t, const std::pair<math::XYZVectorD, math::XYZTLorentzVectorD>& p) {
    std::map<uint32_t, std::pair<math::XYZVectorD, math::XYZTLorentzVectorD> >::const_iterator it =
        mapTkCaloStateInfo.find(t);

    if (it == mapTkCaloStateInfo.end()) {
      mapTkCaloStateInfo.insert(std::pair<uint32_t, std::pair<math::XYZVectorD, math::XYZTLorentzVectorD> >(t, p));
    }
  }
  void setCollapsePrimaryVertices(bool iSet) { m_collapsePrimaryVertices = iSet; }
  int giveMotherNeeded(int i) const {
    int theResult = 0;
    for (unsigned int itr = 0; itr < idsave.size(); itr++) {
      if ((idsave[itr]).first == i) {
        theResult = (idsave[itr]).second;
        break;
      }
    }
    return theResult;
  }
  bool trackExists(unsigned int i) const {
    bool flag = false;
    for (unsigned int itr = 0; itr < (*m_trksForThisEvent).size(); ++itr) {
      if ((*m_trksForThisEvent)[itr]->trackID() == i) {
        flag = true;
        break;
      }
    }
    return flag;
  }
  void setLHCTransportLink(const edm::LHCTransportLinkContainer* thisLHCTlink) { theLHCTlink = thisLHCTlink; }

private:
  // stop default
  SimTrackManager(const SimTrackManager&) = delete;
  const SimTrackManager& operator=(const SimTrackManager&) = delete;

  void saveTrackAndItsBranch(TrackWithHistory*);
  int getOrCreateVertex(TrackWithHistory*, int, G4SimEvent* simEvent);
  void cleanVertexMap();
  void reallyStoreTracks(G4SimEvent* simEvent);
  void fillMotherList();
  int idSavedTrack(int) const;

  // to restore the pre-LHC Transport GenParticle id link to a SimTrack
  void resetGenID();

  // ---------- member data --------------------------------
  TrackContainer* m_trksForThisEvent;
  bool m_SaveSimTracks;
  MotherParticleToVertexMap m_vertexMap;
  int m_nVertices;
  bool m_collapsePrimaryVertices;
  std::map<uint32_t, std::pair<math::XYZVectorD, math::XYZTLorentzVectorD> > mapTkCaloStateInfo;
  std::vector<std::pair<int, int> > idsave;

  std::vector<std::pair<int, int> > ancestorList;

  unsigned int lastTrack;
  unsigned int lastHist;

  const edm::LHCTransportLinkContainer* theLHCTlink;
};

class trkIDLess {
public:
  bool operator()(TrackWithHistory* trk1, TrackWithHistory* trk2) const { return (trk1->trackID() < trk2->trackID()); }
};

#endif