TreeFiller/src/FillerConversions.cc

// $Id: FillerConversions.cc,v 1.22 2010/11/22 16:54:13 bendavid Exp $

#include "MitProd/TreeFiller/interface/FillerConversions.h"
#include "DataFormats/Common/interface/RefToPtr.h"
#include "MitEdm/DataFormats/interface/RefToBaseToPtr.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 (!conversionMapName_.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(inConversion->conversionVertex().ndof());
    vertex.SetNTracksFit(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::TrackBaseRef> trackRefs = inConversion->tracks();
      for (std::vector<reco::TrackBaseRef>::const_iterator trackRef = trackRefs.begin(); 
           trackRef != trackRefs.end(); ++trackRef) {
        outConversion->AddDaughter(GetMitParticle(mitedm::refToBaseToPtr(*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.23
Committed:	Sat May 5 16:49:59 2012 UTC (12 years, 11 months ago) by paus
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Mit_029, Mit_029_pre1, Mit_028a, Mit_028, Mit_027a, Mit_027
Changes since 1.22:	+11 -12 lines
Log Message:	Version 027 - complete version for ICHEP 2012.
#	User	Rev	Content
1	paus	1.23	// $Id: FillerConversions.cc,v 1.22 2010/11/22 16:54:13 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	bendavid	1.22	#include "MitEdm/DataFormats/interface/RefToBaseToPtr.h"
6	loizides	1.15	#include "MitAna/DataTree/interface/ConversionCol.h"
7	bendavid	1.1	#include "MitAna/DataTree/interface/Names.h"
8	loizides	1.15	#include "MitProd/ObjectService/interface/ObjectService.h"
9	bendavid	1.1
10			using namespace std;
11			using namespace edm;
12			using namespace mithep;
13
14	loizides	1.2	//--------------------------------------------------------------------------------------------------
15	loizides	1.12	FillerConversions::FillerConversions(const ParameterSet &cfg, const char *name, bool active) :
16	paus	1.23	BaseFiller (cfg,name,active),
17			edmName_ (Conf().getUntrackedParameter<string>("edmName","conversions")),
18			mitName_ (Conf().getUntrackedParameter<string>("mitName","Conversions")),
19	bendavid	1.16	stablePartMapNames_(Conf().exists("stablePartMaps") ?
20	paus	1.23	Conf().getUntrackedParameter<vector<string> >("stablePartMaps") :
21			vector<string>()),
22			conversionMapName_ (Conf().getUntrackedParameter<string>("conversionMapName",
23			Form("%sMapName",mitName_.c_str()))),
24			conversions_ (new mithep::ConversionArr(16)),
25			conversionMap_ (new mithep::ConversionMap)
26	bendavid	1.1	{
27	loizides	1.2	// Constructor.
28	bendavid	1.1	}
29
30	loizides	1.2	//--------------------------------------------------------------------------------------------------
31	bendavid	1.1	FillerConversions::~FillerConversions()
32			{
33	loizides	1.2	// Destructor.
34
35	loizides	1.4	delete conversions_;
36	loizides	1.2	delete conversionMap_;
37	bendavid	1.1	}
38
39	loizides	1.2	//--------------------------------------------------------------------------------------------------
40	bendavid	1.20	void FillerConversions::BookDataBlock(TreeWriter &tws)
41	bendavid	1.1	{
42	loizides	1.8	// Add conversions to tree. Publish and get our objects.
43	loizides	1.2
44	loizides	1.13	tws.AddBranch(mitName_,&conversions_);
45			OS()->add<mithep::ConversionArr>(conversions_,mitName_);
46	loizides	1.8
47	paus	1.23	if (!conversionMapName_.empty()) {
48	loizides	1.13	conversionMap_->SetBrName(mitName_);
49			OS()->add(conversionMap_,conversionMapName_);
50			}
51
52	bendavid	1.16	for (std::vector<std::string>::const_iterator bmapName = stablePartMapNames_.begin();
53			bmapName!=stablePartMapNames_.end(); ++bmapName) {
54			if (!bmapName->empty()) {
55			const TrackPartMap map = OS()->get<TrackPartMap>(bmapName);
56			if (map) {
57			stablePartMaps_.push_back(map);
58			AddBranchDep(mitName_,map->GetBrName());
59			}
60			}
61	loizides	1.13	}
62	bendavid	1.1	}
63
64	loizides	1.2	//--------------------------------------------------------------------------------------------------
65	bendavid	1.1	void FillerConversions::FillDataBlock(const edm::Event &event,
66			const edm::EventSetup &setup)
67			{
68	loizides	1.5	// Fill conversions data structure and maps.
69	bendavid	1.1
70	bendavid	1.11	conversions_->Delete();
71	bendavid	1.1	conversionMap_->Reset();
72	loizides	1.5
73			Handle<reco::ConversionCollection> hConversionProduct;
74			GetProduct(edmName_, hConversionProduct, event);
75
76			conversionMap_->SetEdmProductId(hConversionProduct.id().id());
77	bendavid	1.1
78	loizides	1.5	const reco::ConversionCollection inConversions = *(hConversionProduct.product());
79	bendavid	1.1
80			for (reco::ConversionCollection::const_iterator inConversion = inConversions.begin();
81			inConversion != inConversions.end(); ++inConversion) {
82
83	loizides	1.14	mithep::Vertex vertex(inConversion->conversionVertex().x(),
84			inConversion->conversionVertex().y(),
85			inConversion->conversionVertex().z(),
86			inConversion->conversionVertex().xError(),
87			inConversion->conversionVertex().yError(),
88			inConversion->conversionVertex().zError());
89			vertex.SetChi2(inConversion->conversionVertex().chi2());
90	bendavid	1.21	vertex.SetNdof(inConversion->conversionVertex().ndof());
91	bendavid	1.19	vertex.SetNTracksFit(inConversion->conversionVertex().tracksSize());
92
93	loizides	1.6	mithep::Conversion *outConversion = conversions_->Allocate();
94	loizides	1.14	new (outConversion) mithep::Conversion(vertex);
95	loizides	1.5	outConversion->SetDCotTheta(inConversion->pairCotThetaSeparation());
96			outConversion->SetEOverP(inConversion->EoverP());
97			outConversion->SetPairMass(inConversion->pairInvariantMass());
98			outConversion->SetPairMomentum(inConversion->pairMomentum().x(),
99			inConversion->pairMomentum().y(),
100			inConversion->pairMomentum().z());
101	bendavid	1.1
102	bendavid	1.16	if (stablePartMaps_.size()) {
103	bendavid	1.22	std::vector<reco::TrackBaseRef> trackRefs = inConversion->tracks();
104			for (std::vector<reco::TrackBaseRef>::const_iterator trackRef = trackRefs.begin();
105	loizides	1.5	trackRef != trackRefs.end(); ++trackRef) {
106	bendavid	1.22	outConversion->AddDaughter(GetMitParticle(mitedm::refToBaseToPtr(*trackRef)));
107	loizides	1.5	}
108			}
109
110			reco::ConversionRef theRef(hConversionProduct, inConversion-inConversions.begin());
111			conversionMap_->Add(theRef, outConversion);
112	bendavid	1.1	}
113			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			}