NtpSRModule Class Reference

#include <NtpSRModule.h>

Inheritance diagram for NtpSRModule:

List of all members.

Public Member Functions
	NtpSRModule ()
	~NtpSRModule ()
const Registry &	DefaultConfig () const
void	Config (const Registry &r)
JobCResult	Reco (MomNavigator *mom)
Private Member Functions
void	FillNtpStrip (TClonesArray &ntpstparray, const CandRecord *cndrec)
void	FillNtpSlice (TClonesArray &ntpslcarray, const CandRecord *cndrec)
void	FillNtpCluster (TClonesArray &ntpcluarray, const CandRecord *cndrec)
void	FillNtpShower (TClonesArray &ntpshwarray, const CandRecord *cndrec)
void	FillNtpTrack (TClonesArray &ntptrkarray, const CandRecord *cndrec)
void	FillNtpEvent (TClonesArray &ntpevtarray, const CandRecord *cndrec)
void	FillNtpTrackLinearFit (NtpSRTrack *ntptrack, const CandTrackHandle *track)
void	FillNtpTrackVertex (NtpSRTrack *ntptrack, const CandTrackHandle *track)
void	FillNtpTrackEnd (NtpSRTrack *ntptrack, const CandTrackHandle *track)
void	FillNtpTrackMomentum (NtpSRTrack *ntptrack, const CandTrackHandle *track)
void	FillNtpTrackFit (NtpSRTrack *ntptrack, const CandTrackHandle *track)
void	FillNtpTrackTime (NtpSRTrack *ntptrack, const CandTrackHandle *track)
void	FillNtpFiducialDistance (NtpSRFiducial &fid, const NtpSRVertex &vtx, const VldContext &vld)
void	FillNtpTrackFidVtx (NtpSRTrack *ntptrack, const CandTrackHandle *track, const VldContext &vld)
void	FillNtpTrackFidEnd (NtpSRTrack *ntptrack, const CandTrackHandle *track, const VldContext &vld)
void	FillNtpTrackFidAll (NtpSRTrack *ntptrack, const CandTrackHandle *track, const VldContext &vld)
void	FillNtpTrackCosmicRay (NtpSRCosmicRay &ntpcosmicray, const NtpSRTrack *ntptrack, const VldContext &vld)
void	FillNtpDmxStatus (NtpSRDmxStatus &ntpdmxstatus, const CandRecord *cndrec)
void	FillNtpDetStatus (NtpSRDetStatus &ntpdetstatus, const VldContext &vldc)
void	FillNtpEventSummary (NtpSREventSummary &ntpeventsummary, const CandRecord *cndrec, const RawRecord *rawrec)
void	FillNtpShield (TClonesArray &ntpshieldstriparray, NtpSRShieldSummary &ntpshieldsummary, const NtpSRTrack *ntptrack, const RawRecord *rawrec)
void	FillNtpShieldStrip (TClonesArray &ntpshieldstriparray, NtpSRShieldSummary &ntpshieldsummary, const NtpSRTrack *ntptrack, const RawRecord *rawrec)
void	FillNtpTrackProjectionToShield (NtpSRShieldSummary &ntpshieldsummary, const NtpSRTrack *ntptrack)
Private Attributes
std::map< int, int >	fStripUidMap
std::map< int, int >	fSliceUidMap
std::map< int, int >	fClusterUidMap
std::map< int, int >	fShowerUidMap
std::map< int, int >	fTrackUidMap
std::map< int, int >	fEventUidMap
Double_t	fPreTrigger
Double_t	fPostTrigger
std::string	fCandRecordName
std::string	fRecordName
std::string	fRecordTitle
bool	fUseStandard
ShieldGeom *	fShGeom
Static Private Attributes
const Double_t	kCos45 = 0.70710678

---

Constructor & Destructor Documentation

NtpSRModule::NtpSRModule (   )  [inline]

Definition at line 35 of file NtpSRModule.h. References fCandRecordName, fPostTrigger, fPreTrigger, fRecordName, fRecordTitle, fShGeom, and fUseStandard. : fPreTrigger(0),fPostTrigger(0),fCandRecordName(""), fRecordName(""),fRecordTitle(""),fUseStandard(false), fShGeom(0) {}

NtpSRModule::~NtpSRModule (   )  [inline]

Definition at line 38 of file NtpSRModule.h. {}

---

Member Function Documentation

void NtpSRModule::Config (  const Registry &  r  )  [virtual]

Return the actual configuration. If your module directly pulls its configuration from the fConfig Registry, you don't need to override this. Override if you have local config variables. Reimplemented from JobCModule. Definition at line 119 of file NtpSRModule.cxx. References fCandRecordName, fPostTrigger, fPreTrigger, fRecordName, fRecordTitle, fUseStandard, Registry::Get(), and MSG. { // // Purpose: Configure the module given a registry. // // Arguments: Registry to use to configure the module. // // Return: none. // MSG("NtpSR",Msg::kDebug) << "NtpSRModule::Config" << endl; Int_t tmpi; Double_t tmpd; const Char_t* tmps; if ( r.Get("PreTrigger",tmpi) ) fPreTrigger = fabs((Double_t)(tmpi)*1.e-9); if ( r.Get("PreTrigger",tmpd) ) fPreTrigger = fabs(tmpd*1.e-9); if ( r.Get("PostTrigger",tmpi)) fPostTrigger = fabs((Double_t)(tmpi)*1.e-9); if ( r.Get("PostTrigger",tmpd)) fPostTrigger = fabs(tmpd*1.e-9); if ( r.Get("CandRecordName",tmps) ) fCandRecordName = tmps; if ( r.Get("RecordName", tmps) ) fRecordName = tmps; if ( r.Get("RecordTitle", tmps) ) fRecordTitle = tmps; if ( r.Get("UseStandard",tmpi) ) fUseStandard = tmpi; }

const Registry & NtpSRModule::DefaultConfig (   )  const [virtual]

Get the default configuration registry. This should normally be overridden. One useful idiom is to implement it like: const Registry& MyModule::DefaultConfig() const { static Registry cfg; // never is destroyed if (cfg.Size()) return cfg; // already filled it // set defaults: cfg.Set("TheAnswer",42); cfg.Set("Units","unknown"); return cfg; } Reimplemented from JobCModule. Definition at line 88 of file NtpSRModule.cxx. References JobCModule::GetName(), Registry::LockValues(), MSG, name, Registry::Set(), and Registry::UnLockValues(). { // // Purpose: Method to return default configuration. // // Arguments: none. // // Return: Registry containing default configuration // MSG("NtpSR",Msg::kDebug) << "NtpSRModule::DefaultConfig" << endl; static Registry r; std::string name = this->JobCModule::GetName(); name += ".config.default"; r.SetName(name.c_str()); r.UnLockValues(); r.Set("PreTrigger",50.); r.Set("PostTrigger",150.); r.Set("CandRecordName", "PrimaryCandidateRecord"); r.Set("RecordName", "Primary"); r.Set("RecordTitle", "Created by NtpSRModule"); r.Set("UseStandard",0); r.LockValues(); return r; }

void NtpSRModule::FillNtpCluster (  TClonesArray &  ntpcluarray, const CandRecord *  cndrec )  [private]

Definition at line 839 of file NtpSRModule.cxx. References NtpSRCluster::AddStripAt(), NtpSRCluster::avgdev, NtpSRCluster::begplane, NtpSRCluster::endplane, fClusterUidMap, fSliceUidMap, fStripUidMap, CandSubShowerSRHandle::GetAvgDev(), CandRecoHandle::GetBegPlane(), CandClusterHandle::GetBegPlane(), CandRecoHandle::GetCharge(), CandClusterHandle::GetCharge(), CandSubShowerSRHandle::GetClusterID(), CandHandle::GetDaughterIterator(), CandRecoHandle::GetEndPlane(), CandClusterHandle::GetEndPlane(), CandSubShowerSRHandle::GetEnergy(), CandRecoHandle::GetNDigit(), CandRecoHandle::GetNPlane(), CandClusterHandle::GetNPlane(), CandRecoHandle::GetNStrip(), CandClusterHandle::GetNStrip(), CandSubShowerSRHandle::GetPlaneView(), CandClusterHandle::GetPlaneView(), CandSubShowerSRHandle::GetProbEM(), CandSubShowerSRHandle::GetSlope(), CandHandle::GetUidInt(), CandRecoHandle::GetVtxU(), CandRecoHandle::GetVtxV(), CandRecoHandle::GetVtxZ(), NtpSRStripPulseHeight::gev, NtpSRCluster::id, NtpSRCluster::index, NtpSRStripPulseHeight::mip, MSG, NtpSRCluster::ndigit, NtpSRCluster::nplane, NtpSRPulseHeight::pe, NtpSRCluster::ph, NtpSRCluster::planeview, NtpSRCluster::probem, NtpSRPulseHeight::raw, NtpSRPulseHeight::sigcor, NtpSRPulseHeight::siglin, NtpSRStripPulseHeight::sigmap, NtpSRCluster::slc, NtpSRCluster::slope, NtpSRCluster::tposvtx, and NtpSRCluster::zvtx. Referenced by Reco(). { // // Purpose: Private method used to fill cluster portion of ntuple record. // // Arguments: reference to TClonesArray of NtpSRClusters & CandRecord ptr // // Return: none. // MSG("NtpSR",Msg::kDebug) << "NtpSRModule::FillNtpCluster" << endl; Int_t ncluster = 0; const CandSubShowerSRListHandle *clusterlisthandle = dynamic_cast <const CandSubShowerSRListHandle*> (cndrec -> FindCandHandle("CandSubShowerSRListHandle")); if ( !clusterlisthandle ) { //look for CandClusterListHandle instead and fill NtpSRCluster //as well as possible const CandClusterListHandle *clulisthandle = dynamic_cast <const CandClusterListHandle*> (cndrec -> FindCandHandle("CandClusterListHandle")); if( !clulisthandle ) return; //nothing to do here TIter cluItr(clulisthandle->GetDaughterIterator()); while (CandClusterHandle* clus=dynamic_cast<CandClusterHandle*>(cluItr())){ Int_t uid = clus->GetUidInt(); fClusterUidMap.insert(std::make_pair(uid,ncluster)); // Uses new with placement to efficiently create cluster ntp NtpSRCluster* ntpcluster = new(ntpclusterarray[ncluster++])NtpSRCluster(clus->GetNStrip()); // Fill indices of associated strips in cluster tree ntpcluster->index = ncluster - 1; // index to associated slice in slice array const CandSliceHandle* clusterslice = clus -> GetCandSlice(); if ( clusterslice ) { std::map<int,int>::iterator uidItr = fSliceUidMap.find(clusterslice->GetUidInt()); if ( uidItr == fSliceUidMap.end() ) { MSG("NtpSR",Msg::kError) << "Cluster slice w/Uid " << clusterslice->GetUidInt() << " does not match any in slice list." << "\n clu slc will not be properly filled." << endl; } else { ntpcluster->slc = uidItr->second; } } else { MSG("NtpSR",Msg::kWarning) << "No associated Slice found for cluster" << endl; ntpcluster->slc = -1; } TIter clusterstripItr(clus->GetDaughterIterator()); Int_t nclusterstrip = 0; while ( CandStripHandle *clusterstrip = dynamic_cast<CandStripHandle*> (clusterstripItr()) ) { std::map<int,int>::iterator uidItr = fStripUidMap.find(clusterstrip->GetUidInt()); if ( uidItr == fStripUidMap.end() ) { MSG("NtpSR",Msg::kError) << "Cluster strip w/Uid " << clusterstrip->GetUidInt() << " does not match any in strip list." << "\n clu stp entry will not be properly filled." << endl; } else { Int_t stripindex = uidItr->second; ntpcluster->AddStripAt(stripindex,nclusterstrip); // add ind to strip } nclusterstrip++; } ntpcluster->planeview = clus->GetPlaneView(); ntpcluster->nplane = clus->GetNPlane(); ntpcluster->begplane = clus->GetBegPlane(); ntpcluster->endplane = clus->GetEndPlane(); ntpcluster->id = ClusterType::kUnknown; // Set summed charge in cluster ntpcluster->ph.raw = clus->GetCharge(); ntpcluster->ph.siglin = 0.; ntpcluster->ph.sigcor = 0.; ntpcluster->ph.pe = 0.; ntpcluster->ph.sigmap = 0.; ntpcluster->ph.mip = 0.; ntpcluster->ph.gev = 0.; MSG("NtpSR",Msg::kDebug) << "CandCluster uid " << clus -> GetUidInt() << "\n" << (*ntpcluster) << endl; } return; } //otherwise, we have CandSubShowerSRListHandle CandSubShowerSRHandleItr clusterItr(clusterlisthandle->GetDaughterIterator()); CandSubShowerSRHandleKeyFunc *engKF = clusterItr.CreateKeyFunc(); engKF->SetFun(CandSubShowerSRHandle::KeyFromViewEnergy); clusterItr.GetSet()->AdoptSortKeyFunc(engKF); engKF = 0; while (CandSubShowerSRHandle* cluster=dynamic_cast<CandSubShowerSRHandle*> (clusterItr())) { Int_t uid = cluster->GetUidInt(); fClusterUidMap.insert(std::make_pair(uid,ncluster)); // Uses new with placement to efficiently create cluster ntp NtpSRCluster* ntpcluster = new(ntpclusterarray[ncluster++])NtpSRCluster(cluster->GetNStrip()); // Fill indices of associated strips in cluster tree ntpcluster->index = ncluster - 1; // Fill index to associated slice in slice array const CandSliceHandle* clusterslice = cluster -> GetCandSlice(); if ( clusterslice ) { std::map<int,int>::iterator uidItr = fSliceUidMap.find(clusterslice->GetUidInt()); if ( uidItr == fSliceUidMap.end() ) { MSG("NtpSR",Msg::kError) << "Cluster slice w/Uid " << clusterslice->GetUidInt() << " does not match any in slice list." << "\n clu slc will not be properly filled." << endl; } else { ntpcluster->slc = uidItr->second; } } else { MSG("NtpSR",Msg::kWarning) << "No associated Slice found for cluster" << endl; ntpcluster->slc = -1; } ntpcluster->ndigit = cluster->GetNDigit(); TIter clusterstripItr(cluster->GetDaughterIterator()); Int_t nclusterstrip = 0; while ( CandStripHandle *clusterstrip = dynamic_cast<CandStripHandle*> (clusterstripItr()) ) { std::map<int,int>::iterator uidItr = fStripUidMap.find(clusterstrip->GetUidInt()); if ( uidItr == fStripUidMap.end() ) { MSG("NtpSR",Msg::kError) << "Cluster strip w/Uid " << clusterstrip->GetUidInt() << " does not match any in strip list." << "\n clu stp entry will not be properly filled." << endl; } else { Int_t stripindex = uidItr->second; ntpcluster->AddStripAt(stripindex,nclusterstrip); // add ind to strip } nclusterstrip++; } ntpcluster->planeview = cluster->GetPlaneView(); ntpcluster->nplane = cluster->GetNPlane(); ntpcluster->begplane = cluster->GetBegPlane(); ntpcluster->endplane = cluster->GetEndPlane(); ntpcluster->zvtx = cluster->GetVtxZ(); if(ntpcluster->planeview==PlaneView::kU || ntpcluster->planeview==PlaneView::kX) ntpcluster->tposvtx = cluster->GetVtxU(); else if(ntpcluster->planeview==PlaneView::kV || ntpcluster->planeview==PlaneView::kY) ntpcluster->tposvtx = cluster->GetVtxV(); ntpcluster->slope = cluster->GetSlope(); ntpcluster->avgdev = cluster->GetAvgDev(); ntpcluster->id = cluster->GetClusterID(); ntpcluster->probem = cluster->GetProbEM(); // Set summed charge in cluster ntpcluster->ph.raw = cluster->GetCharge(CalStripType::kNone); ntpcluster->ph.siglin = cluster->GetCharge(CalStripType::kSigLin); ntpcluster->ph.sigcor = cluster->GetCharge(CalStripType::kSigCorr); ntpcluster->ph.pe = cluster->GetCharge(CalStripType::kPE); ntpcluster->ph.sigmap = cluster->GetCharge(CalStripType::kSigMapped); ntpcluster->ph.mip = cluster->GetCharge(CalStripType::kMIP); ntpcluster->ph.gev = cluster->GetEnergy(); MSG("NtpSR",Msg::kDebug) << "CandSubShowerSR uid " << cluster -> GetUidInt() << "\n" << (*ntpcluster) << endl; } return; }

void NtpSRModule::FillNtpDetStatus (  NtpSRDetStatus &  ntpdetstatus, const VldContext &  vldc )  [private]

Definition at line 2187 of file NtpSRModule.cxx. References NtpSRDetStatus::coilstatus, VldContext::GetDetector(), DbiResultPtr< T >::GetNumRows(), DbiResultPtr< T >::GetRow(), and MSG. Referenced by Reco(). { // // Purpose: Private method used to fill det status portion of ntuple // record. // // Arguments: pointers to NtpSRRecord and vldc // // Return: none. // MSG("NtpSR",Msg::kDebug) << "NtpSRModule::FillNtpSRDetStatus" << endl; ntpdetstatus.coilstatus = 0; // default is unknown DbiResultPtr<BfieldCoilCurrent> coilTable(vldc); const BfieldCoilCurrent* coilCurrent = 0; if ( coilTable.GetNumRows() > 0 ) coilCurrent = coilTable.GetRow(0); if ( !coilCurrent ) return; // should issue warning? DetectorType::Detector_t dtype = vldc.GetDetector(); switch (dtype) { case DetectorType::kFar: if ( coilCurrent -> GetSm1Status() == coilCurrent -> GetSm2Status() ) ntpdetstatus.coilstatus = coilCurrent -> GetSm1Status(); break; case DetectorType::kNear: ntpdetstatus.coilstatus = coilCurrent -> GetSm1Status(); break; default: break; } MSG("NtpSR",Msg::kDebug) << ntpdetstatus << endl; return; }

void NtpSRModule::FillNtpDmxStatus (  NtpSRDmxStatus &  ntpdmxstatus, const CandRecord *  cndrec )  [private]

Definition at line 2232 of file NtpSRModule.cxx. References NtpSRDmxStatus::avgtimeoffset, CandDeMuxDigitListHandle::GetAvgTimeOffset(), CandDeMuxDigitListHandle::GetDeMuxDigitListFlagWord(), CandDeMuxDigitListHandle::GetNumStrayPlanesU(), CandDeMuxDigitListHandle::GetNumStrayPlanesV(), CandDeMuxDigitListHandle::GetNumValidPlanesU(), CandDeMuxDigitListHandle::GetNumValidPlanesV(), NtpSRDmxStatus::ismultimuon, MSG, NtpSRDmxStatus::nonphysicalfail, NtpSRDmxStatus::ustrayplanes, NtpSRDmxStatus::uvalidplanes, NtpSRDmxStatus::validplanesfail, NtpSRDmxStatus::vertexplanefail, NtpSRDmxStatus::vstrayplanes, and NtpSRDmxStatus::vvalidplanes. Referenced by Reco(). { // // Purpose: Private method used to fill dmx status portion of ntuple // record. // // Arguments: pointers to NtpSRRecord and CandRecord // // Return: none. // MSG("NtpSR",Msg::kDebug) << "NtpSRModule::FillNtpDmxStatus" << endl; const CandDeMuxDigitListHandle *dlh = dynamic_cast <const CandDeMuxDigitListHandle*> (cndrec -> FindCandHandle("CandDeMuxDigitListHandle")); if ( !dlh ) return; Int_t demuxflagword = dlh->GetDeMuxDigitListFlagWord(); if (demuxflagword & CandDeMuxDigitList::kMultipleMuonEvent) ntpdmxstatus.ismultimuon = 1; if (demuxflagword & CandDeMuxDigitList::kNonPhysicalStripSolution) ntpdmxstatus.nonphysicalfail = 1; if (demuxflagword & CandDeMuxDigitList::kTooFewValidPlanes) ntpdmxstatus.validplanesfail = 1; if (demuxflagword & CandDeMuxDigitList::kNoVertex) ntpdmxstatus.vertexplanefail = 1; ntpdmxstatus.ustrayplanes = dlh->GetNumStrayPlanesU(); ntpdmxstatus.vstrayplanes = dlh->GetNumStrayPlanesV(); ntpdmxstatus.uvalidplanes = dlh->GetNumValidPlanesU(); ntpdmxstatus.vvalidplanes = dlh->GetNumValidPlanesV(); ntpdmxstatus.avgtimeoffset = dlh->GetAvgTimeOffset(); MSG("NtpSR",Msg::kDebug) << ntpdmxstatus << endl; return; }

void NtpSRModule::FillNtpEvent (  TClonesArray &  ntpevtarray, const CandRecord *  cndrec )  [private]

Definition at line 1214 of file NtpSRModule.cxx. References NtpSRPlane::beg, NtpSRPlane::begu, NtpSRPlane::begv, NtpSRVertex::dcosu, NtpSRVertex::dcosv, NtpSRVertex::dcosx, NtpSRVertex::dcosy, NtpSRVertex::dcosz, NtpSREvent::end, NtpSRPlane::end, NtpSRPlane::endu, NtpSRPlane::endv, fEventUidMap, fShowerUidMap, fSliceUidMap, fStripUidMap, fTrackUidMap, CandRecoHandle::GetBegPlane(), CandRecoHandle::GetCharge(), CandHandle::GetDaughterIterator(), CandRecoHandle::GetEndDirCosU(), CandRecoHandle::GetEndDirCosV(), CandRecoHandle::GetEndDirCosZ(), CandRecoHandle::GetEndPlane(), CandRecoHandle::GetEndT(), CandRecoHandle::GetEndU(), CandRecoHandle::GetEndV(), CandRecoHandle::GetEndZ(), CandEventHandle::GetEnergy(), CandEventHandle::GetLastShower(), CandEventHandle::GetLastTrack(), CandRecoHandle::GetNDigit(), CandRecoHandle::GetNPlane(), CandRecoHandle::GetNStrip(), CandEventHandle::GetShower(), CandEventHandle::GetTrack(), CandHandle::GetUidInt(), CandRecoHandle::GetVtxDirCosU(), CandRecoHandle::GetVtxDirCosV(), CandRecoHandle::GetVtxDirCosZ(), CandRecoHandle::GetVtxPlane(), CandRecoHandle::GetVtxT(), CandRecoHandle::GetVtxU(), CandRecoHandle::GetVtxV(), CandRecoHandle::GetVtxZ(), NtpSRStripPulseHeight::gev, NtpSREvent::index, kCos45, NtpSRStripPulseHeight::mip, MSG, NtpSRPlane::n, NtpSREvent::ndigit, NtpSRPlane::nu, NtpSRPlane::nv, NtpSRPulseHeight::pe, NtpSREvent::ph, NtpSRVertex::plane, NtpSREvent::plane, NtpSRPulseHeight::raw, NtpSRPulseHeight::sigcor, NtpSRPulseHeight::siglin, NtpSRStripPulseHeight::sigmap, NtpSREvent::slc, NtpSRVertex::t, NtpSRVertex::u, NtpSRVertex::v, NtpSREvent::vtx, NtpSRVertex::x, NtpSRVertex::y, and NtpSRVertex::z. Referenced by Reco(). { // // Purpose: Private method used to fill event portion of ntuple record. // // Arguments: pointers to NtpSRRecord and CandRecord // // Return: status. // MSG("NtpSR",Msg::kDebug) << "NtpSRModule::FillNtpEvent" << endl; const CandEventListHandle *eventlisthandle = dynamic_cast <const CandEventListHandle*> (cndrec -> FindCandHandle("CandEventListHandle")); if (!eventlisthandle) return; // all done Int_t nevent = 0; TIter eventItr(eventlisthandle->GetDaughterIterator()); while (CandEventHandle* event=dynamic_cast<CandEventHandle*> (eventItr())) { Int_t uid = event->GetUidInt(); fEventUidMap.insert(std::make_pair(uid,nevent)); // Uses new with placement to efficiently create event ntp NtpSREvent* ntpevent = new(ntpeventarray[nevent++])NtpSREvent(event->GetNStrip(), event->GetLastShower()+1,event->GetLastTrack()+1); ntpevent->index = nevent-1; // index to associated slice in slice array const CandSliceHandle* eventslice = event -> GetCandSlice(); if ( eventslice ) { std::map<int,int>::iterator uidItr; uidItr = fSliceUidMap.find(eventslice->GetUidInt()); if ( uidItr == fSliceUidMap.end() ) { MSG("NtpSR",Msg::kError) << "Event slice w/Uid " << eventslice->GetUidInt() << " does not match any in slice list." << "\n evt slc will not be properly filled." << endl; } else { ntpevent->slc = uidItr->second; } } else { MSG("NtpSR",Msg::kWarning) << "No associated Slice found for event" << endl; ntpevent->slc = -1; } ntpevent->ndigit = event->GetNDigit(); TIter eventstripItr(event->GetDaughterIterator()); Int_t neventstrip = 0; // Fill indices of associated strips,showers,tracks in event ntuple std::map<int,int>::iterator uidItr; while ( CandStripHandle *eventstrip = dynamic_cast<CandStripHandle*> (eventstripItr())) { uidItr = fStripUidMap.find(eventstrip->GetUidInt()); if ( uidItr == fStripUidMap.end() ) { MSG("NtpSR",Msg::kError) << "Event strip w/Uid " << eventstrip->GetUidInt() << " does not match any in strip list." << "\nevt stp array will not be properly filled." << endl; } else { Int_t stripindex = uidItr->second; ntpevent -> AddStripAt(stripindex,neventstrip); } neventstrip++; } for (Int_t i = 0; i <= event->GetLastTrack(); i++ ) { const CandTrackHandle* track = event->GetTrack(i); uidItr = fTrackUidMap.find(track->GetUidInt()); if ( uidItr == fTrackUidMap.end() ) { MSG("NtpSR",Msg::kError) << "Event track w/Uid " << track->GetUidInt() << " does not match any in track list." << "\nevt trk array will not be properly filled." << endl; } else { Int_t trackindex = uidItr->second; ntpevent -> AddTrackAt(trackindex,i); } } for (Int_t i = 0; i <= event->GetLastShower(); i++ ) { const CandShowerHandle* shower = event->GetShower(i); uidItr = fShowerUidMap.find(shower->GetUidInt()); if ( uidItr == fShowerUidMap.end() ) { MSG("NtpSR",Msg::kError) << "Event shower w/Uid " << shower->GetUidInt() << " does not match any in shower list." << "\nevt shw array will not be properly filled." << endl; } else { Int_t showerindex = uidItr->second; ntpevent -> AddShowerAt(showerindex,i); } } // Set range of planes included in event ntpevent->plane.n = event->GetNPlane(); ntpevent->plane.nu = event->GetNPlane(PlaneView::kU); ntpevent->plane.nv = event->GetNPlane(PlaneView::kV); ntpevent->plane.beg = event->GetBegPlane(); ntpevent->plane.begu = event->GetBegPlane(PlaneView::kU); ntpevent->plane.begv = event->GetBegPlane(PlaneView::kV); ntpevent->plane.end = event->GetEndPlane(); ntpevent->plane.endu = event->GetEndPlane(PlaneView::kU); ntpevent->plane.endv = event->GetEndPlane(PlaneView::kV); // Set summed charge in event ntpevent->ph.raw = event->GetCharge(CalStripType::kNone); ntpevent->ph.siglin = event->GetCharge(CalStripType::kSigLin); ntpevent->ph.sigcor = event->GetCharge(CalStripType::kSigCorr); ntpevent->ph.pe = event->GetCharge(CalStripType::kPE); ntpevent->ph.sigmap = event->GetCharge(CalStripType::kSigMapped); ntpevent->ph.mip = event->GetCharge(CalStripType::kMIP); ntpevent->ph.gev = event->GetEnergy(); // Set event vertex & end NtpSRVertex& vtx = ntpevent->vtx; vtx.u = event->GetVtxU(); vtx.v = event->GetVtxV(); vtx.x = kCos45*(vtx.u - vtx.v); vtx.y = kCos45*(vtx.u + vtx.v); vtx.z = event->GetVtxZ(); vtx.t = event->GetVtxT(); vtx.plane = event->GetVtxPlane(); vtx.dcosu = event->GetVtxDirCosU(); vtx.dcosv = event->GetVtxDirCosV(); vtx.dcosx = kCos45*(vtx.dcosu - vtx.dcosv); vtx.dcosy = kCos45*(vtx.dcosu + vtx.dcosv); vtx.dcosz = event->GetVtxDirCosZ(); NtpSRVertex& end = ntpevent->end; end.u = event->GetEndU(); end.v = event->GetEndV(); end.x = kCos45*(end.u - end.v); end.y = kCos45*(end.u + end.v); end.z = event->GetEndZ(); end.t = event->GetEndT(); end.plane = event->GetEndPlane(); end.dcosu = event->GetEndDirCosU(); end.dcosv = event->GetEndDirCosV(); end.dcosx = kCos45*(end.dcosu - end.dcosv); end.dcosy = kCos45*(end.dcosu + end.dcosv); end.dcosz = event->GetEndDirCosZ(); MSG("NtpSR",Msg::kDebug) << (*ntpevent) << endl; } return; }

void NtpSRModule::FillNtpEventSummary (  NtpSREventSummary &  ntpeventsummary, const CandRecord *  cndrec, const RawRecord *  rawrec )  [private]

Definition at line 2276 of file NtpSRModule.cxx. References NtpSRPlane::beg, NtpSRPlane::begu, NtpSRPlane::begv, NtpSREventSummary::date, NtpSRDate::day, NtpSRPlane::end, NtpSRPlane::endu, NtpSRPlane::endv, fClusterUidMap, fEventUidMap, CandRecord::FindCandHandle(), fShowerUidMap, fSliceUidMap, fStripUidMap, fTrackUidMap, CandDigitListHandle::GetAbsTime(), RawDigit::GetADC(), RawDigit::GetChannel(), CandDigitHandle::GetCharge(), VldTimeStamp::GetDate(), CandDigitHandle::GetPlexSEIdAltL(), PlexHandle::GetReadoutType(), VldTimeStamp::GetSec(), RawDigit::GetTDC(), VldTimeStamp::GetTime(), Calibrator::GetTimeFromTDC(), VldContext::GetTimeStamp(), RecMinos::GetVldContext(), NtpSRDate::hour, Calibrator::Instance(), NtpSREventSummary::litime, NtpSRDate::minute, NtpSRDate::month, MSG, NtpSRPlane::n, NtpSREventSummary::ncluster, NtpSREventSummary::ndigit, NtpSREventSummary::nevent, NtpSREventSummary::nshower, NtpSREventSummary::nslice, NtpSREventSummary::nstrip, NtpSREventSummary::ntrack, NtpSRPlane::nu, NtpSRPlane::nv, NtpSRPulseHeight::pe, NtpSREventSummary::ph, NtpSREventSummary::plane, NtpSREventSummary::planeall, NtpSRPulseHeight::raw, NtpSRDate::sec, NtpSRPulseHeight::sigcor, NtpSRPulseHeight::siglin, NtpSREventSummary::trigtime, NtpSRDate::utc, and NtpSRDate::year. Referenced by Reco(). { // // Purpose: Private method used to fill event summary portion of ntuple // record. // // Arguments: pointers to NtpSRRecord and CandRecord // // Return: none. // MSG("NtpSR",Msg::kVerbose) << "NtpSRModule::FillNtpEventSummary" << endl; const CandDigitListHandle *dlh = dynamic_cast <const CandDigitListHandle*> (cndrec->FindCandHandle("CandDigitListHandle")); if ( !dlh ) return; // no digits => done ntpeventsummary.nstrip = fStripUidMap.size(); ntpeventsummary.nslice = fSliceUidMap.size(); ntpeventsummary.ncluster = fClusterUidMap.size(); ntpeventsummary.nshower = fShowerUidMap.size(); ntpeventsummary.ntrack = fTrackUidMap.size(); ntpeventsummary.nevent = fEventUidMap.size(); ntpeventsummary.trigtime = dlh->GetAbsTime(); const VldContext& vld = *(cndrec->GetVldContext()); PlexHandle plex(vld); Double_t maxliTime = -1; if ( rawrec ) { TIter blockIter = rawrec -> GetRawBlockIter(); TObject* blockobj = 0; while ( ( blockobj = blockIter.Next() ) ) { const RawDigitDataBlock* rddb = dynamic_cast<const RawDigitDataBlock*>(blockobj); if ( rddb != 0 ) { TIter digititer = rddb -> GetDatumIter(); TObject* digitobj = 0; while ( ( digitobj = digititer.Next() ) ) { RawDigit* rawdigit = dynamic_cast<RawDigit*>(digitobj); if ( rawdigit ) { RawChannelId rcid = rawdigit->GetChannel(); ReadoutType::Readout_t type = plex.GetReadoutType(rcid); if ( type == ReadoutType::kFlashTrigPMT ) { if ( rawdigit->GetADC() > 100 ) { Double_t liTime = Calibrator::Instance().GetTimeFromTDC(rawdigit->GetTDC(), rawdigit->GetChannel()); maxliTime = TMath::Max(liTime,maxliTime); } } } } } } } else { MSG("NtpSR",Msg::kWarning) << "Missing RawRecord!" << "\n evthdr.litime will not be properly filled." << endl; } ntpeventsummary.litime = maxliTime; // Fill the NtpSRDate portion of the NtpSREventSummary object UInt_t year,month,day,hour,minute,sec; vld.GetTimeStamp().GetDate(kTRUE,0,&year,&month,&day); vld.GetTimeStamp().GetTime(kTRUE,0,&hour,&minute,&sec); ntpeventsummary.date.year = (UShort_t)year; ntpeventsummary.date.month = (Char_t)month; ntpeventsummary.date.day = (Char_t)day; ntpeventsummary.date.hour = (Char_t)hour; ntpeventsummary.date.minute = (Char_t)minute; ntpeventsummary.date.sec = (Double_t)sec; ntpeventsummary.date.sec += ntpeventsummary.trigtime; ntpeventsummary.date.utc = vld.GetTimeStamp().GetSec(); Int_t minplaneall = -1; Int_t minplaneallu = -1; Int_t minplaneallv = -1; Int_t maxplaneall = -1; Int_t maxplaneallu = -1; Int_t maxplaneallv = -1; std::map<Int_t,Bool_t> planeoccupancyall; std::map<Int_t,Bool_t> planeoccupancyallu; std::map<Int_t,Bool_t> planeoccupancyallv; Float_t planepe[1000][2] = {{0},{0}}; // initializes all members to 0 // Loop over all digits TIter digitItr(dlh -> GetDaughterIterator()); while (CandDigitHandle* digit = dynamic_cast<CandDigitHandle*>(digitItr())) { // Calculate the summed pulse height of all digits (non-shield) in // the entire event PlexSEIdAltL pseid(digit->GetPlexSEIdAltL()); if (pseid.IsVetoShield()) continue; ntpeventsummary.ndigit++; ntpeventsummary.ph.raw += digit->GetCharge(CalDigitType::kNone); Float_t calcharge[3] = {0}; if ( pseid.GetDemuxVetoFlag() == 0 ) { // demux successful calcharge[0] = digit->GetCharge(CalDigitType::kSigLin); calcharge[1] = digit->GetCharge(CalDigitType::kSigCorr); calcharge[2] = digit->GetCharge(CalDigitType::kPE); } else if ( pseid.GetSize() > 0 ) { // if it wasn't demuxed, then simply use first entry calcharge[0] = pseid[0].GetSigLin(); calcharge[1] = pseid[0].GetSigCorr(); calcharge[2] = pseid[0].GetPE(); } ntpeventsummary.ph.siglin += calcharge[0]; ntpeventsummary.ph.sigcor += calcharge[1]; ntpeventsummary.ph.pe += calcharge[2]; // Now determine the range of planes. In the first case, the range of // planes is determined as the min/max plane with any digit. Int_t iplane = pseid.GetPlane(); if ( iplane < 0 || iplane >= 1000 ) continue; if ( minplaneall < 0 || iplane < minplaneall ) minplaneall = iplane; if ( maxplaneall < 0 || iplane > maxplaneall ) maxplaneall = iplane; planeoccupancyall[iplane] = kTRUE; // at least one digit on this plane switch (pseid.GetPlaneView()) { case PlaneView::kU: if (minplaneallu < 0 || iplane < minplaneallu) minplaneallu = iplane; if (maxplaneallu < 0 || iplane > maxplaneallu) maxplaneallu = iplane; planeoccupancyallu[iplane] = kTRUE; // at least one digit on this u-plane break; case PlaneView::kV: if (minplaneallv < 0 || iplane < minplaneallv) minplaneallv = iplane; if (maxplaneallv < 0 || iplane > maxplaneallv) maxplaneallv = iplane; planeoccupancyallv[iplane] = kTRUE; // at least one digit on this v-plane break; default: break; } // In the second case, the range of plane requires determining which planes // have a summed ph (over both readout ends) of > 3 pe. Store the plane // pe sum now and use it below. switch (pseid.GetEnd()) { case StripEnd::kNegative: planepe[iplane][0] += calcharge[2]; // CalDigitType::kPE break; case StripEnd::kPositive: planepe[iplane][1] += calcharge[2]; // CalDigitType::kPE break; default: break; } } // end of digit while loop ntpeventsummary.planeall.beg = minplaneall; ntpeventsummary.planeall.end = maxplaneall; ntpeventsummary.planeall.begu = minplaneallu; ntpeventsummary.planeall.endu = maxplaneallu; ntpeventsummary.planeall.begv = minplaneallv; ntpeventsummary.planeall.endv = maxplaneallv; std::map<Int_t,Bool_t>::iterator iter; for ( Int_t iplane = minplaneall; iplane <= maxplaneall; iplane ++ ) { iter = planeoccupancyall.find(iplane); // at least one digit if ( iter != planeoccupancyall.end() ) ntpeventsummary.planeall.n++; iter = planeoccupancyallu.find(iplane); // at least one digit u if ( iter != planeoccupancyallu.end() ) ntpeventsummary.planeall.nu++; iter = planeoccupancyallv.find(iplane); // at least one digit v if ( iter != planeoccupancyallv.end() ) ntpeventsummary.planeall.nv++; } // plane.beg/end is determined by first testing for 4 contiguous planes // with a summed ph > 3 pe across both ends. The minimum plane of the first // such group and the maximum plane of the last such group form plane.beg // and plane.end respectively. Int_t minplane = -1; Int_t maxplane = -1; bool found(0); for (Int_t iplane=minplaneall;iplane<=maxplaneall-3 && !found; iplane++) { if ( !found && (planepe[iplane][0] + planepe[iplane][1]) > 3. && (planepe[iplane+1][0] + planepe[iplane+1][1]) > 3. && (planepe[iplane+2][0] + planepe[iplane+2][1]) > 3. && (planepe[iplane+3][0] + planepe[iplane+3][1]) > 3. ) { found = 1; minplane = iplane; } } found = 0; for (Int_t iplane=maxplaneall;iplane>=minplaneall+3 && !found; iplane--) { if ( !found && (planepe[iplane][0] + planepe[iplane][1]) > 3. && (planepe[iplane-1][0] + planepe[iplane-1][1]) > 3. && (planepe[iplane-2][0] + planepe[iplane-2][1]) > 3. && (planepe[iplane-3][0] + planepe[iplane-3][1]) > 3. ) { found = 1; maxplane = iplane; } } Int_t minplaneu = -1; Int_t minplanev = -1; Int_t maxplaneu = -1; Int_t maxplanev = -1; for (Int_t iplane = minplane; iplane <= maxplane; iplane++ ) { if ( iplane >= 0 ) { if ( planepe[iplane][0] + planepe[iplane][1] > 0. ) { ntpeventsummary.plane.n++; // non-zero readout at either end iter = planeoccupancyallu.find(iplane); if ( iter != planeoccupancyallu.end() ) { ntpeventsummary.plane.nu++; // non-zero readout on u plane if ( minplaneu < 0 || iplane < minplaneu ) minplaneu = iplane; if ( maxplaneu < 0 || iplane > maxplaneu ) maxplaneu = iplane; } iter = planeoccupancyallv.find(iplane); if ( iter != planeoccupancyallv.end() ) { ntpeventsummary.plane.nv++; if ( minplanev < 0 || iplane < minplanev ) minplanev = iplane; if ( maxplanev < 0 || iplane > maxplanev ) maxplanev = iplane; } } } } ntpeventsummary.plane.beg = minplane; ntpeventsummary.plane.end = maxplane; ntpeventsummary.plane.begu = minplaneu; ntpeventsummary.plane.endu = maxplaneu; ntpeventsummary.plane.begv = minplanev; ntpeventsummary.plane.endv = maxplanev; MSG("NtpSR",Msg::kDebug) << ntpeventsummary << endl; return; }

void NtpSRModule::FillNtpFiducialDistance (  NtpSRFiducial &  fid, const NtpSRVertex &  vtx, const VldContext &  vld )  [private]

Definition at line 1572 of file NtpSRModule.cxx. References RawTriggerCodes::AsString(), NtpSRFiducial::dr, NtpSRFiducial::dz, VldContext::GetDetector(), UgliGeomHandle::GetZExtent(), MAXMSG, min(), NtpSRVertex::u, NtpSRVertex::v, NtpSRVertex::x, NtpSRVertex::y, and NtpSRVertex::z. Referenced by FillNtpTrackFidAll(), FillNtpTrackFidEnd(), and FillNtpTrackFidVtx(). { // // Purpose: Private method used to fill NtpSRFiducial dr and dz // data members given a point defined by NtpSRVertex and // the detector type. // // Return: none. // UgliGeomHandle ugh(vld); Float_t zextent[2]; ugh.GetZExtent(zextent[0],zextent[1]); MAXMSG("NtpSR",Msg::kDebug,1) << "Det zmin/max(m) " << zextent[0] << "/" << zextent[1] << endl; DetectorType::Detector_t dtype = vld.GetDetector(); Float_t du,dv,dx,dy; switch (dtype) { case DetectorType::kFar: du = min(4.-vtx.u,4.+vtx.u); dv = min(4.-vtx.v,4.+vtx.v); dx = min(4.-vtx.x,4.+vtx.x); dy = min(4.-vtx.y,4.+vtx.y); fid.dr = min(min(du,dv),min(dx,dy)); if ( fid.dr < 0. ) fid.dr = 0; fid.dz = min(vtx.z-zextent[0],zextent[1]-vtx.z); break; case DetectorType::kCalDet: fid.dr = min(min(0.5+vtx.x,0.5-vtx.x),min(0.5+vtx.y,0.5-vtx.y)); if ( fid.dr < 0. ) fid.dr = 0; fid.dz = min(vtx.z-zextent[0],zextent[1]-vtx.z); break; default: MAXMSG("NtpSR",Msg::kWarning,10) << "Detector '" << Detector::AsString(dtype) << "' not supported for FillNtpFiducialDistance." << endl; break; } return; }

void NtpSRModule::FillNtpShield (  TClonesArray &  ntpshieldstriparray, NtpSRShieldSummary &  ntpshieldsummary, const NtpSRTrack *  ntptrack, const RawRecord *  rawrec )  [private]

Definition at line 728 of file NtpSRModule.cxx. References FillNtpShieldStrip(), FillNtpTrackProjectionToShield(), fShGeom, VldContext::GetTimeStamp(), RecMinos::GetVldContext(), MSG, and ShieldGeom::Reinitialize(). Referenced by Reco(). { // // Purpose: Private method used to fill shield portion of ntuple. // // Arguments: NtpSRRecord // // Return: none. // // Notes: Should be called post-filling of ntp tracks // MSG("NtpSR",Msg::kDebug) << "NtpSRModule::FillNtpShield" << endl; //Getting the Shield geometry **!! Not reloaded unless VldTimeStamp obtained from rawrec is out of VldRange of ShieldGeom object (that's what "Reinitialize" does const VldContext& vldc = *(rawrec->GetVldContext()); VldTimeStamp time=vldc.GetTimeStamp(); if( !fShGeom ){ fShGeom = new ShieldGeom(time); } else{ fShGeom->Reinitialize(time); } // Fill results of projecting track to shield in shield summary first // The result of projection is used to correct timing data in shield strips // for the propagation time along the z-direction of strip this -> FillNtpTrackProjectionToShield(ntpshieldsummary,ntptrack); this -> FillNtpShieldStrip(ntpshieldstriparray,ntpshieldsummary,ntptrack, rawrec); MSG("NtpSR",Msg::kDebug) << ntpshieldsummary << endl; return; }

void NtpSRModule::FillNtpShieldStrip (  TClonesArray &  ntpshieldstriparray, NtpSRShieldSummary &  ntpshieldsummary, const NtpSRTrack *  ntptrack, const RawRecord *  rawrec )  [private]

Definition at line 406 of file NtpSRModule.cxx. References NtpSRShieldSummary::adc, NtpSRShieldStrip::adc, NtpSRShieldStrip::clearlen, NtpSRVertex::dcosx, NtpSRVertex::dcosy, NtpSRVertex::dcosz, NtpSRShieldSummary::dx, NtpSRShieldSummary::dxvetostp, fPostTrigger, fPreTrigger, fShGeom, RawDigit::GetADC(), RawDigit::GetChannel(), RawChannelId::GetCrate(), RawDigitDataBlock::GetDatumIter(), PlexStripEndId::GetEnd(), PlexPlaneId::GetPlane(), ShieldGeom::GetPlank_X(), ShieldGeom::GetPlank_Y(), RawRecord::GetRawBlockIter(), PlexHandle::GetSEIdAltL(), PlexSEIdAltL::GetSize(), PlexStripEndId::GetStrip(), UgliGeomHandle::GetStripHandle(), RawDigit::GetTDC(), RawChannelId::GetVaAdcSel(), RawChannelId::GetVaChannel(), RawChannelId::GetVaChip(), RawChannelId::GetVarcId(), RecMinos::GetVldContext(), RawChannelId::GetVmm(), NtpSRShieldStrip::index, ShieldGeom::IsVertical(), PlexSEIdAltL::IsVetoShield(), max(), min(), MSG, NtpSRShieldSummary::ndigit, NtpSRShieldStrip::ndigit, NtpSRShieldSummary::nplank, NtpSRShieldStrip::plank, NtpSRShieldStrip::pln, NtpSRShieldStrip::pmtindex, NtpSRShieldStrip::pmtpixel, NtpSRShieldSummary::projz, PlexVetoShieldHack::RenumberMuxToMdl(), NtpSRVertex::t, NtpSRShieldStrip::time, NtpSRShieldStrip::timeraw, PropagationVelocity::Velocity(), NtpSRTrack::vtx, NtpSRShieldStrip::wlspigtail, NtpSRVertex::x, NtpSRVertex::y, NtpSRVertex::z, and NtpSRShieldStrip::z. Referenced by FillNtpShield(). { // // Purpose: Private method used to fill shield strip portion of ntuple // record. // // Arguments: TClonesArray& of NtpSRShieldStrip's and CandRecord ptr // // Return: status. // const VldContext& vldc = *(rawrec->GetVldContext()); PlexHandle plexhandle(vldc); UgliGeomHandle ugh(vldc); Int_t minend = TMath::Min(StripEnd::kNegative,StripEnd::kPositive); // these constants should be taken from the database Double_t propagation_velocity = PropagationVelocity::Velocity(); Double_t c1 = -14.45; Double_t c2 = 7.498; Double_t c3 = -1.566; Double_t tracktime = 0; if ( ntptrack ) tracktime = ntptrack->vtx.t; PlexVetoShieldHack plexvetoshieldhack; TIter rdbit = rawrec->GetRawBlockIter(); TObject* tobject; // filled with NtpSRShieldStrip objects organized by time period std::vector<NtpSRShieldStrip*> shieldlist[3]; while ((tobject = rdbit())) { RawDigitDataBlock *rdb = dynamic_cast<RawDigitDataBlock*>(tobject); if ( !rdb ) continue; TIter rdit = rdb->GetDatumIter(); RawDigit* rd; while ((rd = dynamic_cast<RawDigit*>(rdit()))) { RawChannelId rawch = rd->GetChannel(); PlexSEIdAltL plexaltl = plexhandle.GetSEIdAltL(rawch); Int_t stripend = 0; if ( plexaltl.IsVetoShield() ) { PlexStripEndId oldseid = plexaltl[0].GetSEId(); const PlexStripEndId& newseid = plexvetoshieldhack.RenumberMuxToMdl(vldc,oldseid); stripend = 1 - (Int_t)(newseid.GetEnd()-minend); // so that S=0,N=1 assert(stripend >= 0 && stripend < 2); NtpSRShieldStrip* ntpshieldstrip = new NtpSRShieldStrip(); ntpshieldstrip->ndigit++; ntpshieldstrip->pln = newseid.GetPlane(); ntpshieldstrip->plank = newseid.GetStrip(); ntpshieldstrip->adc[stripend] = rd->GetADC(); ntpshieldstrip->pmtindex[stripend] = rawch.GetCrate()*108 + rawch.GetVarcId()*36 + rawch.GetVmm()*6 + rawch.GetVaAdcSel()*3 + rawch.GetVaChip(); Int_t vach2pixel[18]={0,0,15,1,16,2,11,5,12,6,7,9,8,10,3,14,4,13}; if ( rawch.GetVaChannel() >= 2 && rawch.GetVaChannel() <= 17 ) { ntpshieldstrip->pmtpixel[stripend] = vach2pixel[rawch.GetVaChannel()]; } ntpshieldstrip->timeraw[stripend] = rd->GetTDC()*1.5625e-9 + 26.e-9; // ?RWH/BR 26ns is a historical mystery // Correct for time walk Double_t logph =log((Double_t)(ntpshieldstrip->adc[stripend])/70.)/2.3; ntpshieldstrip->time[stripend] = ntpshieldstrip->timeraw[stripend] - (c1*logph + c2*logph*logph + c3*logph*logph*logph)*1.e-9; UgliStripHandle ush(ugh.GetStripHandle(newseid)); if ( ush.IsValid() ) { TVector3 stripxyz0(ush.GlobalPos(-ush.GetHalfLength())); TVector3 stripxyz1(ush.GlobalPos(ush.GetHalfLength())); ntpshieldstrip -> x = 0.5*(stripxyz0[0]+stripxyz1[0]); ntpshieldstrip -> y = 0.5*(stripxyz0[1]+stripxyz1[1]); ntpshieldstrip -> z[0] = min(stripxyz0[2],stripxyz1[2]); ntpshieldstrip -> z[1] = max(stripxyz0[2],stripxyz1[2]); // Average wlspigtail and clearlen over all strip ends for ( int i = 0; i < plexaltl.GetSize(); i++ ) { PlexStripEndId stpoldseid=plexaltl[i].GetSEId(); const PlexStripEndId& stpnewseid = plexvetoshieldhack.RenumberMuxToMdl(vldc,stpoldseid); UgliStripHandle stpush(ugh.GetStripHandle(stpnewseid)); Int_t stpstripend = 1 - (Int_t)(stpnewseid.GetEnd()-minend); // S=0,N=1 assert(stpstripend >= 0 && stpstripend < 2); ntpshieldstrip -> wlspigtail[1] += stpush.WlsPigtail(StripEnd::kNegative); ntpshieldstrip -> wlspigtail[0] += stpush.WlsPigtail(StripEnd::kPositive); ntpshieldstrip -> clearlen[1] += stpush.ClearFiber(StripEnd::kNegative); ntpshieldstrip -> clearlen[0] += stpush.ClearFiber(StripEnd::kPositive); } if ( plexaltl.GetSize() > 0 ) { for ( int iend = 0; iend < 2; iend++ ) { ntpshieldstrip->wlspigtail[iend] /=(Float_t)(plexaltl.GetSize()); ntpshieldstrip->clearlen[iend] /= (Float_t)(plexaltl.GetSize()); } } // correct for wlspigtail + clear fiber Double_t fiberlen = ntpshieldstrip->wlspigtail[stripend] + ntpshieldstrip->clearlen[stripend]; if ( fiberlen > 20. ) fiberlen = 20.; // limit bad lengths ntpshieldstrip->time[stripend] -= fiberlen/propagation_velocity; } // Time is corrected for propagation length along strip if ( ntptrack && ntpshieldsummary.projz >= ntpshieldstrip->z[0] && ntpshieldsummary.projz <= ntpshieldstrip->z[1] ) { ntpshieldstrip->time[stripend] -= fabs(ntpshieldsummary.projz -ntpshieldstrip->z[stripend])/propagation_velocity; } // determine which shield window the time of this strip fell: // pretrigger,trigger or posttrigger Int_t ishieldtime = 1; if ( (ntpshieldstrip->time[stripend]-tracktime)< -1.*fabs(fPreTrigger)) ishieldtime = 0; else if((ntpshieldstrip->time[stripend]-tracktime)>fabs(fPostTrigger)) ishieldtime = 2; ntpshieldsummary.ndigit[ishieldtime]++; ntpshieldsummary.adc[ishieldtime] += rd->GetADC();; // Search through list of shield strips in this time window to // determine if new shield strip should be merged with existing // shield strip (same plane,plank). bool isFound = false; std::vector<NtpSRShieldStrip*>::iterator vsItr; for ( vsItr = shieldlist[ishieldtime].begin(); vsItr!= shieldlist[ishieldtime].end() && !isFound; vsItr++) { NtpSRShieldStrip* liststrip = *vsItr; if ( liststrip->pln == ntpshieldstrip->pln && liststrip->plank == ntpshieldstrip->plank ) { isFound = true; liststrip->ndigit += ntpshieldstrip->ndigit; if ( liststrip->adc[stripend] == 0 ) { liststrip->timeraw[stripend] = ntpshieldstrip->timeraw[stripend]; liststrip->time[stripend] = ntpshieldstrip->time[stripend]; liststrip->wlspigtail[stripend] = ntpshieldstrip->wlspigtail[stripend]; liststrip->clearlen[stripend]=ntpshieldstrip->clearlen[stripend]; liststrip->pmtindex[stripend]=ntpshieldstrip->pmtindex[stripend]; liststrip->pmtpixel[stripend]=ntpshieldstrip->pmtpixel[stripend]; } liststrip->adc[stripend] += ntpshieldstrip->adc[stripend]; delete ntpshieldstrip; ntpshieldstrip = 0; } } if ( !isFound ) { shieldlist[ishieldtime].push_back(ntpshieldstrip); ntpshieldsummary.nplank[ishieldtime]++; } } } // Finally, loop over all strips, grouped by time interval, and produce // TClonesArray of shield strips. Entries in TClonesArray are timeordered // such that pre-trigger strips appear first, then trigger, // then post-trigger. Int_t nshieldstrip = 0; for ( int ishieldtime = 0; ishieldtime < 3; ishieldtime++ ) { std::vector<NtpSRShieldStrip*>::iterator vsItr; for ( vsItr = shieldlist[ishieldtime].begin(); vsItr!= shieldlist[ishieldtime].end(); vsItr++) { NtpSRShieldStrip* liststrip = *vsItr; // Invoke copy constructor to add strip to TClonesArray NtpSRShieldStrip& ntpstrip = *(new(ntpshieldstriparray[nshieldstrip++])NtpSRShieldStrip(*liststrip)); ntpstrip.index = nshieldstrip - 1; if ( ntptrack ) { // Project track back to shield hit and determine distance of closest // approach to any shield hit const NtpSRVertex& vtx = ntptrack -> vtx; Float_t dx; Int_t sign=1; ShieldProj sp(vtx.x,vtx.y,vtx.z,vtx.dcosx,vtx.dcosy,vtx.dcosz,ntpstrip.pln,ntpstrip.plank,fShGeom); if(sp.GetProjInter_Z() >= ntpstrip.z[0] && sp.GetProjInter_Z() <= ntpstrip.z[1]){ if(fShGeom->IsVertical(ntpstrip.pln)){ if(sp.GetProjInter_Y()-(fShGeom->GetPlank_Y(ntpstrip.pln,ntpstrip.plank)) < 0){ sign=-1; } } else{ if(sp.GetProjInter_X()-(fShGeom->GetPlank_X(ntpstrip.pln,ntpstrip.plank)) < 0){ sign=-1; } } dx=sp.GetProjDis()*sign; for(Int_t ie = 0; ie<2; ie++){ if(fabs(dx)<fabs(ntpshieldsummary.dx[ishieldtime])){ ntpshieldsummary.dx[ishieldtime] = dx; ntpshieldsummary.dxvetostp[ishieldtime] = nshieldstrip-1; } } } } // ntptrack exists delete liststrip; liststrip = 0; // done with temporary liststrip MSG("NtpSR",Msg::kDebug) << ntpstrip << endl; } } } return; }

void NtpSRModule::FillNtpShower (  TClonesArray &  ntpshwarray, const CandRecord *  cndrec )  [private]

Definition at line 1030 of file NtpSRModule.cxx. References NtpSRShower::AddStripAt(), NtpSRPlane::beg, NtpSRPlane::begu, NtpSRPlane::begv, NtpSRVertex::dcosu, NtpSRVertex::dcosv, NtpSRVertex::dcosx, NtpSRVertex::dcosy, NtpSRVertex::dcosz, NtpSRShowerPulseHeight::EMgev, NtpSRPlane::end, NtpSRPlane::endu, NtpSRPlane::endv, fClusterUidMap, fShowerUidMap, fSliceUidMap, fStripUidMap, CandRecoHandle::GetBegPlane(), CandRecoHandle::GetCharge(), CandShowerHandle::GetCluster(), CandHandle::GetDaughterIterator(), CandRecoHandle::GetDirCosU(), CandRecoHandle::GetDirCosV(), CandRecoHandle::GetDirCosZ(), CandRecoHandle::GetEndPlane(), CandShowerHandle::GetEnergy(), CandShowerHandle::GetLastCluster(), CandShowerSRHandle::GetLastSubShower(), CandRecoHandle::GetNDigit(), CandRecoHandle::GetNPlane(), CandRecoHandle::GetNStrip(), CandShowerSRHandle::GetNumSubShowersU(), CandShowerSRHandle::GetNumSubShowersV(), CandClusterHandle::GetPlaneView(), CandShowerSRHandle::GetSubShower(), CandHandle::GetUidInt(), CandRecoHandle::GetVtxPlane(), CandRecoHandle::GetVtxT(), CandRecoHandle::GetVtxU(), CandRecoHandle::GetVtxV(), CandRecoHandle::GetVtxZ(), NtpSRStripPulseHeight::gev, NtpSRShower::index, kCos45, NtpSRShowerPulseHeight::linCCgev, NtpSRShowerPulseHeight::linNCgev, NtpSRStripPulseHeight::mip, MSG, NtpSRPlane::n, NtpSRShower::ncluster, NtpSRShower::ndigit, NtpSRPlane::nu, NtpSRShower::nUcluster, NtpSRPlane::nv, NtpSRShower::nVcluster, NtpSRPulseHeight::pe, NtpSRShower::ph, NtpSRVertex::plane, NtpSRShower::plane, NtpSRPulseHeight::raw, NtpSRShower::shwph, NtpSRPulseHeight::sigcor, NtpSRPulseHeight::siglin, NtpSRStripPulseHeight::sigmap, NtpSRShower::slc, NtpSRVertex::t, NtpSRVertex::u, NtpSRVertex::v, NtpSRShower::vtx, NtpSRShowerPulseHeight::wtCCgev, NtpSRShowerPulseHeight::wtNCgev, NtpSRVertex::x, NtpSRVertex::y, and NtpSRVertex::z. Referenced by Reco(). { // // Purpose: Private method used to fill shower portion of ntuple record. // // Arguments: reference to TClonesArray of NtpSRShowers and CandRecord ptr // // Return: status. // MSG("NtpSR",Msg::kDebug) << "NtpSRModule::FillNtpShower" << endl; const CandShowerListHandle *showerlisthandle = dynamic_cast <const CandShowerListHandle*> (cndrec -> FindCandHandle("CandShowerListHandle")); if ( !showerlisthandle ) return; // all done Int_t nshower = 0; TIter showerItr(showerlisthandle->GetDaughterIterator()); while (CandShowerHandle* shower=dynamic_cast<CandShowerHandle*> (showerItr())) { Int_t uid = shower->GetUidInt(); fShowerUidMap.insert(std::make_pair(uid,nshower)); // Uses new with placement to efficiently create slice ntp NtpSRShower* ntpshower = 0; if (shower -> InheritsFrom("CandShowerSRHandle")) { CandShowerSRHandle* showerSR = dynamic_cast<CandShowerSRHandle*>(shower); ntpshower = new(ntpshowerarray[nshower++])NtpSRShower(showerSR->GetNStrip(), showerSR->GetNumSubShowersU()+showerSR->GetNumSubShowersV()); } else { ntpshower=new(ntpshowerarray[nshower++])NtpSRShower(shower->GetNStrip(), shower->GetLastCluster()+1); } ntpshower -> nstpcnt = shower->GetNStrip(); // Fill indices of associated strips in shower tree ntpshower->index = nshower - 1; // index to associated slice in slice array const CandSliceHandle* showerslice = shower -> GetCandSlice(); if ( showerslice ) { std::map<int,int>::iterator uidItr; uidItr = fSliceUidMap.find(showerslice->GetUidInt()); if ( uidItr == fSliceUidMap.end() ) { MSG("NtpSR",Msg::kError) << "Shower slice w/Uid " << showerslice->GetUidInt() << " does not match any in slice list." << "\n shw slc will not be properly filled." << endl; } else { ntpshower->slc = uidItr->second; } } else { MSG("NtpSR",Msg::kWarning) << "No associated Slice found for shower" << endl; ntpshower->slc = -1; } ntpshower->ndigit = shower->GetNDigit(); TIter showerstripItr(shower->GetDaughterIterator()); Int_t nshowerstrip = 0; while ( CandStripHandle *showerstrip = dynamic_cast<CandStripHandle*> (showerstripItr()) ) { Int_t uid = showerstrip->GetUidInt(); std::map<int,int>::iterator uidItr; uidItr = fStripUidMap.find(uid); if ( uidItr == fStripUidMap.end() ) { MSG("NtpSR",Msg::kError) << "Shower strip w/Uid " << uid << " does not match any in strip list." << "\n shw stp entry will not be properly filled." << endl; } else { Int_t stripindex = uidItr->second; ntpshower->AddStripAt(stripindex,nshowerstrip); // add index to strip } nshowerstrip++; } // cluster stuff: ntpshower->ncluster = 0; ntpshower->nUcluster = 0; ntpshower->nVcluster = 0; if ( shower -> InheritsFrom("CandShowerSRHandle") ) { CandShowerSRHandle* showerSR = dynamic_cast<CandShowerSRHandle*>(shower); ntpshower->ncluster = showerSR->GetLastSubShower()+1; if ( showerSR -> GetLastSubShower() + 1 > 0 ) { ntpshower -> nUcluster = showerSR->GetNumSubShowersU(); ntpshower -> nVcluster = showerSR->GetNumSubShowersV(); for ( int i = 0; i < ntpshower->ncluster; i++ ) { const CandSubShowerSRHandle* showercluster=showerSR->GetSubShower(i); Int_t uid = showercluster->GetUidInt(); std::map<int,int>::iterator uidItr = fClusterUidMap.find(uid); if ( uidItr == fClusterUidMap.end() ) { MSG("NtpSR",Msg::kError) << "Shower CandSubShowerSR w/Uid " << uid << " does not match any in cluster list." << " shw clu entry will not be properly filled." << endl; } else { Int_t clusterindex = uidItr->second; ntpshower -> AddClusterAt(clusterindex,i); } } } } else { ntpshower->ncluster = shower->GetLastCluster()+1; for (int i = 0; i < ntpshower->ncluster; i++ ) { const CandClusterHandle* showercluster = shower->GetCluster(i); Int_t uid = showercluster->GetUidInt(); std::map<int,int>::iterator uidItr = fClusterUidMap.find(uid); if ( uidItr == fClusterUidMap.end() ) { MSG("NtpSR",Msg::kError) << "\nShower CandCluster of index " << i << " (of " << ntpshower->ncluster << " clusters) w/Uid " << uid << " does not match any in cluster list." << "\nshw clu entry for CandShower of index " << ntpshower->index << " w/Uid " << shower->GetUidInt() << " will not be properly filled!" << endl; } else { Int_t clusterindex = uidItr->second; ntpshower -> AddClusterAt(clusterindex,i); } if ( showercluster->GetPlaneView() == PlaneView::kU ) ntpshower->nUcluster += 1; else if (showercluster->GetPlaneView() == PlaneView::kV ) ntpshower->nVcluster += 1; } } // Set range of planes included in slice ntpshower->plane.n = shower->GetNPlane(); ntpshower->plane.nu = shower->GetNPlane(PlaneView::kU); ntpshower->plane.nv = shower->GetNPlane(PlaneView::kV); ntpshower->plane.beg = shower->GetBegPlane(); ntpshower->plane.begu = shower->GetBegPlane(PlaneView::kU); ntpshower->plane.begv = shower->GetBegPlane(PlaneView::kV); ntpshower->plane.end = shower->GetEndPlane(); ntpshower->plane.endu = shower->GetEndPlane(PlaneView::kU); ntpshower->plane.endv = shower->GetEndPlane(PlaneView::kV); // Set summed charge in shower ntpshower->ph.raw = shower->GetCharge(CalStripType::kNone); ntpshower->ph.siglin = shower->GetCharge(CalStripType::kSigLin); ntpshower->ph.sigcor = shower->GetCharge(CalStripType::kSigCorr); ntpshower->ph.pe = shower->GetCharge(CalStripType::kPE); ntpshower->ph.sigmap = shower->GetCharge(CalStripType::kSigMapped); ntpshower->ph.mip = shower->GetCharge(CalStripType::kMIP); ntpshower->ph.gev = shower->GetEnergy(CandShowerHandle::kWtCC); ntpshower->shwph.wtCCgev = shower->GetEnergy(CandShowerHandle::kWtCC); ntpshower->shwph.linCCgev = shower->GetEnergy(CandShowerHandle::kCC); ntpshower->shwph.wtNCgev = shower->GetEnergy(CandShowerHandle::kWtNC); ntpshower->shwph.linNCgev = shower->GetEnergy(CandShowerHandle::kNC); ntpshower->shwph.EMgev = shower->GetEnergy(CandShowerHandle::kEM); // Set vertex of shower NtpSRVertex& vtx = ntpshower->vtx; vtx.u = shower->GetVtxU(); vtx.v = shower->GetVtxV(); vtx.x = kCos45*(vtx.u-vtx.v); vtx.y = kCos45*(vtx.u+vtx.v); vtx.z = shower->GetVtxZ(); vtx.t = shower->GetVtxT(); vtx.plane = shower->GetVtxPlane(); vtx.dcosu = shower->GetDirCosU(); vtx.dcosv = shower->GetDirCosV(); vtx.dcosx = kCos45*(vtx.dcosu-vtx.dcosv); vtx.dcosy = kCos45*(vtx.dcosu+vtx.dcosv); vtx.dcosz = shower->GetDirCosZ(); MSG("NtpSR",Msg::kDebug) << "CandShower uid " << shower -> GetUidInt() << "\n" << (*ntpshower) << endl; } return; }

void NtpSRModule::FillNtpSlice (  TClonesArray &  ntpslcarray, const CandRecord *  cndrec )  [private]

Definition at line 766 of file NtpSRModule.cxx. References NtpSRSlice::AddStripAt(), NtpSRPlane::beg, NtpSRPlane::begu, NtpSRPlane::begv, NtpSRPlane::end, NtpSRPlane::endu, NtpSRPlane::endv, fSliceUidMap, fStripUidMap, CandSliceHandle::GetBegPlane(), CandSliceHandle::GetCharge(), CandHandle::GetDaughterIterator(), CandSliceHandle::GetEndPlane(), CandSliceHandle::GetNDigit(), CandSliceHandle::GetNPlane(), CandSliceHandle::GetNStrip(), CandHandle::GetUidInt(), NtpSRSlice::index, MSG, NtpSRPlane::n, NtpSRSlice::ndigit, NtpSRPlane::nu, NtpSRPlane::nv, NtpSRPulseHeight::pe, NtpSRSlice::ph, NtpSRSlice::plane, NtpSRPulseHeight::raw, NtpSRPulseHeight::sigcor, and NtpSRPulseHeight::siglin. Referenced by Reco(). { // // Purpose: Private method used to fill slice portion of ntuple record. // // Arguments: reference to TClonesArray of NtpSRSlice's and CandRecord ptr // // Return: status. // MSG("NtpSR",Msg::kDebug) << "NtpSRModule::FillNtpSlice" << endl; const CandSliceListHandle *slicelisthandle = dynamic_cast <const CandSliceListHandle*> (cndrec -> FindCandHandle("CandSliceListHandle")); if ( !slicelisthandle ) return; // all done Int_t nslice = 0; TIter sliceItr(slicelisthandle->GetDaughterIterator()); while ( CandSliceHandle* slice=dynamic_cast<CandSliceHandle*>(sliceItr())) { Int_t uid = slice->GetUidInt(); fSliceUidMap.insert(std::make_pair(uid,nslice)); // Uses new with placement to efficiently create slice ntp NtpSRSlice* ntpslice = new(ntpslicearray[nslice++]) NtpSRSlice(slice->GetNStrip()); ntpslice->index = nslice-1; // index is number of slices - 1 ntpslice->ndigit = slice->GetNDigit(); // Fill indices of associated strips in slice tree TIter slicestripItr(slice->GetDaughterIterator()); Int_t nslicestrip = 0; while ( CandStripHandle *slicestrip = dynamic_cast<CandStripHandle*> (slicestripItr())) { Int_t uid = slicestrip->GetUidInt(); std::map<int,int>::iterator uidItr; uidItr = fStripUidMap.find(uid); if ( uidItr == fStripUidMap.end() ) { MSG("NtpSR",Msg::kError) << "Slice strip w/Uid " << uid << " does not match any in strip list." << "\n slc stp entry will not be properly filled." << endl; } else { Int_t stripindex = uidItr->second; ntpslice->AddStripAt(stripindex,nslicestrip); // add index to strip } nslicestrip++; } // Set summed charge in slice ntpslice->ph.raw = slice->GetCharge(CalDigitType::kNone); ntpslice->ph.siglin = slice->GetCharge(CalDigitType::kSigLin); ntpslice->ph.sigcor = slice->GetCharge(CalDigitType::kSigCorr); ntpslice->ph.pe = slice->GetCharge(CalDigitType::kPE); // Set range of planes included in slice ntpslice->plane.n =slice->GetNPlane(); ntpslice->plane.beg = slice->GetBegPlane(); ntpslice->plane.end = slice->GetEndPlane(); ntpslice->plane.nu = slice->GetNPlane(PlaneView::kU); ntpslice->plane.begu = slice->GetBegPlane(PlaneView::kU); ntpslice->plane.endu = slice->GetEndPlane(PlaneView::kU); ntpslice->plane.nv = slice->GetNPlane(PlaneView::kV); ntpslice->plane.begv = slice->GetBegPlane(PlaneView::kV); ntpslice->plane.endv = slice->GetEndPlane(PlaneView::kV); MSG("NtpSR",Msg::kDebug) << "CandSlice uid " << slice-> GetUidInt() << "\n" << (*ntpslice) << endl; } return; }

void NtpSRModule::FillNtpStrip (  TClonesArray &  ntpstparray, const CandRecord *  cndrec )  [private]

Definition at line 332 of file NtpSRModule.cxx. References NtpSRStrip::demuxveto, CandRecord::FindCandHandle(), fStripUidMap, CandDigitHandle::GetChannelId(), CandStripHandle::GetCharge(), RawChannelId::GetCrate(), CandHandle::GetDaughterIterator(), CandStripHandle::GetDemuxVetoFlag(), CandStripHandle::GetNDigit(), CandStripHandle::GetPlane(), CandStripHandle::GetPlaneView(), CandStripHandle::GetStrip(), CandStripHandle::GetTime(), CandStripHandle::GetTPos(), CandHandle::GetUidInt(), RawChannelId::GetVaAdcSel(), RawChannelId::GetVaChip(), RawChannelId::GetVarcId(), RawChannelId::GetVmm(), CandStripHandle::GetZPos(), NtpSRStrip::index, MSG, NtpSRStrip::ndigit, NtpSRPulseHeight::pe, NtpSRStrip::plane, NtpSRStrip::planeview, NtpSRPulseHeight::raw, NtpSRStrip::SetPh(), NtpSRStrip::SetPmtIndex(), NtpSRStrip::SetTime(), NtpSRPulseHeight::sigcor, NtpSRPulseHeight::siglin, NtpSRStrip::strip, NtpSRStrip::tpos, and NtpSRStrip::z. Referenced by Reco(). { // // Purpose: Private method used to fill strip portion of ntuple record. // // Arguments: NtpSRRecord and CandRecord // // Return: status. // MSG("NtpSR",Msg::kDebug) << "NtpSRModule::FillNtpStrip" << endl; const CandStripListHandle *striplisthandle = dynamic_cast <const CandStripListHandle*> (cndrec->FindCandHandle("CandStripListHandle")); if ( !striplisthandle ) return; // no strips => done Int_t nstrip = 0; TIter stripItr(striplisthandle->GetDaughterIterator()); while ( CandStripHandle* strip=dynamic_cast<CandStripHandle*>(stripItr())) { Int_t uid = strip->GetUidInt(); fStripUidMap.insert(std::make_pair(uid,nstrip)); // Uses new with placement to efficiently create strip ntp NtpSRStrip* ntpstrip = new((ntpstriparray)[nstrip++])NtpSRStrip(); // Transport information from CandStrip to strip ntp ntpstrip->index = nstrip-1; ntpstrip->planeview = strip->GetPlaneView(); // plane view ntpstrip->ndigit = strip->GetNDigit(); ntpstrip->demuxveto = strip->GetDemuxVetoFlag(); ntpstrip->strip = strip->GetStrip(); // strip number ntpstrip->plane = strip->GetPlane(); // plane number ntpstrip->tpos = strip->GetTPos(); // tpos ntpstrip->z = strip->GetZPos(); // zpos // Raw channel id of first digit associated with each end bool negEndDone = false; bool posEndDone = false; TIter digitItr(strip -> GetDaughterIterator()); while (CandDigitHandle* digit=dynamic_cast<CandDigitHandle*>(digitItr())) { const RawChannelId& rawch = digit->GetChannelId(); Int_t pmtindex = rawch.GetCrate()*108 + rawch.GetVarcId()*36 +rawch.GetVmm()*6 + rawch.GetVaAdcSel()*3+rawch.GetVaChip(); if ( !negEndDone && digit -> GetPlexSEIdAltL().GetEnd()==StripEnd::kNegative) { ntpstrip->SetPmtIndex(pmtindex,0); negEndDone = true; } else if( !posEndDone && digit -> GetPlexSEIdAltL().GetEnd()==StripEnd::kPositive) { ntpstrip->SetPmtIndex(pmtindex,1); posEndDone = true; } } // Strip end dependent quantities for (UInt_t i = 0; i < 2; i++ ) { StripEnd::EStripEnd stripend = StripEnd::kNegative; if (i == 1) stripend = StripEnd::kPositive; if ( strip->GetNDigit(stripend) > 0 ) { NtpSRPulseHeight ph; ph.raw = strip->GetCharge(CalDigitType::kNone,stripend); ph.siglin = strip->GetCharge(CalDigitType::kSigLin,stripend); ph.sigcor = strip->GetCharge(CalDigitType::kSigCorr,stripend); ph.pe = strip->GetCharge(CalDigitType::kPE,stripend); ntpstrip->SetPh(ph,i); ntpstrip->SetTime(strip->GetTime(stripend),i); } } MSG("NtpSR",Msg::kVerbose) << (*ntpstrip) << endl; } // done with all strips return; }

void NtpSRModule::FillNtpTrack (  TClonesArray &  ntptrkarray, const CandRecord *  cndrec )  [private]

Definition at line 1371 of file NtpSRModule.cxx. References NtpSRTrack::AddStripAt(), NtpSRPlane::beg, NtpSRPlane::begu, NtpSRPlane::begv, NtpSRTrack::cputime, NtpSRTrack::cr, Calibrator::DecalStripToStrip(), Calibrator::DecalTime(), NtpSRTrack::ds, NtpSRPlane::end, NtpSRPlane::endu, NtpSRPlane::endv, FillNtpTrackCosmicRay(), FillNtpTrackEnd(), FillNtpTrackFidAll(), FillNtpTrackFidEnd(), FillNtpTrackFidVtx(), FillNtpTrackFit(), FillNtpTrackLinearFit(), FillNtpTrackMomentum(), FillNtpTrackTime(), FillNtpTrackVertex(), CandRecord::FindCandHandle(), fSliceUidMap, fStripUidMap, fTrackUidMap, CandFitTrackSRHandle::GetBadFit(), CandRecoHandle::GetBegPlane(), CandStripHandle::GetCharge(), CandRecoHandle::GetCharge(), CandTrackSRListHandle::GetCPUTime(), CandHandle::GetDaughterIterator(), CandTrackHandle::GetdS(), CandRecoHandle::GetEndPlane(), CandHandle::GetNDaughters(), CandStripHandle::GetNDigit(), CandRecoHandle::GetNDigit(), CandRecoHandle::GetNPlane(), CandRecoHandle::GetNStrip(), CandFitTrackSRHandle::GetNTrackPlane(), CandTrackSRHandle::GetNTrackPlane(), CandStripHandle::GetPlane(), CandFitTrackSRHandle::GetPlaneChi2(), CandFitTrackSRHandle::GetPlanePreChi2(), CandFitTrackSRHandle::GetPlaneQP(), CandTrackHandle::GetRange(), CandRecoHandle::GetStripCharge(), CandStripHandle::GetStripEndId(), CandTrackHandle::GetT(), CandTrackHandle::GetU(), CandHandle::GetUidInt(), CandTrackHandle::GetV(), RecMinos::GetVldContext(), CandTrackHandle::GetZ(), NtpSRStripPulseHeight::gev, NtpSRTrack::index, Calibrator::Instance(), kCos45, NtpSRStripPulseHeight::mip, MSG, NtpSRPlane::n, NtpSRTrack::ndigit, NtpSRTrackPlane::ntrklike, NtpSRPlane::nu, NtpSRPlane::nv, NtpSRPulseHeight::pe, NtpSRTrack::ph, NtpSRTrack::plane, NtpSRTrack::range, NtpSRPulseHeight::raw, NtpSRTrack::SetAttnC0(), NtpSRTrack::SetCalT0(), NtpSRTrack::SetPh(), NtpSRTrack::SetTime(), NtpSRPulseHeight::sigcor, NtpSRPulseHeight::siglin, NtpSRStripPulseHeight::sigmap, NtpSRTrack::slc, NtpSRTrack::stpds, NtpSRTrack::stpfit, NtpSRTrack::stpfitchi2, NtpSRTrack::stpfitprechi2, NtpSRTrack::stpfitqp, NtpSRTrack::stpu, NtpSRTrack::stpv, NtpSRTrack::stpx, NtpSRTrack::stpy, and NtpSRTrack::stpz. Referenced by Reco(). { // // Purpose: Private method used to fill track portion of ntuple record. // // Arguments: TClonesArray of NtpSRTrack's and CandRecord ptr // // Return: none. // MSG("NtpSR",Msg::kDebug) << "NtpSRModule::FillNtpTrack" << endl; const CandTrackListHandle *tracklisthandle = dynamic_cast <const CandTrackListHandle*> (cndrec -> FindCandHandle("CandFitTrackListHandle")); if ( !tracklisthandle ) { tracklisthandle = dynamic_cast <const CandTrackListHandle*> (cndrec -> FindCandHandle("CandTrackListHandle")); } if ( !tracklisthandle ) return; CandTrackSRListHandle* tracksrlisthandle=dynamic_cast<CandTrackSRListHandle*> (cndrec->FindCandHandle("CandTrackSRListHandle")); const VldContext& vld = *(cndrec->GetVldContext()); TIter trackItr(tracklisthandle->GetDaughterIterator()); Int_t ntrack = 0; while (CandTrackHandle* track = dynamic_cast<CandTrackHandle*>(trackItr())){ if(track->GetNDaughters()==0 && track->InheritsFrom("CandFitTrackHandle") && dynamic_cast<CandFitTrackHandle*>(track)->GetFinderTrack()){ track = dynamic_cast<CandFitTrackHandle*>(track)->GetFinderTrack(); } Int_t uid = track->GetUidInt(); fTrackUidMap.insert(std::make_pair(uid,ntrack)); // Uses new with placement to efficiently create event ntp NtpSRTrack* ntptrack = new(ntptrackarray[ntrack++])NtpSRTrack(track->GetNStrip()); ntptrack->index = ntrack-1; // index to associated slice in slice array const CandSliceHandle* trackslice = track -> GetCandSlice(); if ( trackslice ) { std::map<int,int>::iterator uidItr; uidItr = fSliceUidMap.find(trackslice->GetUidInt()); if ( uidItr == fSliceUidMap.end() ) { MSG("NtpSR",Msg::kError) << "Track slice w/Uid " << trackslice->GetUidInt() << " does not match any in slice list." << "\n trk slc will not be properly filled." << endl; } else { ntptrack->slc = uidItr->second; } } else { MSG("NtpSR",Msg::kWarning) << "No associated Slice found for track" << endl; ntptrack->slc = -1; } ntptrack->ndigit = track->GetNDigit(); CandTrackSRHandle *tracksr = dynamic_cast<CandTrackSRHandle*>(track); //CandFitTrackHandle *fittrack = dynamic_cast<CandFitTrackHandle*>(track); CandFitTrackSRHandle *fittracksr =dynamic_cast<CandFitTrackSRHandle*>(track); // Set range of planes included in track NtpSRTrackPlane& plane = ntptrack->plane; plane.n = track->GetNPlane(); plane.nu = track->GetNPlane(PlaneView::kU); plane.nv = track->GetNPlane(PlaneView::kV); plane.beg = track->GetBegPlane(); plane.begu = track->GetBegPlane(PlaneView::kU); plane.begv = track->GetBegPlane(PlaneView::kV); plane.end = track->GetEndPlane(); plane.endu = track->GetEndPlane(PlaneView::kU); plane.endv = track->GetEndPlane(PlaneView::kV); if (tracksr) plane.ntrklike = tracksr->GetNTrackPlane(); if (fittracksr) plane.ntrklike = fittracksr->GetNTrackPlane(); // Set summed pulse height information for track NtpSRStripPulseHeight& ph = ntptrack->ph; ph.raw = track->GetCharge(CalStripType::kNone); ph.siglin = track->GetCharge(CalStripType::kSigLin); ph.sigcor = track->GetCharge(CalStripType::kSigCorr); ph.pe = track->GetCharge(CalStripType::kPE); ph.sigmap = track->GetCharge(CalStripType::kSigMapped); ph.mip = track->GetCharge(CalStripType::kMIP); ph.gev = track->GetCharge(CalStripType::kGeV); ntptrack->ds = track->GetdS(); // distance from vertex to end ntptrack->range = track->GetRange(); // g/cm**2 from vertex to end // CPU to create track list if (tracksrlisthandle) ntptrack->cputime = tracksrlisthandle->GetCPUTime(); this->FillNtpTrackVertex(ntptrack,track); this->FillNtpTrackEnd(ntptrack,track); this->FillNtpTrackLinearFit(ntptrack,track); this->FillNtpTrackFidVtx(ntptrack,track,vld); this->FillNtpTrackFidEnd(ntptrack,track,vld); this->FillNtpTrackFidAll(ntptrack,track,vld); this->FillNtpTrackFit(ntptrack,track); this->FillNtpTrackMomentum(ntptrack,track); this->FillNtpTrackTime(ntptrack,track); NtpSRCosmicRay& ntpcosmicray = ntptrack->cr; this->FillNtpTrackCosmicRay(ntpcosmicray,ntptrack,vld); // Loop over strips associated with track TIter trackstripItr(track->GetDaughterIterator()); Int_t ntrackstrip = 0; // Fill indices of associated strips in track ntuple while ( CandStripHandle *trackstrip = dynamic_cast<CandStripHandle*> (trackstripItr())) { Int_t uid = trackstrip->GetUidInt(); std::map<int,int>::iterator uidItr; uidItr = fStripUidMap.find(uid); if ( uidItr == fStripUidMap.end() ) { MSG("NtpSR",Msg::kError) << "Track strip w/Uid " << uid << " does not match any in strip list." << "\n trk stp entry will not be properly filled." << endl; } else { Int_t stripindex = uidItr->second; ntptrack->AddStripAt(stripindex,ntrackstrip); // add index to strip } // Track positional information at plane associated with each strip Int_t iplane = trackstrip->GetPlane(); ntptrack->stpu[ntrackstrip] = track->GetU(iplane); ntptrack->stpv[ntrackstrip] = track->GetV(iplane); ntptrack->stpx[ntrackstrip] = kCos45*(ntptrack->stpu[ntrackstrip] -ntptrack->stpv[ntrackstrip]); ntptrack->stpy[ntrackstrip] = kCos45*(ntptrack->stpu[ntrackstrip] +ntptrack->stpv[ntrackstrip]); ntptrack->stpz[ntrackstrip] = track->GetZ(iplane); // dS is travel distance from vertex ntptrack->stpds[ntrackstrip] = track->GetdS(iplane); // Fit track dependent quantities if ( fittracksr ) { ntptrack->stpfitchi2[ntrackstrip] = fittracksr->GetPlaneChi2(iplane); ntptrack->stpfitprechi2[ntrackstrip] = fittracksr->GetPlanePreChi2(iplane); ntptrack->stpfitqp[ntrackstrip] = fittracksr->GetPlaneQP(iplane); if ( fittracksr->GetBadFit(iplane) ) ntptrack->stpfit[ntrackstrip] = 0; } else{ ntptrack->stpfitchi2[ntrackstrip] = 0; ntptrack->stpfitprechi2[ntrackstrip] =0; ntptrack->stpfitqp[ntrackstrip] = 0; ntptrack->stpfit[ntrackstrip] = 0; } // Strip end dependent quantities for (UInt_t i = 0; i < 2; i++ ) { StripEnd::EStripEnd stripend = StripEnd::kNegative; if (i == 1) stripend = StripEnd::kPositive; if ( trackstrip->GetNDigit(stripend) > 0 ) { Float_t sigmap = track->GetStripCharge(trackstrip, CalStripType::kSigMapped,stripend); Float_t mip = track->GetStripCharge(trackstrip, CalStripType::kMIP,stripend); Float_t gev = track->GetStripCharge(trackstrip, CalStripType::kGeV,stripend); ntptrack->SetPh(sigmap,mip,gev,ntrackstrip,i); ntptrack->SetTime(track->GetT(iplane,stripend),ntrackstrip,i); // New, NJT 07/04 // Will now fill with default values if real ones don't exist. // Uses Calibrator configuration, not a custom thing. // Use DecalStripToStrip on input charge 1 to get muon C0 double c0 = Calibrator::Instance().DecalStripToStrip(1.0, trackstrip->GetStripEndId(stripend)); ntptrack->SetAttnC0(c0,ntrackstrip,i); // Use DecalTime on input time 0 to get time offset double t0 = Calibrator::Instance().DecalTime(0.0, trackstrip->GetCharge(CalDigitType::kNone,stripend), trackstrip->GetStripEndId(stripend)); ntptrack->SetCalT0(t0,ntrackstrip,i); } } ntrackstrip++; } // loop over all track strips MSG("NtpSR",Msg::kDebug) << (*ntptrack) << endl; } return; }

void NtpSRModule::FillNtpTrackCosmicRay (  NtpSRCosmicRay &  ntpcosmicray, const NtpSRTrack *  ntptrack, const VldContext &  vld )  [private]

Definition at line 1662 of file NtpSRModule.cxx. References NtpSRCosmicRay::azimuth, AstUtil::CalendarToJulian(), NtpSRVertex::dcosx, NtpSRVertex::dcosy, NtpSRVertex::dcosz, NtpSRCosmicRay::dec, AstUtil::EquatorialToCelestial(), VldTimeStamp::GetDate(), VldContext::GetDetector(), AstUtil::GetDetLatitude(), AstUtil::GetDetLongitude(), VldTimeStamp::GetTime(), VldContext::GetTimeStamp(), AstUtil::GSTToLST(), AstUtil::HorizonToEquatorial(), NtpSRCosmicRay::juliandate, AstUtil::JulianToGAST(), AstUtil::LocalToHorizon(), NtpSRCosmicRay::locsiderialtime, MSG, NtpSRCosmicRay::ra, NtpSRCosmicRay::rahourangle, NtpSRTrack::vtx, and NtpSRCosmicRay::zenith. Referenced by FillNtpTrack(), and Reco(). { // // Purpose: Private method used to fill NtpSRTrack cr data member // given a pointer to the ntuple track and a pointer to the // associated CandTrackHandle. // // Return: none. // MSG("NtpSR",Msg::kVerbose) << "NtpSRModule::FillNtpTrackCosmicRay" << endl; if ( !ntptrack ) return; DetectorType::Detector_t dettype = vldc.GetDetector(); // Reverse sign for pointing track back up to source Float_t dcosx = -(ntptrack->vtx.dcosx); Float_t dcosy = -(ntptrack->vtx.dcosy); Float_t dcosz = -(ntptrack->vtx.dcosz); Double_t altitude,azimuth; AstUtil::LocalToHorizon(dcosx,dcosy,dcosz,dettype,altitude,azimuth); // Zenith = 90 - altitude ntpcosmicray.zenith = 90. - altitude; ntpcosmicray.azimuth = azimuth; UInt_t dyear,dmonth,dday,dhour,dminute,dsec; vldc.GetTimeStamp().GetDate(kTRUE,0,&dyear,&dmonth,&dday); vldc.GetTimeStamp().GetTime(kTRUE,0,&dhour,&dminute,&dsec); int year = dyear; int month = dmonth; int day = dday; double hour = dhour + (dminute + (dsec)/60.)/60.; AstUtil::CalendarToJulian(year,month,day,hour,ntpcosmicray.juliandate); double longitude = AstUtil::GetDetLongitude(dettype); double latitude = AstUtil::GetDetLatitude(dettype); double gast; // in hours AstUtil::JulianToGAST(ntpcosmicray.juliandate,gast); double last; AstUtil::GSTToLST(gast,longitude,last); // sidereal time misspelled here for historical consistency ntpcosmicray.locsiderialtime = last; double hourangle, declination; AstUtil::HorizonToEquatorial(altitude,azimuth,latitude,hourangle, declination); ntpcosmicray.dec = declination; double ra; AstUtil::EquatorialToCelestial(hourangle,gast,longitude,ra); ntpcosmicray.ra = ra; ntpcosmicray.rahourangle = ntpcosmicray.ra*12./180.; // hours return; }

void NtpSRModule::FillNtpTrackEnd (  NtpSRTrack *  ntptrack, const CandTrackHandle *  track )  [private]

Definition at line 2037 of file NtpSRModule.cxx. References NtpSRVertex::dcosu, NtpSRVertex::dcosv, NtpSRVertex::dcosx, NtpSRVertex::dcosy, NtpSRVertex::dcosz, NtpSRVertex::edcosu, NtpSRVertex::edcosv, NtpSRVertex::edcosx, NtpSRVertex::edcosy, NtpSRVertex::edcosz, NtpSRTrack::end, NtpSRVertex::eu, NtpSRVertex::ev, NtpSRVertex::ex, NtpSRVertex::ey, CandRecoHandle::GetEndDirCosU(), CandRecoHandle::GetEndDirCosV(), CandRecoHandle::GetEndDirCosZ(), CandFitTrackSRHandle::GetEnddUError(), CandFitTrackSRHandle::GetEnddVError(), CandRecoHandle::GetEndPlane(), CandRecoHandle::GetEndT(), CandRecoHandle::GetEndU(), CandFitTrackSRHandle::GetEndUError(), CandRecoHandle::GetEndV(), CandFitTrackSRHandle::GetEndVError(), CandRecoHandle::GetEndZ(), kCos45, MSG, NtpSRVertex::plane, NtpSRVertex::t, NtpSRVertex::u, NtpSRVertex::v, NtpSRVertex::x, NtpSRVertex::y, and NtpSRVertex::z. Referenced by FillNtpTrack(). { // // Purpose: Private method used to fill end portion of ntuple track. // // Arguments: NtpSRTrack to fill and const CandTrackHandle pointer. // // Return: status. // MSG("NtpSR",Msg::kVerbose) << "NtpSRModule::FillNtpTrackEnd" << endl; NtpSRVertex& end = ntptrack->end; end.u = track->GetEndU(); end.v = track->GetEndV(); end.x = kCos45*(end.u-end.v); end.y = kCos45*(end.u+end.v); end.z = track->GetEndZ(); end.t = track->GetEndT(); end.plane = track->GetEndPlane(); end.dcosu = track->GetEndDirCosU(); end.dcosv = track->GetEndDirCosV(); end.dcosx = kCos45*(end.dcosu-end.dcosv); end.dcosy = kCos45*(end.dcosu+end.dcosv); end.dcosz = track->GetEndDirCosZ(); const CandFitTrackSRHandle* fittracksr =dynamic_cast<const CandFitTrackSRHandle*>(track); if ( fittracksr ) { end.eu = fittracksr->GetEndUError(); end.ev = fittracksr->GetEndVError(); end.ex = kCos45*sqrt(end.eu*end.eu+end.ev*end.ev); end.ey = kCos45*sqrt(end.eu*end.eu+end.ev*end.ev); Double_t edudz = fittracksr->GetEnddUError(); Double_t edvdz = fittracksr->GetEnddVError(); // These calculations should include the dudz and dvdz covariance terms // but currently the covariance terms are not accessible end.edcosz = fabs(end.dcosz)*sqrt(pow(end.dcosu*edudz,2)+ pow(end.dcosv*edvdz,2)); end.edcosu = sqrt(fabs(end.dcosz))*sqrt(pow(end.dcosu*end.dcosv*edvdz,2) + pow((pow(end.dcosz,2)+pow(end.dcosv,2))*edudz,2)); end.edcosv = sqrt(fabs(end.dcosz))*sqrt(pow(end.dcosu*end.dcosv*edudz,2) + pow((pow(end.dcosz,2)+pow(end.dcosu,2))*edvdz,2)); end.edcosx = kCos45*sqrt(end.edcosu*end.edcosu+end.edcosv*end.edcosv); end.edcosy = kCos45*sqrt(end.edcosu*end.edcosu+end.edcosv*end.edcosv); } return; }

void NtpSRModule::FillNtpTrackFidAll (  NtpSRTrack *  ntptrack, const CandTrackHandle *  track, const VldContext &  vld )  [private]

Definition at line 1935 of file NtpSRModule.cxx. References NtpSRFiducial::dr, NtpSRFiducial::dz, NtpSRTrack::fidall, NtpSRTrack::fidend, NtpSRTrack::fidvtx, FillNtpFiducialDistance(), CandHandle::GetDaughterIterator(), CandStripHandle::GetPlane(), CandTrackHandle::GetU(), CandTrackHandle::GetV(), CandTrackHandle::GetZ(), kCos45, max(), min(), MSG, NtpSRFiducial::nplane, NtpSRFiducial::nplaneu, NtpSRFiducial::nplanev, NtpSRVertex::plane, NtpSRFiducial::trace, NtpSRFiducial::tracez, NtpSRVertex::u, NtpSRVertex::v, NtpSRVertex::x, NtpSRVertex::y, and NtpSRVertex::z. Referenced by FillNtpTrack(). { // // Purpose: Private method used to fill NtpSRTrack fidall data member // given a pointer to the ntuple track, a pointer to the // associated CandTrackHandle, and the vldcontext of the // event. // // Return: none. // // Notes: This method should be called after FillNtpTrackFidAll // and FillNtpFiducialEnd MSG("NtpSR",Msg::kVerbose) << "NtpSRModule::FillNtpFiducialAll" << endl; NtpSRFiducial& fidall = ntptrack->fidall; NtpSRFiducial fidtmp; NtpSRVertex vtxtmp; fidall.dr = min(ntptrack->fidvtx.dr,ntptrack->fidend.dr); fidall.dz = min(ntptrack->fidvtx.dz,ntptrack->fidend.dz); fidall.trace = min(ntptrack->fidvtx.trace,ntptrack->fidend.trace); fidall.tracez = min(ntptrack->fidvtx.tracez,ntptrack->fidend.tracez); fidall.nplane = max(ntptrack->fidvtx.nplane,ntptrack->fidend.nplane); fidall.nplaneu = max(ntptrack->fidvtx.nplaneu,ntptrack->fidend.nplaneu); fidall.nplanev = max(ntptrack->fidvtx.nplanev,ntptrack->fidend.nplanev); TIter trackstripItr(track->GetDaughterIterator()); while(CandStripHandle* trackstrip = dynamic_cast<CandStripHandle*> (trackstripItr())) { // For all strips calculate closest approach to boundaries Int_t iplane = trackstrip->GetPlane(); vtxtmp.plane = iplane; vtxtmp.u = track->GetU(iplane); vtxtmp.v = track->GetV(iplane); vtxtmp.x = kCos45*(vtxtmp.u-vtxtmp.v); vtxtmp.y = kCos45*(vtxtmp.u+vtxtmp.v); vtxtmp.z = track->GetZ(iplane); this->FillNtpFiducialDistance(fidtmp,vtxtmp,vld); // fills dr,dz fidall.dr = min(fidtmp.dr,fidall.dr); fidall.dz = min(fidtmp.dz,fidall.dz); } return; }

void NtpSRModule::FillNtpTrackFidEnd (  NtpSRTrack *  ntptrack, const CandTrackHandle *  track, const VldContext &  vld )  [private]

Definition at line 1901 of file NtpSRModule.cxx. References NtpSRTrack::end, NtpSRTrack::fidend, FillNtpFiducialDistance(), CandFitTrackSRHandle::GetEndExtrapolate(), CandTrackHandle::GetEndTrace(), CandTrackHandle::GetEndTraceZ(), MSG, NtpSRFiducial::nplane, NtpSRFiducial::nplaneu, NtpSRFiducial::nplanev, NtpSRFiducial::trace, and NtpSRFiducial::tracez. Referenced by FillNtpTrack(). { // // Purpose: Private method used to fill NtpSRTrack fidend data member // given a pointer to the ntuple track, a pointer to the // associated CandTrackHandle, and the vldcontext of the // event. // // Return: none. // MSG("NtpSR",Msg::kVerbose) << "NtpSRModule::FillNtpTrackFidEnd" << endl; NtpSRFiducial& fid = ntptrack->fidend; NtpSRVertex& end = ntptrack->end; this->FillNtpFiducialDistance(fid,end,vld); // fills dr,dz fid.trace = track->GetEndTrace(); fid.tracez = track->GetEndTraceZ(); const CandFitTrackSRHandle* fittracksr = dynamic_cast<const CandFitTrackSRHandle*>(track); if ( fittracksr ) { fid.nplane = fittracksr->GetEndExtrapolate(); fid.nplaneu = fittracksr->GetEndExtrapolate(PlaneView::kU); fid.nplanev = fittracksr->GetEndExtrapolate(PlaneView::kV); } return; }

void NtpSRModule::FillNtpTrackFidVtx (  NtpSRTrack *  ntptrack, const CandTrackHandle *  track, const VldContext &  vld )  [private]

Definition at line 1867 of file NtpSRModule.cxx. References NtpSRTrack::fidvtx, FillNtpFiducialDistance(), CandFitTrackSRHandle::GetVtxExtrapolate(), CandTrackHandle::GetVtxTrace(), CandTrackHandle::GetVtxTraceZ(), MSG, NtpSRFiducial::nplane, NtpSRFiducial::nplaneu, NtpSRFiducial::nplanev, NtpSRFiducial::trace, NtpSRFiducial::tracez, and NtpSRTrack::vtx. Referenced by FillNtpTrack(). { // // Purpose: Private method used to fill NtpSRTrack fidvtx data member // given a pointer to the ntuple track, a pointer to the // associated CandTrackHandle, and the vldcontext of the // event. // // Return: none. // MSG("NtpSR",Msg::kVerbose) << "NtpSRModule::FillNtpTrackFidVtx" << endl; NtpSRFiducial& fid = ntptrack->fidvtx; NtpSRVertex& vtx = ntptrack->vtx; this->FillNtpFiducialDistance(fid,vtx,vld); // fills dr,dz fid.trace = track->GetVtxTrace(); fid.tracez = track->GetVtxTraceZ(); const CandFitTrackSRHandle* fittracksr = dynamic_cast<const CandFitTrackSRHandle*>(track); if ( fittracksr ) { fid.nplane = fittracksr->GetVtxExtrapolate(); fid.nplaneu = fittracksr->GetVtxExtrapolate(PlaneView::kU); fid.nplanev = fittracksr->GetVtxExtrapolate(PlaneView::kV); } return; }

void NtpSRModule::FillNtpTrackFit (  NtpSRTrack *  ntptrack, const CandTrackHandle *  track )  [private]

Definition at line 1832 of file NtpSRModule.cxx. References NtpSRFitTrack::chi2, NtpSRFitTrack::cputime, NtpSRTrack::fit, CandFitTrackHandle::GetChi2(), CandFitTrackHandle::GetCPUTime(), CandFitTrackHandle::GetNDOF(), CandFitTrackHandle::GetNIterate(), CandFitTrackSRHandle::GetNSwimFail(), CandFitTrackHandle::GetPass(), MSG, NtpSRFitTrack::ndof, NtpSRFitTrack::niterate, NtpSRFitTrack::nswimfail, and NtpSRFitTrack::pass. Referenced by FillNtpTrack(). { // // Purpose: Private method used to fill NtpSRTrack fit data member // given a pointer to the ntuple track and a pointer to the // associated CandTrackHandle. // // Return: none. // MSG("NtpSR",Msg::kVerbose) << "NtpSRModule::FillNtpTrackFit" << endl; NtpSRFitTrack& fit = ntptrack->fit; const CandFitTrackHandle* fittrack = dynamic_cast<const CandFitTrackHandle*>(track); if ( fittrack ) { fit.chi2 = fittrack->GetChi2(); fit.pass = fittrack->GetPass(); fit.ndof = fittrack->GetNDOF(); fit.niterate = fittrack->GetNIterate(); fit.cputime = fittrack->GetCPUTime(); } const CandFitTrackSRHandle* fittracksr = dynamic_cast<const CandFitTrackSRHandle*>(track); if ( fittracksr ) { fit.nswimfail = fittracksr->GetNSwimFail(); } return; }

void NtpSRModule::FillNtpTrackLinearFit (  NtpSRTrack *  ntptrack, const CandTrackHandle *  track )  [private]

Definition at line 2090 of file NtpSRModule.cxx. References NtpSRVertex::dcosu, NtpSRVertex::dcosv, NtpSRVertex::dcosx, NtpSRVertex::dcosy, NtpSRVertex::dcosz, CandStripHandle::GetCharge(), CandHandle::GetDaughterIterator(), CandStripHandle::GetPlane(), CandStripHandle::GetPlaneView(), CandRecoHandle::GetTimeSlope(), CandStripHandle::GetTPos(), CandRecoHandle::GetVtxT(), CandRecoHandle::GetVtxZ(), CandStripHandle::GetZPos(), kCos45, NtpSRTrack::lin, MSG, NtpSRVertex::t, NtpSRVertex::u, NtpSRVertex::v, LinearFit::Weighted(), NtpSRVertex::x, NtpSRVertex::y, and NtpSRVertex::z. Referenced by FillNtpTrack(). { // // Purpose: Private method used to fill linar fit track portion of // ntuple track. // // Arguments: NtpSRTrack to fill and const CandTrackHandle pointer. // // Return: status. // MSG("NtpSR",Msg::kVerbose) << "NtpSRModule::FillNtpTrackLinearFit" << endl; // First array dimension is view (u or v) // Second array dimension is plane number const Int_t nplane = 1000; Double_t uzfit[nplane]={0},vzfit[nplane]={0},ufit[nplane]={0}; Double_t vfit[nplane]={0},uwfit[nplane]={0},vwfit[nplane]={0}; Double_t uph[nplane]={0},vph[nplane]={0}; // Loop over all strips on track TIter trackstripItr(track->GetDaughterIterator()); while(CandStripHandle* trackstrip = dynamic_cast<CandStripHandle*> (trackstripItr())) { Float_t tpos = trackstrip->GetTPos(); Float_t phend[2] = {trackstrip->GetCharge(StripEnd::kNegative), trackstrip->GetCharge(StripEnd::kPositive)}; Float_t phsum = phend[0] + phend[1]; Int_t iplane = trackstrip->GetPlane(); assert(iplane >= 0 && iplane < nplane); if ( trackstrip->GetPlaneView()==PlaneView::kU ) { uzfit[iplane] = trackstrip->GetZPos(); ufit[iplane] += tpos*phsum; // pulse height weighted average of tpos uph[iplane] += phsum; // summed pulse height both ends uwfit[iplane] = 1; // weight assigned for use in fit } else if ( trackstrip->GetPlaneView()==PlaneView::kV ) { vzfit[iplane] = trackstrip->GetZPos(); vfit[iplane] += tpos*phsum; // pulse height weighted average of tpos vph[iplane] += phsum; // summed pulse height both ends vwfit[iplane] = 1; // weight assigned for use in fit } } // Finished with loop over all strips, calculate fit results NtpSRVertex& lin = ntptrack->lin; lin.z = track->GetVtxZ(); lin.t = track->GetVtxT(); Int_t timesign = 1; if ( track->GetTimeSlope() < 0. ) timesign = -1; Int_t nhitplane[2] = {0}; for ( Int_t ip = 0; ip < nplane; ip++ ) { if ( uph[ip] > 0 ) { nhitplane[0]++; ufit[ip] /= uph[ip]; } if ( vph[ip] > 0 ) { nhitplane[1]++; vfit[ip] /= vph[ip]; } } Double_t uparm[2]={0},ueparm[2]={0},vparm[2]={0},veparm[2]={0}; if ( nhitplane[0] > 1 ) { LinearFit::Weighted(nplane,uzfit,ufit,uwfit,uparm,ueparm); } if ( nhitplane[1] > 1 ) { LinearFit::Weighted(nplane,vzfit,vfit,vwfit,vparm,veparm); } if ( nhitplane[0] > 1 || nhitplane[1] > 1 ) { // Need at least one of two views to make attempt at filling direction Double_t dvdz = vparm[1]; lin.v = vparm[0]+lin.z*dvdz; Double_t dudz = uparm[1]; lin.u = uparm[0]+lin.z*dudz; Double_t anorm = sqrt(1.+dudz*dudz+dvdz*dvdz); lin.dcosu = timesign*dudz/anorm; lin.dcosv = timesign*dvdz/anorm; lin.dcosz = timesign*1./anorm; } if ( nhitplane[0] > 1 && nhitplane[1] > 1 ) { // Need both u&z views fit to rotate to x,y Double_t dxdz = kCos45*(uparm[1]-vparm[1]); Double_t dydz = kCos45*(uparm[1]+vparm[1]); Double_t anorm = sqrt(1.+dxdz*dxdz+dydz*dydz); lin.dcosx = timesign*dxdz/anorm; lin.dcosy = timesign*dydz/anorm; lin.x = kCos45*(uparm[0]-vparm[0])+lin.z*dxdz; // Xv = Xint + dx/dz * Zv lin.y = kCos45*(uparm[0]+vparm[0])+lin.z*dydz; } return; }

void NtpSRModule::FillNtpTrackMomentum (  NtpSRTrack *  ntptrack, const CandTrackHandle *  track )  [private]

Definition at line 1626 of file NtpSRModule.cxx. References NtpSRMomentum::eqp, CandFitTrackHandle::GetEMCharge(), CandTrackHandle::GetMomentum(), CandFitTrackHandle::GetMomentumCurve(), CandFitTrackHandle::GetVtxQPError(), max(), NtpSRTrack::momentum, MSG, NtpSRMomentum::qp, and NtpSRMomentum::range. Referenced by FillNtpTrack(). { // // Purpose: Private method used to fill NtpSRTrack momentum data member // given a pointer to the ntuple track and a pointer to the // associated CandTrackHandle. // // Return: none. // MSG("NtpSR",Msg::kVerbose) << "NtpSRModule::FillNtpTrackMomentum" << endl; NtpSRMomentum& momentum = ntptrack->momentum; momentum.range = track->GetMomentum(); const CandFitTrackHandle* fittrack = dynamic_cast<const CandFitTrackHandle*>(track); if ( fittrack ) { // Guard against divide by 0 Double_t pcurve = max(fittrack->GetMomentumCurve(),0.001); //if ( ntptrack->fit.pass ) momentum.qp = fittrack->GetEMCharge()/pcurve; momentum.qp = fittrack->GetEMCharge()/pcurve; momentum.eqp = fittrack->GetVtxQPError(); } // const CandFitTrackSRHandle* fittracksr // = dynamic_cast<const CandFitTrackSRHandle*>(track); // if ( fittracksr ) { // momentum.eqp = fittracksr->GetVtxQPError(); // } return; }

void NtpSRModule::FillNtpTrackProjectionToShield (  NtpSRShieldSummary &  ntpshieldsummary, const NtpSRTrack *  ntptrack )  [private]

Definition at line 614 of file NtpSRModule.cxx. References NtpSRShieldSummary::dcos, NtpSRVertex::dcosu, NtpSRVertex::dcosv, NtpSRVertex::dcosx, NtpSRVertex::dcosy, NtpSRVertex::dcosz, fShGeom, NtpSRShieldSummary::ishit, MSG, NtpSRShieldSummary::projx, NtpSRShieldSummary::projy, NtpSRShieldSummary::projz, NtpSRVertex::u, NtpSRVertex::v, NtpSRTrack::vtx, NtpSRVertex::x, NtpSRVertex::y, and NtpSRVertex::z. Referenced by FillNtpShield(). { // // Purpose: Private method used to fill projection of track intercept // with shield portion of shield summary ntuple. // // Arguments: Reference to NtpSRShieldSummary and ptr to primary track // // Return: none. // // Notes: Should be called before ntp veto shield strips and // post-filling of ntp tracks // If multiple tracks, projection is calculated using first of // tracks. MSG("NtpSR",Msg::kVerbose) << "NtpSRModule::FillNtpTrackProjectionToShield" << endl; if ( ! ntptrack ) return; // no track to project const NtpSRVertex& vtx = ntptrack->vtx; CandShieldSR cs(vtx.x,vtx.y,vtx.z,vtx.dcosx,vtx.dcosy,vtx.dcosz,fShGeom); ntpshieldsummary.ishit = 0; if(cs.IsVetoHit() == true){ ntpshieldsummary.ishit = 1; } ntpshieldsummary.projx=cs.GetCandShieldInter_X(); ntpshieldsummary.projy=cs.GetCandShieldInter_Y(); ntpshieldsummary.projz=cs.GetCandShieldInter_Z(); // I left this to fill ntpshieldsummary.dcos in the SR way **!! Float_t xzproj[2] = {-999.,-999.}; Int_t ishit=0; if ( vtx.dcosy != 0. ) { xzproj[0] = vtx.x + vtx.dcosx/vtx.dcosy*(4.37-vtx.y); xzproj[1] = vtx.z + vtx.dcosz/vtx.dcosy*(4.37-vtx.y); if (fabs(xzproj[0])<2.03 && (xzproj[1]-vtx.z)*vtx.dcosz<0.) { if (xzproj[1]>0.0&&xzproj[1]<30.) ishit = 1; if ((xzproj[1]>0.0&&xzproj[1]<30.) || !ishit) { ntpshieldsummary.dcos = vtx.dcosy; } } xzproj[0] = vtx.x + vtx.dcosx/vtx.dcosy*(3.06-vtx.y); xzproj[1] = vtx.z + vtx.dcosz/vtx.dcosy*(3.06-vtx.y); if (fabs(xzproj[0])>3.34 && (xzproj[1]-vtx.z)*vtx.dcosz<0.) { if (fabs(xzproj[0])<6.05&&xzproj[1]>0.0&&xzproj[1]<30.) ishit = 1; if ((xzproj[1]>0.0&&xzproj[1]<30.) || !ishit) { ntpshieldsummary.dcos = vtx.dcosy; } } } if (vtx.dcosu!=0.) { xzproj[0] = vtx.v + vtx.dcosv/vtx.dcosu*(4.45-vtx.u); xzproj[1] = vtx.z + vtx.dcosz/vtx.dcosu*(4.45-vtx.u); if (xzproj[0]>-.22624&&xzproj[0]<1.5554 && (xzproj[1]-vtx.z)*vtx.dcosz<0.) { if (xzproj[1]>0.0&&xzproj[1]<30.) ishit = 1; if ((xzproj[1]>0.0&&xzproj[1]<30.) || !ishit) { ntpshieldsummary.dcos = vtx.dcosu; } } } if (vtx.dcosv!=0.) { xzproj[0] = vtx.u +vtx.dcosu/vtx.dcosv*(4.45-vtx.v); xzproj[1] = vtx.z + vtx.dcosz/vtx.dcosv*(4.45-vtx.v); if (xzproj[0]>-.22624&&xzproj[0]<1.5554 && (xzproj[1]-vtx.z)*vtx.dcosz<0.) { if (xzproj[1]>0.0&&xzproj[1]<30.) ishit = 1; if ((xzproj[1]>0.0&&xzproj[1]<30.) || !ishit) { ntpshieldsummary.dcos = vtx.dcosv; } } } if (vtx.dcosx!=0.) { xzproj[0] = vtx.y + vtx.dcosy/vtx.dcosx*(6.7-vtx.x); xzproj[1] = vtx.z + vtx.dcosz/vtx.dcosx*(6.7-vtx.x); if (xzproj[0]>1.20&&xzproj[0]<4.64 && (xzproj[1]-vtx.z)*vtx.dcosz<0.) { if (xzproj[1]>0.0&&xzproj[1]<30.) ishit = 1; if ((xzproj[1]>0.0&&xzproj[1]<30.) || !ishit) { ntpshieldsummary.dcos = vtx.dcosx; } } xzproj[0] = vtx.y + vtx.dcosy/vtx.dcosx*(-6.7-vtx.x); xzproj[1] = vtx.z + vtx.dcosz/vtx.dcosx*(-6.7-vtx.x); if (xzproj[0]>1.20&&xzproj[0]<4.64 && (xzproj[1]-vtx.z)*vtx.dcosz<0.) { if (xzproj[1]>0.0&&xzproj[1]<30.) ishit = 1; if ((xzproj[1]>0.0&&xzproj[1]<30.) || !ishit) { ntpshieldsummary.dcos = vtx.dcosx; } } xzproj[0] = vtx.y + vtx.dcosy/vtx.dcosx*(4.3-vtx.x); xzproj[1] = vtx.z + vtx.dcosz/vtx.dcosx*(4.3-vtx.x); if (xzproj[0]>-1.5&&xzproj[0]<0.5 && (xzproj[1]-vtx.z)*vtx.dcosz<0.) { if (xzproj[1]>0.0&&xzproj[1]<30.) ishit = 1; if ((xzproj[1]>0.0&&xzproj[1]<30.) || !ishit) { ntpshieldsummary.dcos = vtx.dcosx; } } xzproj[0] = vtx.y + vtx.dcosy/vtx.dcosx*(-4.3-vtx.x); xzproj[1] = vtx.z + vtx.dcosz/vtx.dcosx*(-4.3-vtx.x); if (xzproj[0]>-1.5&&xzproj[0]<0.5 && (xzproj[1]-vtx.z)*vtx.dcosz<0.) { if (xzproj[1]>0.0&&xzproj[1]<30.) ishit = 1; if ((xzproj[1]>0.0&&xzproj[1]<30.) || !ishit) { ntpshieldsummary.dcos = vtx.dcosx; } } } return; }

void NtpSRModule::FillNtpTrackTime (  NtpSRTrack *  ntptrack, const CandTrackHandle *  track )  [private]

Definition at line 1723 of file NtpSRModule.cxx. References NtpSRTrackTime::cdtds, NtpSRTrackTime::chi2, NtpSRTrackTime::dtds, NtpSRTrackTime::du, NtpSRTrackTime::dv, CandHandle::GetDaughterIterator(), CandStripHandle::GetNDigit(), CandFitTrackSRHandle::GetNTimeFitDigit(), CandTrackSRHandle::GetNTimeFitDigit(), CalHelpers::GetPlane(), CandTrackHandle::GetT(), CandFitTrackSRHandle::GetTimeFitChi2(), CandTrackSRHandle::GetTimeFitChi2(), CandRecoHandle::GetTimeOffset(), CandRecoHandle::GetTimeSlope(), MSG, NtpSRTrackTime::ndigit, NtpSRTrackTime::t0, NtpSRTrack::time, NtpSRTrackTime::u0, NtpSRTrackTime::u1, NtpSRTrackTime::v0, NtpSRTrackTime::v1, and PropagationVelocity::VelocityPosErr(). Referenced by FillNtpTrack(). { // // Purpose: Private method used to fill NtpSRTrack time data member // given a pointer to the ntuple track and a pointer to the // associated CandTrackHandle. // // Return: none. // MSG("NtpSR",Msg::kVerbose) << "NtpSRModule::FillNtpTrackTime" << endl; NtpSRTrackTime& time = ntptrack->time; const CandTrackSRHandle* tracksr = dynamic_cast<const CandTrackSRHandle*>(track); if ( tracksr ) { time.ndigit = tracksr->GetNTimeFitDigit(); time.chi2 = tracksr->GetTimeFitChi2(); } const CandFitTrackSRHandle* fittracksr = dynamic_cast<const CandFitTrackSRHandle*>(track); if ( fittracksr ) { time.ndigit = fittracksr->GetNTimeFitDigit(); time.chi2 = fittracksr->GetTimeFitChi2(); } time.cdtds = fabs(track->GetTimeSlope())*3.e8; time.dtds = track->GetTimeSlope(); time.t0 = track->GetTimeOffset(); Double_t totuph[2] = {0}, totvph[2] = {0}; Int_t ndutimespace[1000] = {0}, ndvtimespace[1000] = {0}; Double_t dutimespace[1000] = {0}, dvtimespace[1000] = {0}; TIter trackstripItr(track->GetDaughterIterator()); while (CandStripHandle* trackstrip = dynamic_cast<CandStripHandle*> (trackstripItr())) { Int_t iplane = trackstrip -> GetPlane(); assert(iplane >= 0 && iplane < 1000); Double_t ph0 = trackstrip -> GetCharge(StripEnd::kNegative); Double_t ph1 = trackstrip -> GetCharge(StripEnd::kPositive); Double_t t0 = track->GetT(iplane,StripEnd::kNegative); Double_t t1 = track->GetT(iplane,StripEnd::kPositive); if ( trackstrip -> GetPlaneView() == PlaneView::kU ) { if ( trackstrip -> GetNDigit(StripEnd::kNegative) > 0 ) { totuph[0] += ph0; time.u0 += ph0*t0; } if ( trackstrip -> GetNDigit(StripEnd::kPositive) > 0 ) { totuph[1] += ph1; time.u1 += ph1*t1; } if ( trackstrip->GetNDigit(StripEnd::kNegative) > 0 && trackstrip->GetNDigit(StripEnd::kPositive) > 0 ) { Double_t dapos = .5*(t0-t1)*PropagationVelocity::VelocityPosErr(); if (!ndutimespace[iplane] || fabs(dapos)<fabs(dutimespace[iplane])) { dutimespace[iplane] = dapos; ndutimespace[iplane] = 1; } } } if ( trackstrip -> GetPlaneView() == PlaneView::kV ) { if ( trackstrip -> GetNDigit(StripEnd::kNegative) > 0 ) { totvph[0] += ph0; time.v0 += ph0*t0; } if ( trackstrip -> GetNDigit(StripEnd::kPositive) > 0 ) { totvph[1] += ph1; time.v1 += ph1*t1; } if ( trackstrip -> GetNDigit(StripEnd::kNegative) > 0 && trackstrip -> GetNDigit(StripEnd::kPositive) > 0 ) { Double_t dapos = .5*(t0-t1)*PropagationVelocity::VelocityPosErr(); if (!ndvtimespace[iplane] || fabs(dapos) < fabs(dvtimespace[iplane])) { dvtimespace[iplane] = dapos; ndvtimespace[iplane] = 1; } } } } Int_t ndu = 0; Int_t ndv = 0; for (int ip = 0; ip < 1000; ip++ ) { if ( ndutimespace[ip] > 0 ) { ndu++; time.du += dutimespace[ip]; } if ( ndvtimespace[ip] > 0 ) { ndv++; time.dv += dvtimespace[ip]; } } if ( totuph[0] > 0. ) time.u0 /= totuph[0]; if ( totvph[0] > 0. ) time.v0 /= totvph[0]; if ( totuph[1] > 0. ) time.u1 /= totuph[1]; if ( totvph[1] > 0. ) time.v1 /= totvph[1]; if ( ndu ) time.du /= (Double_t)ndu; if ( ndv ) time.dv /= (Double_t)ndv; return; }

void NtpSRModule::FillNtpTrackVertex (  NtpSRTrack *  ntptrack, const CandTrackHandle *  track )  [private]

Definition at line 1984 of file NtpSRModule.cxx. References NtpSRVertex::dcosu, NtpSRVertex::dcosv, NtpSRVertex::dcosx, NtpSRVertex::dcosy, NtpSRVertex::dcosz, NtpSRVertex::edcosu, NtpSRVertex::edcosv, NtpSRVertex::edcosx, NtpSRVertex::edcosy, NtpSRVertex::edcosz, NtpSRVertex::eu, NtpSRVertex::ev, NtpSRVertex::ex, NtpSRVertex::ey, CandRecoHandle::GetDirCosU(), CandRecoHandle::GetDirCosV(), CandRecoHandle::GetDirCosZ(), CandFitTrackHandle::GetVtxdUError(), CandFitTrackHandle::GetVtxdVError(), CandRecoHandle::GetVtxPlane(), CandRecoHandle::GetVtxT(), CandRecoHandle::GetVtxU(), CandFitTrackHandle::GetVtxUError(), CandRecoHandle::GetVtxV(), CandFitTrackHandle::GetVtxVError(), CandRecoHandle::GetVtxZ(), kCos45, MSG, NtpSRVertex::plane, NtpSRVertex::t, NtpSRVertex::u, NtpSRVertex::v, NtpSRTrack::vtx, NtpSRVertex::x, NtpSRVertex::y, and NtpSRVertex::z. Referenced by FillNtpTrack(). { // // Purpose: Private method used to fill vertex portion of ntuple track. // // Arguments: NtpSRTrack to fill and const CandTrackHandle pointer. // // Return: status. // MSG("NtpSR",Msg::kVerbose) << "NtpSRModule::FillNtpTrackVertex" << endl; NtpSRVertex& vtx = ntptrack->vtx; vtx.u = track->GetVtxU(); vtx.v = track->GetVtxV(); vtx.x = kCos45*(vtx.u-vtx.v); vtx.y = kCos45*(vtx.u+vtx.v); vtx.z = track->GetVtxZ(); vtx.t = track->GetVtxT(); vtx.plane = track->GetVtxPlane(); vtx.dcosu = track->GetDirCosU(); vtx.dcosv = track->GetDirCosV(); vtx.dcosx = kCos45*(vtx.dcosu-vtx.dcosv); vtx.dcosy = kCos45*(vtx.dcosu+vtx.dcosv); vtx.dcosz = track->GetDirCosZ(); const CandFitTrackHandle* fittrack = dynamic_cast<const CandFitTrackHandle*>(track); if ( fittrack ) { vtx.eu = fittrack->GetVtxUError(); vtx.ev = fittrack->GetVtxVError(); vtx.ex = kCos45*sqrt(vtx.eu*vtx.eu+vtx.ev*vtx.ev); vtx.ey = kCos45*sqrt(vtx.eu*vtx.eu+vtx.ev*vtx.ev); Double_t edudz = fittrack->GetVtxdUError(); Double_t edvdz = fittrack->GetVtxdVError(); // These calculations should include the dudz and dvdz covariance terms // but currently the covariance terms are not accessible vtx.edcosz = fabs(vtx.dcosz)*sqrt(pow(vtx.dcosu*edudz,2)+ pow(vtx.dcosv*edvdz,2)); vtx.edcosu = sqrt(fabs(vtx.dcosz))*sqrt(pow(vtx.dcosu*vtx.dcosv*edvdz,2) + pow((pow(vtx.dcosz,2)+pow(vtx.dcosv,2))*edudz,2)); vtx.edcosv = sqrt(fabs(vtx.dcosz))*sqrt(pow(vtx.dcosu*vtx.dcosv*edudz,2) + pow((pow(vtx.dcosz,2)+pow(vtx.dcosu,2))*edvdz,2)); vtx.edcosx = kCos45*sqrt(vtx.edcosu*vtx.edcosu+vtx.edcosv*vtx.edcosv); vtx.edcosy = kCos45*sqrt(vtx.edcosu*vtx.edcosu+vtx.edcosv*vtx.edcosv); } return; }

JobCResult NtpSRModule::Reco (  MomNavigator *  mom  )  [virtual]

Implement this for read-write access to the MomNavigator Reimplemented from JobCModule. Definition at line 149 of file NtpSRModule.cxx. References NtpSRRecord::crhdr, NtpStRecord::crhdr, NtpSRRecord::detstatus, NtpStRecord::detstatus, NtpSRRecord::dmxstatus, NtpStRecord::dmxstatus, NtpSRRecord::evthdr, NtpStRecord::evthdr, fCandRecordName, fClusterUidMap, fEventUidMap, FillNtpCluster(), FillNtpDetStatus(), FillNtpDmxStatus(), FillNtpEvent(), FillNtpEventSummary(), FillNtpShield(), FillNtpShower(), FillNtpSlice(), FillNtpStrip(), FillNtpTrack(), FillNtpTrackCosmicRay(), fRecordName, fRecordTitle, fShowerUidMap, fSliceUidMap, fStripUidMap, fTrackUidMap, DataUtil::GetCandHeader(), RawDaqSnarlHeader::GetErrorCode(), RecDataHeader::GetErrorCode(), CandHeader::GetEvent(), MomNavigator::GetFragment(), DataUtil::GetRawHeader(), RawDaqSnarlHeader::GetRemoteSpillType(), RecPhysicsHeader::GetRemoteSpillType(), CandHeader::GetRun(), RawDaqHeader::GetRun(), RecDataHeader::GetRun(), RawDaqHeader::GetRunType(), RecDataHeader::GetRunType(), SimSnarlRecord::GetSimSnarlHeader(), CandHeader::GetSnarl(), RawDaqSnarlHeader::GetSnarl(), RecPhysicsHeader::GetSnarl(), RawDaqHeader::GetSubRun(), RecDataHeader::GetSubRun(), RecPhysicsHeader::GetTimeFrame(), RawDaqHeader::GetTimeFrameNum(), RawDaqSnarlHeader::GetTrigSrc(), RecPhysicsHeader::GetTrigSrc(), RecMinosHdr::GetVldContext(), RecHeader::GetVldContext(), RecRecordImp< T >::GetVldContext(), Calibrator::Instance(), MSG, NtpSREventSummary::ntrack, CalScheme::Reset(), JobCResult::SetFailed(), JobCResult::SetWarning(), NtpSRRecord::vetohdr, and NtpStRecord::vetohdr. { // // Purpose: Create and fill ntuple record. // // Arguments: mom. // // Return: status. // JobCResult result(JobCResult::kPassed); MSG("NtpSR",Msg::kDebug) << "NtpSRModule::Reco" << endl; // Reset maps used to associate uid of reconstructed object with array index fStripUidMap.clear(); fSliceUidMap.clear(); fClusterUidMap.clear(); fShowerUidMap.clear(); fTrackUidMap.clear(); fEventUidMap.clear(); // Check that mom exists. assert(mom); // CandRecord will be extracted by name to match record name of NtpSRRecord const CandRecord* cndrec = dynamic_cast<const CandRecord*> (mom->GetFragment("CandRecord",fCandRecordName.c_str())); const SimSnarlRecord* simrec = dynamic_cast<const SimSnarlRecord*> (mom->GetFragment("SimSnarlRecord")); const RawRecord* rawrec = dynamic_cast<const RawRecord*> (mom->GetFragment("RawRecord","","DaqSnarl")); if (!cndrec && !simrec ) { MSG("NtpSR",Msg::kWarning) << "No CandRecord of name " << fRecordName << " or SimSnarlRecord in Mom" << endl; result.SetWarning().SetFailed(); return result; } TClonesArray* ntpstparrptr = 0; TClonesArray* ntpslcarrptr = 0; TClonesArray* ntpcluarrptr = 0; TClonesArray* ntpshwarrptr = 0; TClonesArray* ntptrkarrptr = 0; TClonesArray* ntpevtarrptr = 0; TClonesArray* ntpvetostparrptr = 0; NtpSREventSummary* ntpeventsummaryptr = 0; NtpSRShieldSummary* ntpshieldsummaryptr = 0; NtpSRCosmicRay* ntpcosmicrayptr = 0; NtpSRDmxStatus* ntpdmxstatusptr = 0; NtpSRDetStatus* ntpdetstatusptr = 0; NtpSRRecord* ntpsrrec = 0; NtpStRecord* ntpstrec = 0; const VldContext* ntpvldcptr = 0; if ( fUseStandard ) { ntpstrec = dynamic_cast<NtpStRecord*>(mom->GetFragment("NtpStRecord", fRecordName.c_str())); if ( !ntpstrec ) { MSG("NtpSR",Msg::kWarning) << "No NtpStRecord in Mom of name " << fRecordName.c_str() << "\nMust call NtpStModule::Get first." << endl; result.SetWarning().SetFailed(); return result; } ntpstparrptr = ntpstrec -> stp; ntpslcarrptr = ntpstrec -> slc; ntpcluarrptr = ntpstrec -> clu; ntpshwarrptr = ntpstrec -> shw; ntptrkarrptr = ntpstrec -> trk; ntpevtarrptr = ntpstrec -> evt; ntpvetostparrptr = ntpstrec-> vetostp; ntpeventsummaryptr = &(ntpstrec->evthdr); ntpshieldsummaryptr = &(ntpstrec->vetohdr); ntpcosmicrayptr = &(ntpstrec->crhdr); ntpdmxstatusptr = &(ntpstrec->dmxstatus); ntpdetstatusptr = &(ntpstrec->detstatus); ntpvldcptr = ntpstrec->GetVldContext(); } else { if ( !cndrec ) { // Use SimSnarlRecord header - presumably a triggerless mc event const SimSnarlHeader* simhdr = simrec->GetSimSnarlHeader(); RecCandHeader ntphdr(simhdr->GetVldContext(),simhdr->GetRun(), simhdr->GetSubRun(),simhdr->GetRunType(),simhdr->GetErrorCode(), simhdr->GetSnarl(),simhdr->GetTrigSrc(), simhdr->GetTimeFrame(),simhdr->GetRemoteSpillType(),-1); ntpsrrec = new NtpSRRecord(ntphdr); ntpsrrec -> SetName(fRecordName.c_str()); ntpsrrec -> SetTitle(fRecordTitle.c_str()); mom -> AdoptFragment(ntpsrrec); // pass record to mom to own return result; // a triggerless event } // Extract header from CandRecord and use this to create RecCandHeader // and NtpSRRecord. const CandHeader* cndhdr = cndrec -> GetCandHeader(); if (!rawrec) { MSG("NtpSR",Msg::kWarning) << "No DaqSnarl RawRecord in Mom" <<"\nShield data will not be filled and header will be incomplete." << endl; result.SetWarning(); } if (rawrec) { const RawDaqSnarlHeader* rawhdr = dynamic_cast<const RawDaqSnarlHeader*> (rawrec -> GetRawHeader()); RecCandHeader ntphdr(rawhdr->GetVldContext(),rawhdr->GetRun(), rawhdr->GetSubRun(),rawhdr->GetRunType(),rawhdr->GetErrorCode(), rawhdr->GetSnarl(),rawhdr->GetTrigSrc(),rawhdr->GetTimeFrameNum(), rawhdr->GetRemoteSpillType(),cndhdr->GetEvent()); ntpsrrec = new NtpSRRecord(ntphdr); } else { // This dependency is terrible, but is because CandRecord never made // the transition to new base class and CandHeader is incomplete RecCandHeader ntphdr(cndhdr->GetVldContext(),cndhdr->GetRun(), -1,-1,0,cndhdr->GetSnarl(),0,-1,-1,cndhdr->GetEvent()); ntpsrrec = new NtpSRRecord(ntphdr); } ntpsrrec -> SetName(fRecordName.c_str()); ntpsrrec -> SetTitle(fRecordTitle.c_str()); ntpstparrptr = ntpsrrec -> stp; ntpslcarrptr = ntpsrrec -> slc; ntpcluarrptr = ntpsrrec -> clu; ntpshwarrptr = ntpsrrec -> shw; ntptrkarrptr = ntpsrrec -> trk; ntpevtarrptr = ntpsrrec -> evt; ntpvetostparrptr = ntpsrrec-> vetostp; ntpeventsummaryptr = &(ntpsrrec->evthdr); ntpshieldsummaryptr = &(ntpsrrec->vetohdr); ntpcosmicrayptr = &(ntpsrrec->crhdr); ntpdmxstatusptr = &(ntpsrrec->dmxstatus); ntpdetstatusptr = &(ntpsrrec->detstatus); ntpvldcptr = ntpsrrec->GetVldContext(); } TClonesArray& ntpstriparray = *(ntpstparrptr); TClonesArray& ntpslicearray = *(ntpslcarrptr); TClonesArray& ntpclusterarray = *(ntpcluarrptr); TClonesArray& ntpshowerarray = *(ntpshwarrptr); TClonesArray& ntptrackarray = *(ntptrkarrptr); TClonesArray& ntpeventarray = *(ntpevtarrptr); NtpSREventSummary& ntpeventsummary = *(ntpeventsummaryptr); NtpSRShieldSummary& ntpshieldsummary = *(ntpshieldsummaryptr); NtpSRCosmicRay& ntpcosmicray = *(ntpcosmicrayptr); NtpSRDmxStatus& ntpdmxstatus = *(ntpdmxstatusptr); NtpSRDetStatus& ntpdetstatus = *(ntpdetstatusptr); const VldContext& vldc = *(ntpvldcptr); // Calibrator is used by FillNtpTrack Calibrator::Instance().Reset(vldc); this -> FillNtpStrip(ntpstriparray,cndrec); this -> FillNtpSlice(ntpslicearray,cndrec); this -> FillNtpCluster(ntpclusterarray,cndrec); this -> FillNtpShower(ntpshowerarray,cndrec); this -> FillNtpTrack(ntptrackarray,cndrec); this -> FillNtpEvent(ntpeventarray,cndrec); this -> FillNtpDmxStatus(ntpdmxstatus,cndrec); this -> FillNtpDetStatus(ntpdetstatus,vldc); this -> FillNtpEventSummary(ntpeventsummary,cndrec,rawrec); const NtpSRTrack* ntptrack = 0; if(ntpeventsummary.ntrack > 0) ntptrack = dynamic_cast<NtpSRTrack*>(ntptrackarray.At(0)); if ( ntptrack ) this->FillNtpTrackCosmicRay(ntpcosmicray,ntptrack,vldc); if ( rawrec ) { TClonesArray& ntpshieldstriparray = *(ntpvetostparrptr); this->FillNtpShield(ntpshieldstriparray,ntpshieldsummary,ntptrack, rawrec); } // pass record to mom to own if ( !fUseStandard ) mom -> AdoptFragment(ntpsrrec); return result; }

---

Member Data Documentation

std::string NtpSRModule::fCandRecordName [private]

Definition at line 102 of file NtpSRModule.h. Referenced by Config(), NtpSRModule(), and Reco().

std::map<int,int> NtpSRModule::fClusterUidMap [private]

Definition at line 94 of file NtpSRModule.h. Referenced by FillNtpCluster(), FillNtpEventSummary(), FillNtpShower(), and Reco().

std::map<int,int> NtpSRModule::fEventUidMap [private]

Definition at line 97 of file NtpSRModule.h. Referenced by FillNtpEvent(), FillNtpEventSummary(), and Reco().

Double_t NtpSRModule::fPostTrigger [private]

Definition at line 100 of file NtpSRModule.h. Referenced by Config(), FillNtpShieldStrip(), and NtpSRModule().

Double_t NtpSRModule::fPreTrigger [private]

Definition at line 99 of file NtpSRModule.h. Referenced by Config(), FillNtpShieldStrip(), and NtpSRModule().

std::string NtpSRModule::fRecordName [private]

Definition at line 103 of file NtpSRModule.h. Referenced by Config(), NtpSRModule(), and Reco().

std::string NtpSRModule::fRecordTitle [private]

Definition at line 104 of file NtpSRModule.h. Referenced by Config(), NtpSRModule(), and Reco().

ShieldGeom* NtpSRModule::fShGeom [private]

Definition at line 107 of file NtpSRModule.h. Referenced by FillNtpShield(), FillNtpShieldStrip(), FillNtpTrackProjectionToShield(), and NtpSRModule().

std::map<int,int> NtpSRModule::fShowerUidMap [private]

Definition at line 95 of file NtpSRModule.h. Referenced by FillNtpEvent(), FillNtpEventSummary(), FillNtpShower(), and Reco().

std::map<int,int> NtpSRModule::fSliceUidMap [private]

Definition at line 93 of file NtpSRModule.h. Referenced by FillNtpCluster(), FillNtpEvent(), FillNtpEventSummary(), FillNtpShower(), FillNtpSlice(), FillNtpTrack(), and Reco().

std::map<int,int> NtpSRModule::fStripUidMap [private]

Definition at line 92 of file NtpSRModule.h. Referenced by FillNtpCluster(), FillNtpEvent(), FillNtpEventSummary(), FillNtpShower(), FillNtpSlice(), FillNtpStrip(), FillNtpTrack(), and Reco().

std::map<int,int> NtpSRModule::fTrackUidMap [private]

Definition at line 96 of file NtpSRModule.h. Referenced by FillNtpEvent(), FillNtpEventSummary(), FillNtpTrack(), and Reco().

bool NtpSRModule::fUseStandard [private]

Definition at line 105 of file NtpSRModule.h. Referenced by Config(), and NtpSRModule().

const Double_t NtpSRModule::kCos45 = 0.70710678 [static, private]

Definition at line 80 of file NtpSRModule.cxx. Referenced by FillNtpEvent(), FillNtpShower(), FillNtpTrack(), FillNtpTrackEnd(), FillNtpTrackFidAll(), FillNtpTrackLinearFit(), and FillNtpTrackVertex().

---

The documentation for this class was generated from the following files:

• NtpSRModule.h
• NtpSRModule.cxx

---