TreeFiller/src/FillerStableParts.cc

// $Id: FillerStableParts.cc,v 1.14 2009/07/12 13:09:55 bendavid Exp $

#include "MitProd/TreeFiller/interface/FillerStableParts.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "DataFormats/Common/interface/RefToPtr.h"
#include "DataFormats/RecoCandidate/interface/TrackAssociation.h"
#include "SimDataFormats/TrackingAnalysis/interface/TrackingParticle.h"
#include "SimDataFormats/TrackingAnalysis/interface/TrackingParticleFwd.h"
#include "MitAna/DataTree/interface/Names.h"
#include "MitAna/DataTree/interface/StableParticleCol.h"
#include "MitEdm/DataFormats/interface/Collections.h"
#include "MitProd/ObjectService/interface/ObjectService.h"

using namespace std;
using namespace edm;
using namespace mithep;

//--------------------------------------------------------------------------------------------------
FillerStableParts::FillerStableParts(const ParameterSet &cfg, const char *name, bool active) :
  BaseFiller(cfg,name,active),
  edmName_(Conf().getUntrackedParameter<string>("edmName","")),
  mitName_(Conf().getUntrackedParameter<string>("mitName","")),
  trackMapNames_(Conf().exists("trackMapNames") ? 
                    Conf().getUntrackedParameter<vector<string> >("trackMapNames") : 
                    vector<string>()),
  basePartMapName_(Conf().getUntrackedParameter<string>("basePartMap",
                                                        Form("%sMapName",mitName_.c_str()))),
  trackPartMapName_(Conf().getUntrackedParameter<string>("trackPartMap",
                                                        Form("%sTrackMapName",mitName_.c_str()))),
  stables_(new mithep::StableParticleArr(250)),
  basePartMap_(new mithep::BasePartMap),
  trackPartMap_(new mithep::TrackPartMap)
{
  // Constructor.
}

//--------------------------------------------------------------------------------------------------
FillerStableParts::~FillerStableParts()
{
  // Destructor.

  delete stables_;
  delete basePartMap_;
  delete trackPartMap_;
}

//--------------------------------------------------------------------------------------------------
void FillerStableParts::BookDataBlock(TreeWriter &tws)
{
  // Add tracks branch to tree, get and publish our maps.

  tws.AddBranch(mitName_,&stables_);
  OS()->add<mithep::StableParticleArr>(stables_,mitName_);

  if (!basePartMapName_.empty()) {
    basePartMap_->SetBrName(mitName_);
    OS()->add(basePartMap_,basePartMapName_);
  }
  if (!trackPartMapName_.empty()) {
    trackPartMap_->SetBrName(mitName_);
    OS()->add(trackPartMap_,trackPartMapName_);
  }

  for (std::vector<std::string>::const_iterator tmapName = trackMapNames_.begin();
        tmapName!=trackMapNames_.end(); ++tmapName) {
    if (!tmapName->empty()) {
      const TrackMap *map = OS()->get<TrackMap>(*tmapName);
      if (map) {
        trackMaps_.push_back(map);
        AddBranchDep(mitName_,map->GetBrName());
      }
    }
  }
}

//--------------------------------------------------------------------------------------------------
void FillerStableParts::FillDataBlock(const edm::Event      &evt, 
                                      const edm::EventSetup &setup)
{
  // Fill our EDM StablePart collection into the MIT StableParticle collection.

  stables_->Delete();
  basePartMap_->Reset();

  Handle<mitedm::StablePartCol> hParts;
  GetProduct(edmName_, hParts, evt);  
  const mitedm::StablePartCol *iParts = hParts.product();
  
  // loop through all StableParts and fill the information
  for (UInt_t i=0; i<iParts->size(); ++i) {
    const mitedm::StablePart &p = iParts->at(i); 
    mitedm::BasePartPtr thePtr(hParts,i);
    mithep::StableParticle *d = stables_->Allocate();
    new (d) mithep::StableParticle(p.pid());
    basePartMap_->Add(thePtr,d);
    trackPartMap_->Add(p.trackPtr(),d);
    if (trackMaps_.size())
      d->SetTrk(GetMitTrack(p.trackPtr()));
  }
  stables_->Trim();
}

//--------------------------------------------------------------------------------------------------
mithep::Track *FillerStableParts::GetMitTrack(const mitedm::TrackPtr &ptr) const
{
  // Return our particle referenced by the edm pointer.

  mithep::Track *mitTrack = 0;
  for (std::vector<const mithep::TrackMap*>::const_iterator tmap = trackMaps_.begin();
        tmap!=trackMaps_.end(); ++tmap) {
    const mithep::TrackMap *theMap = *tmap;
    if (theMap->HasMit(ptr)) {
      mitTrack = theMap->GetMit(ptr);
      return mitTrack;
    }
  }
  
  if (!mitTrack)
    throw edm::Exception(edm::errors::Configuration, "FillerStableParts::FillDataBlock()\n")
    << "Error! MITHEP Object " 
    << "not found in AssociationMaps (" << typeid(*this).name() << ")." << std::endl;
    
  return mitTrack;
}
Revision:	1.15
Committed:	Mon Jul 20 03:19:24 2009 UTC (15 years, 9 months ago) by loizides
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Mit_011, Mit_010a, Mit_010
Changes since 1.14:	+2 -3 lines
Log Message:	Cleanup
#	User	Rev	Content
1	loizides	1.15	// $Id: FillerStableParts.cc,v 1.14 2009/07/12 13:09:55 bendavid Exp $
2	paus	1.1
3	loizides	1.12	#include "MitProd/TreeFiller/interface/FillerStableParts.h"
4	paus	1.1	#include "DataFormats/TrackReco/interface/Track.h"
5			#include "DataFormats/TrackReco/interface/TrackFwd.h"
6	bendavid	1.8	#include "DataFormats/Common/interface/RefToPtr.h"
7	loizides	1.12	#include "DataFormats/RecoCandidate/interface/TrackAssociation.h"
8	paus	1.1	#include "SimDataFormats/TrackingAnalysis/interface/TrackingParticle.h"
9			#include "SimDataFormats/TrackingAnalysis/interface/TrackingParticleFwd.h"
10	loizides	1.12	#include "MitAna/DataTree/interface/Names.h"
11			#include "MitAna/DataTree/interface/StableParticleCol.h"
12	loizides	1.7	#include "MitEdm/DataFormats/interface/Collections.h"
13	loizides	1.12	#include "MitProd/ObjectService/interface/ObjectService.h"
14	paus	1.1
15			using namespace std;
16			using namespace edm;
17			using namespace mithep;
18
19			//--------------------------------------------------------------------------------------------------
20	loizides	1.4	FillerStableParts::FillerStableParts(const ParameterSet &cfg, const char *name, bool active) :
21	paus	1.1	BaseFiller(cfg,name,active),
22	loizides	1.4	edmName_(Conf().getUntrackedParameter<string>("edmName","")),
23			mitName_(Conf().getUntrackedParameter<string>("mitName","")),
24	bendavid	1.14	trackMapNames_(Conf().exists("trackMapNames") ?
25			Conf().getUntrackedParameter<vector<string> >("trackMapNames") :
26			vector<string>()),
27	loizides	1.4	basePartMapName_(Conf().getUntrackedParameter<string>("basePartMap",
28			Form("%sMapName",mitName_.c_str()))),
29	bendavid	1.13	trackPartMapName_(Conf().getUntrackedParameter<string>("trackPartMap",
30	loizides	1.15	Form("%sTrackMapName",mitName_.c_str()))),
31	loizides	1.4	stables_(new mithep::StableParticleArr(250)),
32	bendavid	1.13	basePartMap_(new mithep::BasePartMap),
33			trackPartMap_(new mithep::TrackPartMap)
34	paus	1.1	{
35	loizides	1.4	// Constructor.
36	paus	1.1	}
37
38			//--------------------------------------------------------------------------------------------------
39			FillerStableParts::~FillerStableParts()
40			{
41	loizides	1.4	// Destructor.
42
43	paus	1.1	delete stables_;
44	loizides	1.4	delete basePartMap_;
45	bendavid	1.13	delete trackPartMap_;
46	paus	1.1	}
47
48			//--------------------------------------------------------------------------------------------------
49			void FillerStableParts::BookDataBlock(TreeWriter &tws)
50			{
51	loizides	1.4	// Add tracks branch to tree, get and publish our maps.
52
53	loizides	1.11	tws.AddBranch(mitName_,&stables_);
54			OS()->add<mithep::StableParticleArr>(stables_,mitName_);
55	loizides	1.4
56	loizides	1.11	if (!basePartMapName_.empty()) {
57			basePartMap_->SetBrName(mitName_);
58			OS()->add(basePartMap_,basePartMapName_);
59			}
60	bendavid	1.13	if (!trackPartMapName_.empty()) {
61			trackPartMap_->SetBrName(mitName_);
62			OS()->add(trackPartMap_,trackPartMapName_);
63			}
64	bendavid	1.14
65			for (std::vector<std::string>::const_iterator tmapName = trackMapNames_.begin();
66			tmapName!=trackMapNames_.end(); ++tmapName) {
67			if (!tmapName->empty()) {
68			const TrackMap map = OS()->get<TrackMap>(tmapName);
69			if (map) {
70			trackMaps_.push_back(map);
71			AddBranchDep(mitName_,map->GetBrName());
72			}
73			}
74	loizides	1.11	}
75	paus	1.1	}
76
77			//--------------------------------------------------------------------------------------------------
78			void FillerStableParts::FillDataBlock(const edm::Event &evt,
79			const edm::EventSetup &setup)
80			{
81	loizides	1.4	// Fill our EDM StablePart collection into the MIT StableParticle collection.
82
83	bendavid	1.10	stables_->Delete();
84	loizides	1.4	basePartMap_->Reset();
85
86	bendavid	1.2	Handle<mitedm::StablePartCol> hParts;
87	paus	1.1	GetProduct(edmName_, hParts, evt);
88	bendavid	1.2	const mitedm::StablePartCol *iParts = hParts.product();
89	paus	1.1
90			// loop through all StableParts and fill the information
91	bendavid	1.2	for (UInt_t i=0; i<iParts->size(); ++i) {
92	loizides	1.7	const mitedm::StablePart &p = iParts->at(i);
93	bendavid	1.6	mitedm::BasePartPtr thePtr(hParts,i);
94	bendavid	1.2	mithep::StableParticle *d = stables_->Allocate();
95			new (d) mithep::StableParticle(p.pid());
96	bendavid	1.6	basePartMap_->Add(thePtr,d);
97	bendavid	1.13	trackPartMap_->Add(p.trackPtr(),d);
98	bendavid	1.14	if (trackMaps_.size())
99			d->SetTrk(GetMitTrack(p.trackPtr()));
100	paus	1.1	}
101			stables_->Trim();
102			}
103	bendavid	1.14
104			//--------------------------------------------------------------------------------------------------
105			mithep::Track *FillerStableParts::GetMitTrack(const mitedm::TrackPtr &ptr) const
106			{
107			// Return our particle referenced by the edm pointer.
108
109			mithep::Track *mitTrack = 0;
110			for (std::vector<const mithep::TrackMap*>::const_iterator tmap = trackMaps_.begin();
111			tmap!=trackMaps_.end(); ++tmap) {
112			const mithep::TrackMap theMap = tmap;
113			if (theMap->HasMit(ptr)) {
114			mitTrack = theMap->GetMit(ptr);
115			return mitTrack;
116			}
117			}
118
119			if (!mitTrack)
120			throw edm::Exception(edm::errors::Configuration, "FillerStableParts::FillDataBlock()\n")
121			<< "Error! MITHEP Object "
122			<< "not found in AssociationMaps (" << typeid(*this).name() << ")." << std::endl;
123
124			return mitTrack;
125			}