#include <SUSYBSMAnalysis/HSCParticleProducer/interface/HSCParticleProducer.h>

Inheritance diagram for HSCParticleProducer:

Public Member Functions
	HSCParticleProducer (const edm::ParameterSet &)

	~HSCParticleProducer ()

Public Member Functions inherited from edm::EDFilter
	EDFilter ()

ModuleDescription const &	moduleDescription () const

virtual	~EDFilter ()

Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Member Functions
virtual void	beginJob ()

virtual void	endJob ()

virtual bool	filter (edm::Event &, const edm::EventSetup &)

std::vector< susybsm::HSCParticle >	getHSCPSeedCollection (edm::Handle< reco::TrackCollection > &trackCollectionHandle, edm::Handle< reco::MuonCollection > &muonCollectionHandle, edm::Handle< reco::MuonCollection > &MTmuonCollectionHandle)

Private Attributes
BetaCalculatorECAL *	beta_calculator_ECAL

BetaCalculatorMUON *	beta_calculator_MUON

BetaCalculatorRPC *	beta_calculator_RPC

BetaCalculatorTK *	beta_calculator_TK

bool	Filter_

edm::EDGetTokenT < reco::MuonCollection >	m_MTmuonsToken

edm::EDGetTokenT < reco::MuonCollection >	m_muonsToken

edm::EDGetTokenT < reco::TrackCollection >	m_trackIsoToken

edm::EDGetTokenT < reco::TrackCollection >	m_trackToken

float	maxInvPtDiff

float	maxTkChi2

float	minDR

float	minMTDR

float	minMTMuPt

float	minMuP

float	minSAMuPt

unsigned int	minTkHits

float	minTkP

std::vector< CandidateSelector * >	Selectors

bool	useBetaFromEcal

bool	useBetaFromMuon

bool	useBetaFromRpc

bool	useBetaFromTk

Additional Inherited Members
Public Types inherited from edm::EDFilter
typedef EDFilter	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Static Public Member Functions inherited from edm::EDFilter
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

Protected Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Description: Producer for HSCP candidates, merging tracker dt information and rpc information

Implementation: <Notes on="" implementation>="">

Definition at line 54 of file HSCParticleProducer.h.

Constructor & Destructor Documentation

HSCParticleProducer::HSCParticleProducer ( const edm::ParameterSet & iConfig )

explicit

Definition at line 25 of file HSCParticleProducer.cc.

References edm::ParameterSet::getParameter(), i, and HLT_25ns14e33_v1_cff::minDR.

                                                                        {
   using namespace edm;
   using namespace std;
 
   // the Act as Event filter
    Filter_        = iConfig.getParameter<bool>          ("filter");
 
   // the input collections
   m_trackToken      = consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("tracks"));
   m_muonsToken      = consumes<reco::MuonCollection>(iConfig.getParameter<edm::InputTag>("muons"));
   m_MTmuonsToken    = consumes<reco::MuonCollection>(iConfig.getParameter<edm::InputTag>("MTmuons"));
   m_trackIsoToken   = consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("tracksIsolation"));
 
   useBetaFromTk   = iConfig.getParameter<bool>    ("useBetaFromTk"  );
   useBetaFromMuon = iConfig.getParameter<bool>    ("useBetaFromMuon");
   useBetaFromRpc  = iConfig.getParameter<bool>    ("useBetaFromRpc" );
   useBetaFromEcal = iConfig.getParameter<bool>    ("useBetaFromEcal");
 
   // the parameters
   minTkP          = iConfig.getParameter<double>  ("minTkP");       // 30
   maxTkChi2       = iConfig.getParameter<double>  ("maxTkChi2");    // 5
   minTkHits       = iConfig.getParameter<uint32_t>("minTkHits");    // 9
   minMuP          = iConfig.getParameter<double>  ("minMuP");       // 30
   minDR           = iConfig.getParameter<double>  ("minDR");        // 0.1
   minSAMuPt       = iConfig.getParameter<double>  ("minSAMuPt");    // 70
   minMTMuPt       = iConfig.getParameter<double>  ("minMTMuPt");    // 70
   minMTDR         = iConfig.getParameter<double>  ("minMTDR");        // 0.3
   maxInvPtDiff    = iConfig.getParameter<double>  ("maxInvPtDiff"); // 0.005
 
   if(useBetaFromTk  )beta_calculator_TK   = new BetaCalculatorTK  (iConfig, consumesCollector());
   if(useBetaFromMuon)beta_calculator_MUON = new BetaCalculatorMUON(iConfig, consumesCollector());
   if(useBetaFromRpc )beta_calculator_RPC  = new BetaCalculatorRPC (iConfig, consumesCollector());
   if(useBetaFromEcal)beta_calculator_ECAL = new BetaCalculatorECAL(iConfig, consumesCollector());
 
   // Load all the selections
   std::vector<edm::ParameterSet> SelectionParameters = iConfig.getParameter<std::vector<edm::ParameterSet> >("SelectionParameters");
   for(unsigned int i=0;i<SelectionParameters.size();i++){
      Selectors.push_back(new CandidateSelector(SelectionParameters[i]) );
   }
 
   // what I produce
   produces<susybsm::HSCParticleCollection >();
   if(useBetaFromEcal)produces<susybsm::HSCPCaloInfoCollection >();
 
 }

HSCParticleProducer::~HSCParticleProducer ( )

Definition at line 71 of file HSCParticleProducer.cc.

                                           {
    // do anything here that needs to be done at desctruction time
    // (e.g. close files, deallocate resources etc.)
 }

Member Function Documentation

void HSCParticleProducer::beginJob ( void )

privatevirtual

Reimplemented from edm::EDFilter.

Definition at line 201 of file HSCParticleProducer.cc.

201 {

202 }

void HSCParticleProducer::endJob ( void )

privatevirtual

Reimplemented from edm::EDFilter.

Definition at line 206 of file HSCParticleProducer.cc.

206 {

207 }

bool HSCParticleProducer::filter	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

privatevirtual

Implements edm::EDFilter.

Definition at line 82 of file HSCParticleProducer.cc.

References deltaR(), PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, HLT_25ns14e33_v1_cff::dRMin, newFWLiteAna::found, edm::Event::getByToken(), i, edm::Ref< C, T, F >::isNull(), HLT_25ns14e33_v1_cff::minDR, edm::Event::put(), dt_dqm_sourceclient_common_cff::reco, query::result, alignCSCRings::s, and edmStreamStallGrapher::t.

                                                                          {
 
   using namespace edm;
   using namespace reco;
   using namespace std;
   using namespace susybsm;
 
   // information from the muons
   edm::Handle<reco::MuonCollection> muonCollectionHandle;
   iEvent.getByToken(m_muonsToken,muonCollectionHandle);
 
   //information from the mean timer muons
   edm::Handle<reco::MuonCollection> MTmuonCollectionHandle;
   iEvent.getByToken(m_MTmuonsToken,MTmuonCollectionHandle);
 
   // information from the tracks
   edm::Handle<reco::TrackCollection> trackCollectionHandle;
   iEvent.getByToken(m_trackToken,trackCollectionHandle);
 
   // information from the tracks iso
   edm::Handle<reco::TrackCollection> trackIsoCollectionHandle;
   iEvent.getByToken(m_trackIsoToken,trackIsoCollectionHandle);
 
 
   // creates the output collection
   susybsm::HSCParticleCollection* hscp = new susybsm::HSCParticleCollection;
   std::auto_ptr<susybsm::HSCParticleCollection> result(hscp);
 
   susybsm::HSCPCaloInfoCollection* caloInfoColl = new susybsm::HSCPCaloInfoCollection;
   std::auto_ptr<susybsm::HSCPCaloInfoCollection> caloInfoCollaptr(caloInfoColl);
 
 
   // Fill the output collection with HSCP Candidate (the candiate only contains ref to muon AND/OR track object)
   *hscp = getHSCPSeedCollection(trackCollectionHandle, muonCollectionHandle, MTmuonCollectionHandle);
 
   // find the track ref for isolation purposed (main track is supposed to be the Iso track after refitting)
   for(susybsm::HSCParticleCollection::iterator hscpcandidate = hscp->begin(); hscpcandidate != hscp->end(); ++hscpcandidate) {
       // Matching is needed because input track collection and muon inner track may lightly differs due to track refit
       reco::TrackRef track  = hscpcandidate->trackRef();
       if(track.isNull())continue;
       float dRMin=1000; int found = -1;
       for(unsigned int t=0; t<trackIsoCollectionHandle->size();t++) {
          reco::TrackRef Isotrack  = reco::TrackRef( trackIsoCollectionHandle, t );
          if( fabs( (1.0/track->pt())-(1.0/Isotrack->pt())) > maxInvPtDiff) continue;
          float dR = deltaR(track->momentum(), Isotrack->momentum());
          if(dR <= minDR && dR < dRMin){ dRMin=dR; found = t;}
       }
       if(found>=0)hscpcandidate->setTrackIso(reco::TrackRef( trackIsoCollectionHandle, found ));
   }
 
   // compute the TRACKER contribution
   if(useBetaFromTk){
   for(susybsm::HSCParticleCollection::iterator hscpcandidate = hscp->begin(); hscpcandidate != hscp->end(); ++hscpcandidate) {
     beta_calculator_TK->addInfoToCandidate(*hscpcandidate,  iEvent,iSetup);
   }}
 
   // compute the MUON contribution
   if(useBetaFromMuon){
   for(susybsm::HSCParticleCollection::iterator hscpcandidate = hscp->begin(); hscpcandidate != hscp->end(); ++hscpcandidate) {
     beta_calculator_MUON->addInfoToCandidate(*hscpcandidate,  iEvent,iSetup);
   }}
 
   // compute the RPC contribution
   if(useBetaFromRpc){
   for(susybsm::HSCParticleCollection::iterator hscpcandidate = hscp->begin(); hscpcandidate != hscp->end(); ++hscpcandidate) {
       beta_calculator_RPC->addInfoToCandidate(*hscpcandidate, iEvent, iSetup);
   }}
 
   // compute the ECAL contribution
   if(useBetaFromEcal){
   int Index=0;
   caloInfoColl->resize(hscp->size());
   for(susybsm::HSCParticleCollection::iterator hscpcandidate = hscp->begin(); hscpcandidate != hscp->end(); ++hscpcandidate, Index++) {
      beta_calculator_ECAL->addInfoToCandidate(*hscpcandidate,trackCollectionHandle,iEvent,iSetup, (*caloInfoColl)[Index]);
   }}
 
   // cleanup the collection based on the input selection
   for(int i=0;i<(int)hscp->size();i++) {
      susybsm::HSCParticleCollection::iterator hscpcandidate = hscp->begin() + i;
      bool decision = false;
      for(unsigned int s=0;s<Selectors.size();s++){decision |= Selectors[s]->isSelected(*hscpcandidate);}
      if(!decision){
         hscp->erase(hscpcandidate);
         if(useBetaFromEcal)caloInfoColl->erase(caloInfoColl->begin() + i);
         i--;
      }
   }
   bool filterResult = !Filter_ || (Filter_ && hscp->size()>=1);
 
 
 
 
   // output result
   if(useBetaFromEcal){
     edm::OrphanHandle<susybsm::HSCPCaloInfoCollection> caloInfoHandle= iEvent.put(caloInfoCollaptr);
     // adding the reftoCaloInfoObject to the HSCP Object
     for(int i=0;i<(int)hscp->size();i++) {
        susybsm::HSCParticleCollection::iterator hscpcandidate = hscp->begin() + i;
        hscpcandidate->setCaloInfo(HSCPCaloInfoRef(caloInfoHandle,i));
     }
   }
 
 
   // output result
 
 
   edm::OrphanHandle<susybsm::HSCParticleCollection> putHandle = iEvent.put(result);
 //  if(useBetaFromEcal){
 //      edm::RefProd<susybsm::HSCParticleCollection> hscpCollectionHandle = iEvent.getRefBeforePut<susybsm::HSCParticleCollection>();
 //    filler.insert(putHandle, CaloInfoColl.begin(), CaloInfoColl.end());
 //    filler.fill();
 //    iEvent.put(CaloInfoMap);
 //  }
 
   return filterResult;
 }

std::vector< HSCParticle > HSCParticleProducer::getHSCPSeedCollection	(	edm::Handle< reco::TrackCollection > &	trackCollectionHandle,
		edm::Handle< reco::MuonCollection > &	muonCollectionHandle,
		edm::Handle< reco::MuonCollection > &	MTmuonCollectionHandle
	)

private

Definition at line 209 of file HSCParticleProducer.cc.

References deltaR(), PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, HLT_25ns14e33_v1_cff::dRMin, newFWLiteAna::found, i, reco::isMuon(), edm::Ref< C, T, F >::isNonnull(), edm::Ref< C, T, F >::isNull(), visualization-live-secondInstance_cfg::m, HLT_25ns14e33_v1_cff::minDR, metsig::muon, susybsm::HSCParticle::setMTMuon(), susybsm::HSCParticle::setMuon(), susybsm::HSCParticle::setTrack(), edmStreamStallGrapher::t, and testEve_cfg::tracks.

 {
    std::vector<HSCParticle> HSCPCollection;
 
    // Store a local vector of track ref (that can be modified if matching)
    std::vector<reco::TrackRef> tracks;
    for(unsigned int i=0; i<trackCollectionHandle->size(); i++){
       TrackRef track = reco::TrackRef( trackCollectionHandle, i );
 
       //If track is from muon always keep it
       bool isMuon=false;
       for(unsigned int m=0; m<muonCollectionHandle->size(); m++){
     reco::MuonRef muon  = reco::MuonRef( muonCollectionHandle, m );
     TrackRef innertrack = muon->innerTrack();
     if(innertrack.isNull())continue;
     if( fabs( (1.0/innertrack->pt())-(1.0/track->pt())) > maxInvPtDiff) continue;
     float dR = deltaR(innertrack->momentum(), track->momentum());
     if(dR <= minDR) isMuon=true;
       }
 
       if((track->p()<minTkP || (track->chi2()/track->ndof())>maxTkChi2 || track->found()<minTkHits) && !isMuon)continue;
       tracks.push_back( track );
    }
 
    // Loop on muons with inner track ref and create Muon HSCP Candidate
    for(unsigned int m=0; m<muonCollectionHandle->size(); m++){
       reco::MuonRef muon  = reco::MuonRef( muonCollectionHandle, m );
       double SApt=-1;
       if(muon->isStandAloneMuon()) SApt=muon->standAloneMuon()->pt();
       if(muon->p()<minMuP && SApt<minSAMuPt)continue;
       TrackRef innertrack = muon->innerTrack();
       if(innertrack.isNull())continue;
 
       // Check if the inner track match any track in order to create a Muon+Track HSCP Candidate
       // Matching is needed because input track collection and muon inner track may lightly differs due to track refit
       float dRMin=1000; int found = -1;
       for(unsigned int t=0; t<tracks.size();t++) {
          reco::TrackRef track  = tracks[t];
          if( fabs( (1.0/innertrack->pt())-(1.0/track->pt())) > maxInvPtDiff) continue;
          float dR = deltaR(innertrack->momentum(), track->momentum());
          if(dR <= minDR && dR < dRMin){ dRMin=dR; found = t;}
       }
 
       HSCParticle candidate;
       candidate.setMuon(muon);
       if(found>=0){
 //        printf("MUON with Inner Track Matching --> DR = %6.2f (%6.2f %+6.2f %+6.2f):(%6.2f %+6.2f %+6.2f) vs (%6.2f %+6.2f %+6.2f)\n",dRMin,muon->pt(), muon->eta(), muon->phi(), innertrack->pt(), innertrack->eta(), innertrack->phi(), tracks[found]->pt(), tracks[found]->eta(), tracks[found]->phi() );
         candidate.setTrack(tracks[found]);
         tracks.erase(tracks.begin()+found);
       }
       HSCPCollection.push_back(candidate);
    }
 
    // Loop on muons without inner tracks and create Muon HSCP Candidate
    for(unsigned int m=0; m<muonCollectionHandle->size(); m++){
       reco::MuonRef muon  = reco::MuonRef( muonCollectionHandle, m );
       double SApt=-1;
       if(muon->isStandAloneMuon()) SApt=muon->standAloneMuon()->pt();
       if(muon->p()<minMuP && SApt<minSAMuPt)continue;
       TrackRef innertrack = muon->innerTrack();
       if(innertrack.isNonnull())continue;
 
       // Check if the muon match any track in order to create a Muon+Track HSCP Candidate
       float dRMin=1000; int found = -1;
       for(unsigned int t=0; t<tracks.size();t++) {
          reco::TrackRef track  = tracks[t];
          if( fabs( (1.0/muon->pt())-(1.0/track->pt())) > maxInvPtDiff) continue;
          float dR = deltaR(muon->momentum(), track->momentum());
          if(dR <= minDR && dR < dRMin){ dRMin=dR; found = t;}
       }
 
       HSCParticle candidate;
       candidate.setMuon(muon);
       if(found>=0){
 //        printf("MUON without Inner Track Matching --> DR = %6.2f (%6.2f %+6.2f %+6.2f) vs (%6.2f %+6.2f %+6.2f)\n",dRMin,muon->pt(), muon->eta(), muon->phi(), tracks[found]->pt(), tracks[found]->eta(), tracks[found]->phi() );
         candidate.setTrack(tracks[found]);
         tracks.erase(tracks.begin()+found);
       }
       HSCPCollection.push_back(candidate);
    }
 
 
    //Loop on MT muons and add to collection
    for(unsigned int m=0; m<MTmuonCollectionHandle->size(); m++){
      reco::MuonRef MTmuon  = reco::MuonRef( MTmuonCollectionHandle, m );
      if(MTmuon->pt()<minMTMuPt )continue;
 
      //Check if matches muon HSCP candidate and add reference
      float dRMin=1000; int found = -1;
      for(unsigned int i=0; i<HSCPCollection.size(); i++) {
        if(!HSCPCollection[i].hasMuonRef()) continue;
        reco::MuonRef muon  = HSCPCollection[i].muonRef();
        float dR = deltaR(muon->momentum(), MTmuon->momentum());
        if(dR <= minMTDR && dR < dRMin){ dRMin=dR; found = i;}
      }
      if(found>-1) HSCPCollection[found].setMTMuon(MTmuon);
      else {
        HSCParticle candidate;
        candidate.setMTMuon(MTmuon);
        HSCPCollection.push_back(candidate);
      }
    }
 
 
    // Loop on tracks not matching muon and create Track HSCP Candidate
    for(unsigned int i=0; i<tracks.size(); i++){
       HSCParticle candidate;
       candidate.setTrack(tracks[i]);
       HSCPCollection.push_back(candidate);
    }
 
    return HSCPCollection;
 }

Member Data Documentation

BetaCalculatorECAL* HSCParticleProducer::beta_calculator_ECAL

private

Definition at line 92 of file HSCParticleProducer.h.

BetaCalculatorMUON* HSCParticleProducer::beta_calculator_MUON

private

Definition at line 90 of file HSCParticleProducer.h.

BetaCalculatorRPC* HSCParticleProducer::beta_calculator_RPC

private

Definition at line 91 of file HSCParticleProducer.h.

BetaCalculatorTK* HSCParticleProducer::beta_calculator_TK

private

Definition at line 89 of file HSCParticleProducer.h.

bool HSCParticleProducer::Filter_

private

Definition at line 67 of file HSCParticleProducer.h.

edm::EDGetTokenT<reco::MuonCollection> HSCParticleProducer::m_MTmuonsToken

private

Definition at line 72 of file HSCParticleProducer.h.

edm::EDGetTokenT<reco::MuonCollection> HSCParticleProducer::m_muonsToken

private

Definition at line 71 of file HSCParticleProducer.h.

edm::EDGetTokenT<reco::TrackCollection> HSCParticleProducer::m_trackIsoToken

private

Definition at line 70 of file HSCParticleProducer.h.

edm::EDGetTokenT<reco::TrackCollection> HSCParticleProducer::m_trackToken

private

Definition at line 69 of file HSCParticleProducer.h.

float HSCParticleProducer::maxInvPtDiff

private

Definition at line 87 of file HSCParticleProducer.h.

float HSCParticleProducer::maxTkChi2

private

Definition at line 80 of file HSCParticleProducer.h.

float HSCParticleProducer::minDR

private

Definition at line 85 of file HSCParticleProducer.h.

float HSCParticleProducer::minMTDR

private

Definition at line 86 of file HSCParticleProducer.h.

float HSCParticleProducer::minMTMuPt

private

Definition at line 84 of file HSCParticleProducer.h.

float HSCParticleProducer::minMuP

private

Definition at line 82 of file HSCParticleProducer.h.

float HSCParticleProducer::minSAMuPt

private

Definition at line 83 of file HSCParticleProducer.h.

unsigned int HSCParticleProducer::minTkHits

private

Definition at line 81 of file HSCParticleProducer.h.

float HSCParticleProducer::minTkP

private

Definition at line 79 of file HSCParticleProducer.h.

std::vector<CandidateSelector*> HSCParticleProducer::Selectors

private

Definition at line 94 of file HSCParticleProducer.h.

bool HSCParticleProducer::useBetaFromEcal

private

Definition at line 77 of file HSCParticleProducer.h.

bool HSCParticleProducer::useBetaFromMuon

private

Definition at line 75 of file HSCParticleProducer.h.

bool HSCParticleProducer::useBetaFromRpc

private

Definition at line 76 of file HSCParticleProducer.h.

bool HSCParticleProducer::useBetaFromTk

private

Definition at line 74 of file HSCParticleProducer.h.

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation