TreeFiller/src/FillerConversionsDecay.cc

// $Id: FillerConversionsDecay.cc,v 1.7 2012/12/28 17:27:21 pharris Exp $

#include "MitProd/TreeFiller/interface/FillerConversionsDecay.h"
#include "DataFormats/Common/interface/RefToPtr.h"
#include "MitEdm/DataFormats/interface/RefToBaseToPtr.h"
#include "MitAna/DataTree/interface/StableDataCol.h"
#include "MitAna/DataTree/interface/DecayDataCol.h"
#include "MitAna/DataTree/interface/DecayParticleCol.h"
#include "MitAna/DataTree/interface/Names.h"
#include "MitProd/ObjectService/interface/ObjectService.h"
#include "TrackingTools/IPTools/interface/IPTools.h"
#include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h"
#include "TrackingTools/TransientTrack/plugins/TransientTrackBuilderESProducer.h"
#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
#include "TrackingTools/GeomPropagators/interface/AnalyticalTrajectoryExtrapolatorToLine.h"
#include "TrackingTools/GeomPropagators/interface/AnalyticalImpactPointExtrapolator.h"
#include "DataFormats/GeometryCommonDetAlgo/interface/Measurement1D.h"
#include "TrackingTools/TransientTrack/interface/TransientTrack.h"
#include "RecoVertex/VertexPrimitives/interface/ConvertToFromReco.h"
#include "MagneticField/UniformEngine/src/UniformMagneticField.h"


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

//--------------------------------------------------------------------------------------------------
FillerConversionsDecay::FillerConversionsDecay(const ParameterSet &cfg, const char *name, bool active) :
  BaseFiller(cfg,name,active),
  edmName_(Conf().getUntrackedParameter<string>("edmName","conversions")),
  mitName_(Conf().getUntrackedParameter<string>("mitName","Conversions")),
  checkTrackRef_     (Conf().getUntrackedParameter<bool>  ("checkTrackRef" ,true  )),
  stableDataName_(mitName_ + "_StableDatas"),  
  stablePartMapNames_(Conf().exists("stablePartMaps") ? 
                    Conf().getUntrackedParameter<vector<string> >("stablePartMaps") : 
                    vector<string>()),
  conversionMapName_(Conf().getUntrackedParameter<string>("conversionMapName",
                                                          Form("%sMapName",mitName_.c_str()))),
  decays_(new mithep::DecayParticleArr(250)),
  stableData_(new mithep::StableDataArr(500)),
  conversionMap_(new mithep::ConversionDecayMap)
{
  // Constructor.
}

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

  delete decays_;
  delete stableData_;
  delete conversionMap_;
}

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

  tws.AddBranch(mitName_,        &decays_);
  OS()->add<mithep::DecayParticleArr>(decays_,mitName_);
  tws.AddBranch(stableDataName_, &stableData_);
  OS()->add<mithep::StableDataArr>(stableData_,stableDataName_);

  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 FillerConversionsDecay::FillDataBlock(const edm::Event      &event, 
                                      const edm::EventSetup &setup)
{
  // Fill conversions data structure and maps.

  decays_->Delete();
  stableData_->Delete();
  conversionMap_->Reset();

  //get beamspot
  edm::Handle<reco::BeamSpot> bsHandle;
  event.getByLabel("offlineBeamSpot", bsHandle);
  const reco::BeamSpot &thebs = *bsHandle.product();

  //transient track producer
  edm::ESHandle<TransientTrackBuilder> hTransientTrackBuilder;
  setup.get<TransientTrackRecord>().get("TransientTrackBuilder",hTransientTrackBuilder);
  const TransientTrackBuilder *transientTrackBuilder = hTransientTrackBuilder.product();

  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::DecayParticle *outConversion = decays_->Allocate();    
    new (outConversion) mithep::DecayParticle(22);

    math::XYZTLorentzVectorD convP4(inConversion->refittedPair4Momentum());
    FourVector p4Fitted(convP4.px(),convP4.py(),convP4.pz(),convP4.energy());
  
    const std::vector<reco::TrackBaseRef> &trackRefs = inConversion->tracks();
    if (trackRefs.size()==1 && p4Fitted.Pt()<1e-3) {
      p4Fitted.SetXYZT(trackRefs.front()->px(),trackRefs.front()->py(),trackRefs.front()->pz(),trackRefs.front()->p());
    }
  
    outConversion->SetMom(p4Fitted);
  
    const reco::Vertex &vtx = inConversion->conversionVertex();
    ThreeVector vtxPos(vtx.x(),vtx.y(),vtx.z());
    GlobalPoint vtxPoint(vtx.x(),vtx.y(),vtx.z());
    
    double dlz = vtxPos.z()*TMath::Abs(p4Fitted.Pz())/p4Fitted.Pz();
    ThreeVector momPerp(p4Fitted.Px(),p4Fitted.Py(),0);
    ThreeVector posPerp(vtxPos.x(),vtxPos.y(),0);
    double dl = momPerp.Dot(posPerp)/momPerp.R();    
    double dxy = momPerp.Cross(vtxPos).Z()/p4Fitted.Pt();
    
    outConversion->SetLz(dlz);
    outConversion->SetLxy(dl);
    outConversion->SetDxy(dxy);
       
    outConversion->SetChi2(vtx.chi2());
    outConversion->SetNdof((Int_t)vtx.ndof());
    
    outConversion->SetNSharedHits(inConversion->nSharedHits());
        
    
    const std::vector<reco::Track> &refittedTracks = vtx.refittedTracks();
    const std::vector<uint8_t> &nHitsBeforeVtx = inConversion->nHitsBeforeVtx();
    const std::vector<Measurement1DFloat> &dlClosestHitToVtx = inConversion->dlClosestHitToVtx();
    
    //fill conversion quality mask
    ConversionQuality &outQuality = outConversion->Quality();
    for (uint i=0; i<16; ++i) {
      outQuality.SetQuality(ConversionQuality::EQuality(i),inConversion->quality(reco::Conversion::ConversionQuality(i)));
    }
    
    //fill daughters
    double zbeamlineerr = -99.;
    if (stablePartMaps_.size()) {
      for (uint i=0; i<trackRefs.size(); ++i) {
        
        const reco::TrackBaseRef &trackRef = trackRefs.at(i);

        const reco::Track *refittedTrack = 0;

        if (refittedTracks.size()>i)
          refittedTrack = &refittedTracks.at(i);
        else 
          refittedTrack = trackRef.get();

        //fill dzError at beamline (take from refitted first track normally)
        if (zbeamlineerr<0.) {
          const reco::TransientTrack &tt = transientTrackBuilder->build(*refittedTrack);
          //null b-field
          const UniformMagneticField nullField(0.0); 
          TransverseImpactPointExtrapolator extrapolator(&nullField);
        
          //const TrajectoryStateOnSurface &bsstate = extrapolator.extrapolate(tt.stateOnSurface(vtxPoint), RecoVertex::convertPos(thebs.position()));
          const FreeTrajectoryState &initialfts = tt.initialFreeState();
          const GlobalTrajectoryParameters trackgtp(initialfts.position(),initialfts.momentum(),initialfts.charge(),&nullField);
          const FreeTrajectoryState trackfts(trackgtp,initialfts.cartesianError(),initialfts.curvilinearError());
          const TrajectoryStateOnSurface &bsstate = extrapolator.extrapolate(trackfts, RecoVertex::convertPos(thebs.position()));
          if (bsstate.isValid()) {
            double zbeamline = bsstate.globalPosition().z();
            zbeamlineerr = sqrt((bsstate.cartesianError().matrix())(2,2));
            if (0) {
              math::XYZVector mom(inConversion->refittedPairMomentum());
              double zbeamlineconv = (vtx.z()) - ((vtx.x()-thebs.position().x())*mom.x()+(vtx.y()-thebs.position().y())*mom.y())/mom.rho() * mom.z()/mom.rho();
              double zbeamlinetrk = (refittedTrack->vertex().z()) - ((refittedTrack->vertex().x()-thebs.position().x())*refittedTrack->momentum().x()+(refittedTrack->vertex().y()-thebs.position().y())*refittedTrack->momentum().y())/refittedTrack->momentum().rho() * refittedTrack->momentum().z()/refittedTrack->momentum().rho();

              printf("zbeamlineconv = %5f, zbeamlinetrk = %5f, zbeamline = %5f, zbeamlineerr = %5f\n",zbeamlineconv,zbeamlinetrk,zbeamline,zbeamlineerr);
            }
          }
        }


        const mithep::Particle *daughter = 0; 
        try{daughter = GetMitParticle(mitedm::refToBaseToPtr(trackRef));}
        catch(...) { 
          std::cout << " ======> Broken Track Reference ===> " << std::endl;
          if(checkTrackRef_)     throw edm::Exception(edm::errors::Configuration, "FillerConversionsDecay::FillDataBlock()\n")
            << "Error! not found in AssociationMaps (" << typeid(*this).name() << ")." << std::endl;
        }
        
        mithep::StableData *outStable = stableData_->Allocate();
        new (outStable) mithep::StableData(daughter,
                                           refittedTrack->px(),refittedTrack->py(),refittedTrack->pz());
        
        if (nHitsBeforeVtx.size()>i) {
          outStable->SetNHitsBeforeVtx(nHitsBeforeVtx.at(i));
        }
        if (dlClosestHitToVtx.size()>i) {
          outStable->SetDlClosestHitToVtx(dlClosestHitToVtx.at(i).value());
          outStable->SetDlClosestHitToVtxErr(dlClosestHitToVtx.at(i).error());          
        }
                                                                            
        outConversion->AddDaughterData(outStable);
      }
    }

    outConversion->SetDzBeamlineError(zbeamlineerr);
    
    reco::ConversionRef theRef(hConversionProduct, inConversion-inConversions.begin());
    conversionMap_->Add(theRef, outConversion);
  }
  decays_->Trim();
}

//--------------------------------------------------------------------------------------------------
mithep::Particle *FillerConversionsDecay::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 && checkTrackRef_)
    throw edm::Exception(edm::errors::Configuration, "FillerConversionsDecay::FillDataBlock()\n")
    << "Error! MITHEP Object " 
    << "not found in AssociationMaps (" << typeid(*this).name() << ")." << std::endl;

  return mitPart;
}
Revision:	1.4.2.2
Committed:	Fri May 31 22:58:45 2013 UTC (11 years, 11 months ago) by pharris
Content type:	text/plain
Branch:	Mit_025c_branch
CVS Tags:	Mit_025c_branch2
Changes since 1.4.2.1:	+22 -14 lines
Log Message:	updated 42X for Tau
#	User	Rev	Content
1	pharris	1.4.2.2	// $Id: FillerConversionsDecay.cc,v 1.7 2012/12/28 17:27:21 pharris Exp $
2	bendavid	1.1
3			#include "MitProd/TreeFiller/interface/FillerConversionsDecay.h"
4			#include "DataFormats/Common/interface/RefToPtr.h"
5			#include "MitEdm/DataFormats/interface/RefToBaseToPtr.h"
6			#include "MitAna/DataTree/interface/StableDataCol.h"
7			#include "MitAna/DataTree/interface/DecayDataCol.h"
8			#include "MitAna/DataTree/interface/DecayParticleCol.h"
9			#include "MitAna/DataTree/interface/Names.h"
10			#include "MitProd/ObjectService/interface/ObjectService.h"
11	bendavid	1.2	#include "TrackingTools/IPTools/interface/IPTools.h"
12			#include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h"
13			#include "TrackingTools/TransientTrack/plugins/TransientTrackBuilderESProducer.h"
14			#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
15			#include "TrackingTools/GeomPropagators/interface/AnalyticalTrajectoryExtrapolatorToLine.h"
16			#include "TrackingTools/GeomPropagators/interface/AnalyticalImpactPointExtrapolator.h"
17			#include "DataFormats/GeometryCommonDetAlgo/interface/Measurement1D.h"
18			#include "TrackingTools/TransientTrack/interface/TransientTrack.h"
19			#include "RecoVertex/VertexPrimitives/interface/ConvertToFromReco.h"
20	bendavid	1.3	#include "MagneticField/UniformEngine/src/UniformMagneticField.h"
21
22	bendavid	1.1
23			using namespace std;
24			using namespace edm;
25			using namespace mithep;
26
27			//--------------------------------------------------------------------------------------------------
28			FillerConversionsDecay::FillerConversionsDecay(const ParameterSet &cfg, const char *name, bool active) :
29			BaseFiller(cfg,name,active),
30			edmName_(Conf().getUntrackedParameter<string>("edmName","conversions")),
31			mitName_(Conf().getUntrackedParameter<string>("mitName","Conversions")),
32	pharris	1.4.2.2	checkTrackRef_ (Conf().getUntrackedParameter<bool> ("checkTrackRef" ,true )),
33	bendavid	1.1	stableDataName_(mitName_ + "_StableDatas"),
34			stablePartMapNames_(Conf().exists("stablePartMaps") ?
35			Conf().getUntrackedParameter<vector<string> >("stablePartMaps") :
36			vector<string>()),
37			conversionMapName_(Conf().getUntrackedParameter<string>("conversionMapName",
38			Form("%sMapName",mitName_.c_str()))),
39			decays_(new mithep::DecayParticleArr(250)),
40			stableData_(new mithep::StableDataArr(500)),
41			conversionMap_(new mithep::ConversionDecayMap)
42			{
43			// Constructor.
44			}
45
46			//--------------------------------------------------------------------------------------------------
47			FillerConversionsDecay::~FillerConversionsDecay()
48			{
49			// Destructor.
50
51			delete decays_;
52			delete stableData_;
53			delete conversionMap_;
54			}
55
56			//--------------------------------------------------------------------------------------------------
57			void FillerConversionsDecay::BookDataBlock(TreeWriter &tws)
58			{
59			// Add conversions to tree. Publish and get our objects.
60
61			tws.AddBranch(mitName_, &decays_);
62			OS()->add<mithep::DecayParticleArr>(decays_,mitName_);
63			tws.AddBranch(stableDataName_, &stableData_);
64			OS()->add<mithep::StableDataArr>(stableData_,stableDataName_);
65
66	paus	1.4.2.1	if (!conversionMapName_.empty()) {
67	bendavid	1.1	conversionMap_->SetBrName(mitName_);
68			OS()->add(conversionMap_,conversionMapName_);
69			}
70
71			for (std::vector<std::string>::const_iterator bmapName = stablePartMapNames_.begin();
72			bmapName!=stablePartMapNames_.end(); ++bmapName) {
73			if (!bmapName->empty()) {
74			const TrackPartMap map = OS()->get<TrackPartMap>(bmapName);
75			if (map) {
76			stablePartMaps_.push_back(map);
77			AddBranchDep(mitName_,map->GetBrName());
78			}
79			}
80			}
81			}
82
83			//--------------------------------------------------------------------------------------------------
84			void FillerConversionsDecay::FillDataBlock(const edm::Event &event,
85			const edm::EventSetup &setup)
86			{
87			// Fill conversions data structure and maps.
88
89			decays_->Delete();
90			stableData_->Delete();
91			conversionMap_->Reset();
92
93	bendavid	1.2	//get beamspot
94			edm::Handle<reco::BeamSpot> bsHandle;
95			event.getByLabel("offlineBeamSpot", bsHandle);
96			const reco::BeamSpot &thebs = *bsHandle.product();
97
98			//transient track producer
99			edm::ESHandle<TransientTrackBuilder> hTransientTrackBuilder;
100			setup.get<TransientTrackRecord>().get("TransientTrackBuilder",hTransientTrackBuilder);
101			const TransientTrackBuilder *transientTrackBuilder = hTransientTrackBuilder.product();
102
103	bendavid	1.1	Handle<reco::ConversionCollection> hConversionProduct;
104			GetProduct(edmName_, hConversionProduct, event);
105
106			conversionMap_->SetEdmProductId(hConversionProduct.id().id());
107
108			const reco::ConversionCollection inConversions = *(hConversionProduct.product());
109
110	bendavid	1.3
111	bendavid	1.1	for (reco::ConversionCollection::const_iterator inConversion = inConversions.begin();
112			inConversion != inConversions.end(); ++inConversion) {
113
114			mithep::DecayParticle *outConversion = decays_->Allocate();
115			new (outConversion) mithep::DecayParticle(22);
116
117	bendavid	1.4	math::XYZTLorentzVectorD convP4(inConversion->refittedPair4Momentum());
118	bendavid	1.1	FourVector p4Fitted(convP4.px(),convP4.py(),convP4.pz(),convP4.energy());
119
120	pharris	1.4.2.2	const std::vector<reco::TrackBaseRef> &trackRefs = inConversion->tracks();
121			if (trackRefs.size()==1 && p4Fitted.Pt()<1e-3) {
122			p4Fitted.SetXYZT(trackRefs.front()->px(),trackRefs.front()->py(),trackRefs.front()->pz(),trackRefs.front()->p());
123			}
124
125	bendavid	1.1	outConversion->SetMom(p4Fitted);
126
127			const reco::Vertex &vtx = inConversion->conversionVertex();
128			ThreeVector vtxPos(vtx.x(),vtx.y(),vtx.z());
129	bendavid	1.3	GlobalPoint vtxPoint(vtx.x(),vtx.y(),vtx.z());
130	bendavid	1.1
131			double dlz = vtxPos.z()*TMath::Abs(p4Fitted.Pz())/p4Fitted.Pz();
132			ThreeVector momPerp(p4Fitted.Px(),p4Fitted.Py(),0);
133			ThreeVector posPerp(vtxPos.x(),vtxPos.y(),0);
134			double dl = momPerp.Dot(posPerp)/momPerp.R();
135			double dxy = momPerp.Cross(vtxPos).Z()/p4Fitted.Pt();
136
137			outConversion->SetLz(dlz);
138			outConversion->SetLxy(dl);
139			outConversion->SetDxy(dxy);
140
141			outConversion->SetChi2(vtx.chi2());
142			outConversion->SetNdof((Int_t)vtx.ndof());
143
144			outConversion->SetNSharedHits(inConversion->nSharedHits());
145
146	pharris	1.4.2.2
147	bendavid	1.1	const std::vector<reco::Track> &refittedTracks = vtx.refittedTracks();
148			const std::vector<uint8_t> &nHitsBeforeVtx = inConversion->nHitsBeforeVtx();
149			const std::vector<Measurement1DFloat> &dlClosestHitToVtx = inConversion->dlClosestHitToVtx();
150
151			//fill conversion quality mask
152			ConversionQuality &outQuality = outConversion->Quality();
153			for (uint i=0; i<16; ++i) {
154			outQuality.SetQuality(ConversionQuality::EQuality(i),inConversion->quality(reco::Conversion::ConversionQuality(i)));
155			}
156
157			//fill daughters
158	bendavid	1.3	double zbeamlineerr = -99.;
159	paus	1.4.2.1	if (stablePartMaps_.size()) {
160	bendavid	1.1	for (uint i=0; i<trackRefs.size(); ++i) {
161	pharris	1.4.2.2
162	bendavid	1.1	const reco::TrackBaseRef &trackRef = trackRefs.at(i);
163	paus	1.4.2.1
164			const reco::Track *refittedTrack = 0;
165
166			if (refittedTracks.size()>i)
167			refittedTrack = &refittedTracks.at(i);
168			else
169			refittedTrack = trackRef.get();
170	pharris	1.4.2.2
171	bendavid	1.3	//fill dzError at beamline (take from refitted first track normally)
172			if (zbeamlineerr<0.) {
173	paus	1.4.2.1	const reco::TransientTrack &tt = transientTrackBuilder->build(*refittedTrack);
174	bendavid	1.3	//null b-field
175			const UniformMagneticField nullField(0.0);
176			TransverseImpactPointExtrapolator extrapolator(&nullField);
177	pharris	1.4.2.2
178	bendavid	1.3	//const TrajectoryStateOnSurface &bsstate = extrapolator.extrapolate(tt.stateOnSurface(vtxPoint), RecoVertex::convertPos(thebs.position()));
179			const FreeTrajectoryState &initialfts = tt.initialFreeState();
180			const GlobalTrajectoryParameters trackgtp(initialfts.position(),initialfts.momentum(),initialfts.charge(),&nullField);
181			const FreeTrajectoryState trackfts(trackgtp,initialfts.cartesianError(),initialfts.curvilinearError());
182			const TrajectoryStateOnSurface &bsstate = extrapolator.extrapolate(trackfts, RecoVertex::convertPos(thebs.position()));
183			if (bsstate.isValid()) {
184			double zbeamline = bsstate.globalPosition().z();
185			zbeamlineerr = sqrt((bsstate.cartesianError().matrix())(2,2));
186			if (0) {
187	bendavid	1.4	math::XYZVector mom(inConversion->refittedPairMomentum());
188	bendavid	1.3	double zbeamlineconv = (vtx.z()) - ((vtx.x()-thebs.position().x())mom.x()+(vtx.y()-thebs.position().y())mom.y())/mom.rho() * mom.z()/mom.rho();
189	paus	1.4.2.1	double zbeamlinetrk = (refittedTrack->vertex().z()) - ((refittedTrack->vertex().x()-thebs.position().x())refittedTrack->momentum().x()+(refittedTrack->vertex().y()-thebs.position().y())refittedTrack->momentum().y())/refittedTrack->momentum().rho() * refittedTrack->momentum().z()/refittedTrack->momentum().rho();
190	bendavid	1.2
191	bendavid	1.3	printf("zbeamlineconv = %5f, zbeamlinetrk = %5f, zbeamline = %5f, zbeamlineerr = %5f\n",zbeamlineconv,zbeamlinetrk,zbeamline,zbeamlineerr);
192			}
193	bendavid	1.2	}
194			}
195
196	pharris	1.4.2.2
197
198			const mithep::Particle *daughter = 0;
199			try{daughter = GetMitParticle(mitedm::refToBaseToPtr(trackRef));}
200			catch(...) {
201			std::cout << " ======> Broken Track Reference ===> " << std::endl;
202			if(checkTrackRef_) throw edm::Exception(edm::errors::Configuration, "FillerConversionsDecay::FillDataBlock()\n")
203			<< "Error! not found in AssociationMaps (" << typeid(*this).name() << ")." << std::endl;
204			}
205	bendavid	1.1
206			mithep::StableData *outStable = stableData_->Allocate();
207			new (outStable) mithep::StableData(daughter,
208	paus	1.4.2.1	refittedTrack->px(),refittedTrack->py(),refittedTrack->pz());
209	bendavid	1.1
210			if (nHitsBeforeVtx.size()>i) {
211			outStable->SetNHitsBeforeVtx(nHitsBeforeVtx.at(i));
212			}
213			if (dlClosestHitToVtx.size()>i) {
214			outStable->SetDlClosestHitToVtx(dlClosestHitToVtx.at(i).value());
215			outStable->SetDlClosestHitToVtxErr(dlClosestHitToVtx.at(i).error());
216			}
217
218			outConversion->AddDaughterData(outStable);
219			}
220			}
221	bendavid	1.3
222			outConversion->SetDzBeamlineError(zbeamlineerr);
223	bendavid	1.1
224			reco::ConversionRef theRef(hConversionProduct, inConversion-inConversions.begin());
225			conversionMap_->Add(theRef, outConversion);
226			}
227			decays_->Trim();
228			}
229
230			//--------------------------------------------------------------------------------------------------
231			mithep::Particle *FillerConversionsDecay::GetMitParticle(edm::Ptr<reco::Track> ptr) const
232			{
233			// Return our particle referenced by the edm pointer.
234			mithep::Particle *mitPart = 0;
235			for (std::vector<const mithep::TrackPartMap*>::const_iterator bmap = stablePartMaps_.begin();
236			bmap!=stablePartMaps_.end(); ++bmap) {
237			const mithep::TrackPartMap theMap = bmap;
238			if (theMap->HasMit(ptr)) {
239			mitPart = theMap->GetMit(ptr);
240			return mitPart;
241			}
242			}
243	pharris	1.4.2.2	if (!mitPart && checkTrackRef_)
244	bendavid	1.1	throw edm::Exception(edm::errors::Configuration, "FillerConversionsDecay::FillDataBlock()\n")
245			<< "Error! MITHEP Object "
246			<< "not found in AssociationMaps (" << typeid(*this).name() << ")." << std::endl;
247	pharris	1.4.2.2
248	bendavid	1.1	return mitPart;
249			}