TreeFiller/src/FillerConversions.cc

// $Id: FillerConversions.cc,v 1.16 2009/06/18 23:07:14 bendavid Exp $

#include "MitProd/TreeFiller/interface/FillerConversions.h"
#include "DataFormats/Common/interface/RefToPtr.h"
#include "MitAna/DataTree/interface/ConversionCol.h"
#include "MitAna/DataTree/interface/Names.h"
#include "MitProd/ObjectService/interface/ObjectService.h"

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

//--------------------------------------------------------------------------------------------------
FillerConversions::FillerConversions(const ParameterSet &cfg, const char *name, bool active) :
  BaseFiller(cfg,name,active),
  edmName_(Conf().getUntrackedParameter<string>("edmName","conversions")),
  mitName_(Conf().getUntrackedParameter<string>("mitName","Conversions")),
  stablePartMapNames_(Conf().exists("stablePartMaps") ? 
                    Conf().getUntrackedParameter<vector<string> >("stablePartMaps") : 
                    vector<string>()),
  conversionMapName_(Conf().getUntrackedParameter<string>("conversionMapName",
                                                          Form("%sMapName",mitName_.c_str()))),
  conversions_(new mithep::ConversionArr(16)),
  conversionMap_(new mithep::ConversionMap)
{
  // Constructor.
}

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

  delete conversions_;
  delete conversionMap_;
}

//--------------------------------------------------------------------------------------------------
void FillerConversions::BookDataBlock(TreeWriter &tws)
{
  // Add conversions to tree. Publish and get our objects.

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

  if (!convElectronMapName_.empty()) {
    conversionMap_->SetBrName(mitName_);
    OS()->add(conversionMap_,conversionMapName_);
  }

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

//--------------------------------------------------------------------------------------------------
void FillerConversions::FillDataBlock(const edm::Event      &event, 
                                      const edm::EventSetup &setup)
{
  // Fill conversions data structure and maps.

  conversions_->Delete();
  conversionMap_->Reset();

  Handle<reco::ConversionCollection> hConversionProduct;
  GetProduct(edmName_, hConversionProduct, event);

  conversionMap_->SetEdmProductId(hConversionProduct.id().id());
        
  const reco::ConversionCollection inConversions = *(hConversionProduct.product());  
  
  for (reco::ConversionCollection::const_iterator inConversion = inConversions.begin(); 
      inConversion != inConversions.end(); ++inConversion) {
        
    mithep::Vertex vertex(inConversion->conversionVertex().x(),
                          inConversion->conversionVertex().y(),
                          inConversion->conversionVertex().z(), 
                          inConversion->conversionVertex().xError(),
                          inConversion->conversionVertex().yError(),
                          inConversion->conversionVertex().zError());
    vertex.SetChi2(inConversion->conversionVertex().chi2());
    vertex.SetNdof((Int_t)inConversion->conversionVertex().ndof());
    vertex.SetNTracks(inConversion->conversionVertex().tracksSize());

    mithep::Conversion *outConversion = conversions_->Allocate();
    new (outConversion) mithep::Conversion(vertex);
    outConversion->SetDCotTheta(inConversion->pairCotThetaSeparation());
    outConversion->SetEOverP(inConversion->EoverP());
    outConversion->SetPairMass(inConversion->pairInvariantMass());
    outConversion->SetPairMomentum(inConversion->pairMomentum().x(),
                                   inConversion->pairMomentum().y(),
                                   inConversion->pairMomentum().z());
        
    if (stablePartMaps_.size()) {
      std::vector<reco::TrackRef> trackRefs = inConversion->tracks();
      for (std::vector<reco::TrackRef>::const_iterator trackRef = trackRefs.begin(); 
           trackRef != trackRefs.end(); ++trackRef) {
        outConversion->AddDaughter(GetMitParticle(refToPtr(*trackRef)));
      }
    }
    
    reco::ConversionRef theRef(hConversionProduct, inConversion-inConversions.begin());
    conversionMap_->Add(theRef, outConversion);
  }

  conversions_->Trim();
}

//--------------------------------------------------------------------------------------------------
mithep::Particle *FillerConversions::GetMitParticle(edm::Ptr<reco::Track> ptr) const
{
  // Return our particle referenced by the edm pointer.

  mithep::Particle *mitPart = 0;
  for (std::vector<const mithep::TrackPartMap*>::const_iterator bmap = stablePartMaps_.begin();
        bmap!=stablePartMaps_.end(); ++bmap) {
    const mithep::TrackPartMap *theMap = *bmap;
    if (theMap->HasMit(ptr)) {
      mitPart = theMap->GetMit(ptr);
      return mitPart;
    }
  }
  
  if (!mitPart)
    throw edm::Exception(edm::errors::Configuration, "FillerConversions::FillDataBlock()\n")
    << "Error! MITHEP Object " 
    << "not found in AssociationMaps (" << typeid(*this).name() << ")." << std::endl;
    
  return mitPart;
}
Revision:	1.17
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.16:	+3 -11 lines
Log Message:	Cleanup
#	User	Rev	Content
1	loizides	1.17	// $Id: FillerConversions.cc,v 1.16 2009/06/18 23:07:14 bendavid Exp $
2	bendavid	1.1
3	loizides	1.2	#include "MitProd/TreeFiller/interface/FillerConversions.h"
4	bendavid	1.10	#include "DataFormats/Common/interface/RefToPtr.h"
5	loizides	1.15	#include "MitAna/DataTree/interface/ConversionCol.h"
6	bendavid	1.1	#include "MitAna/DataTree/interface/Names.h"
7	loizides	1.15	#include "MitProd/ObjectService/interface/ObjectService.h"
8	bendavid	1.1
9			using namespace std;
10			using namespace edm;
11			using namespace mithep;
12
13	loizides	1.2	//--------------------------------------------------------------------------------------------------
14	loizides	1.12	FillerConversions::FillerConversions(const ParameterSet &cfg, const char *name, bool active) :
15			BaseFiller(cfg,name,active),
16	bendavid	1.1	edmName_(Conf().getUntrackedParameter<string>("edmName","conversions")),
17			mitName_(Conf().getUntrackedParameter<string>("mitName","Conversions")),
18	bendavid	1.16	stablePartMapNames_(Conf().exists("stablePartMaps") ?
19			Conf().getUntrackedParameter<vector<string> >("stablePartMaps") :
20			vector<string>()),
21	loizides	1.8	conversionMapName_(Conf().getUntrackedParameter<string>("conversionMapName",
22			Form("%sMapName",mitName_.c_str()))),
23	loizides	1.6	conversions_(new mithep::ConversionArr(16)),
24	bendavid	1.1	conversionMap_(new mithep::ConversionMap)
25			{
26	loizides	1.2	// Constructor.
27	bendavid	1.1	}
28
29	loizides	1.2	//--------------------------------------------------------------------------------------------------
30	bendavid	1.1	FillerConversions::~FillerConversions()
31			{
32	loizides	1.2	// Destructor.
33
34	loizides	1.4	delete conversions_;
35	loizides	1.2	delete conversionMap_;
36	bendavid	1.1	}
37
38	loizides	1.2	//--------------------------------------------------------------------------------------------------
39	bendavid	1.1	void FillerConversions::BookDataBlock(TreeWriter &tws)
40			{
41	loizides	1.8	// Add conversions to tree. Publish and get our objects.
42	loizides	1.2
43	loizides	1.13	tws.AddBranch(mitName_,&conversions_);
44			OS()->add<mithep::ConversionArr>(conversions_,mitName_);
45	loizides	1.8
46	loizides	1.13	if (!convElectronMapName_.empty()) {
47			conversionMap_->SetBrName(mitName_);
48			OS()->add(conversionMap_,conversionMapName_);
49			}
50
51	bendavid	1.16	for (std::vector<std::string>::const_iterator bmapName = stablePartMapNames_.begin();
52			bmapName!=stablePartMapNames_.end(); ++bmapName) {
53			if (!bmapName->empty()) {
54			const TrackPartMap map = OS()->get<TrackPartMap>(bmapName);
55			if (map) {
56			stablePartMaps_.push_back(map);
57			AddBranchDep(mitName_,map->GetBrName());
58			}
59			}
60	loizides	1.13	}
61	bendavid	1.1	}
62
63	loizides	1.2	//--------------------------------------------------------------------------------------------------
64	bendavid	1.1	void FillerConversions::FillDataBlock(const edm::Event &event,
65			const edm::EventSetup &setup)
66			{
67	loizides	1.5	// Fill conversions data structure and maps.
68	bendavid	1.1
69	bendavid	1.11	conversions_->Delete();
70	bendavid	1.1	conversionMap_->Reset();
71	loizides	1.5
72			Handle<reco::ConversionCollection> hConversionProduct;
73			GetProduct(edmName_, hConversionProduct, event);
74
75			conversionMap_->SetEdmProductId(hConversionProduct.id().id());
76	bendavid	1.1
77	loizides	1.5	const reco::ConversionCollection inConversions = *(hConversionProduct.product());
78	bendavid	1.1
79			for (reco::ConversionCollection::const_iterator inConversion = inConversions.begin();
80			inConversion != inConversions.end(); ++inConversion) {
81
82	loizides	1.14	mithep::Vertex vertex(inConversion->conversionVertex().x(),
83			inConversion->conversionVertex().y(),
84			inConversion->conversionVertex().z(),
85			inConversion->conversionVertex().xError(),
86			inConversion->conversionVertex().yError(),
87			inConversion->conversionVertex().zError());
88			vertex.SetChi2(inConversion->conversionVertex().chi2());
89			vertex.SetNdof((Int_t)inConversion->conversionVertex().ndof());
90			vertex.SetNTracks(inConversion->conversionVertex().tracksSize());
91
92	loizides	1.6	mithep::Conversion *outConversion = conversions_->Allocate();
93	loizides	1.14	new (outConversion) mithep::Conversion(vertex);
94	loizides	1.5	outConversion->SetDCotTheta(inConversion->pairCotThetaSeparation());
95			outConversion->SetEOverP(inConversion->EoverP());
96			outConversion->SetPairMass(inConversion->pairInvariantMass());
97			outConversion->SetPairMomentum(inConversion->pairMomentum().x(),
98			inConversion->pairMomentum().y(),
99			inConversion->pairMomentum().z());
100	bendavid	1.1
101	bendavid	1.16	if (stablePartMaps_.size()) {
102	loizides	1.5	std::vector<reco::TrackRef> trackRefs = inConversion->tracks();
103			for (std::vector<reco::TrackRef>::const_iterator trackRef = trackRefs.begin();
104			trackRef != trackRefs.end(); ++trackRef) {
105	loizides	1.17	outConversion->AddDaughter(GetMitParticle(refToPtr(*trackRef)));
106	loizides	1.5	}
107			}
108
109			reco::ConversionRef theRef(hConversionProduct, inConversion-inConversions.begin());
110			conversionMap_->Add(theRef, outConversion);
111	bendavid	1.1	}
112	loizides	1.2
113	bendavid	1.1	conversions_->Trim();
114			}
115	bendavid	1.16
116			//--------------------------------------------------------------------------------------------------
117	loizides	1.17	mithep::Particle *FillerConversions::GetMitParticle(edm::Ptr<reco::Track> ptr) const
118	bendavid	1.16	{
119			// Return our particle referenced by the edm pointer.
120
121			mithep::Particle *mitPart = 0;
122			for (std::vector<const mithep::TrackPartMap*>::const_iterator bmap = stablePartMaps_.begin();
123			bmap!=stablePartMaps_.end(); ++bmap) {
124			const mithep::TrackPartMap theMap = bmap;
125			if (theMap->HasMit(ptr)) {
126			mitPart = theMap->GetMit(ptr);
127			return mitPart;
128			}
129			}
130
131			if (!mitPart)
132			throw edm::Exception(edm::errors::Configuration, "FillerConversions::FillDataBlock()\n")
133			<< "Error! MITHEP Object "
134			<< "not found in AssociationMaps (" << typeid(*this).name() << ")." << std::endl;
135
136			return mitPart;
137			}