MinosCompactEvent Class Reference

#include <MinosCompactEvent.h>

List of all members.

Public Member Functions
	MinosCompactEvent (unsigned short qtype=0)
	MinosCompactEvent (const NtpStRecord *record, const int eventno, unsigned short qtype)
	MinosCompactEvent (const MinosCompactEvent *event, int stripCompressionFactor)
	MinosCompactEvent (const MinosCompactEvent *event, int pattern[201])
	MinosCompactEvent (const MinosCompactEvent *event)
int	SizeOf ()
void	SetPEThreshold (float qpe)
void	Print ()
void	Merge (MinosCompactEvent *pcce2)
void	ScaleCharges (float factor)
Int_t	GetLastPlaneToUse (const NtpStRecord *record, int eventno, int max_strips_cut=3, int max_gap=3)
virtual	~MinosCompactEvent ()
Public Attributes
float	_peThreshold
int	Run
int	Snarl
float	chargeScale
float	meanU
float	meanV
int	meanPlane
int	Qtot
int	Qtotraw
int	nPlanes
float	eNu
float	y
short	idact
short	idres
short	idnu
int	nxtalk
int	nxtalk_tagged
int	nxtalk_mistagged
int	nphysics
int	nremoved
std::vector< compactStrip_h >	UStrips
std::vector< compactStrip_h >	VStrips
unsigned short	ChargeType

---

Constructor & Destructor Documentation

MinosCompactEvent::MinosCompactEvent (  unsigned short  qtype = 0  )

Definition at line 65 of file MinosCompactEvent.cxx. References chargeScale, ChargeType, eNu, idact, idnu, idres, meanPlane, meanU, meanV, nphysics, nPlanes, nremoved, nxtalk, nxtalk_mistagged, nxtalk_tagged, Qtot, Run, Snarl, and y. { Run = -1; Snarl = -1; chargeScale = -1; meanU = -1; meanV = -1; meanPlane = -1; Qtot = -1; nPlanes = -1; eNu = -1; y = -1; idact = -1; idres = -1; idnu = -1; nxtalk = -1; nxtalk_tagged = -1; nxtalk_mistagged = -1; nphysics = -1; nremoved = -1; //UStrips.reserve(1); //VStrips.reserve(1); ChargeType = qtype; }

MinosCompactEvent::MinosCompactEvent (  const NtpStRecord *  record, const int  eventno, unsigned short  qtype )

Definition at line 227 of file MinosCompactEvent.cxx. References _peThreshold, abs(), AttenCorr::CalcCorr(), chargeScale, ChargeType, XTalkFilter::Config(), XTalkFilter::DefaultConfig(), XTalkFilter::DoTrueFilter(), eNu, NtpStRecord::evt, NtpStRecord::evthdr, FloatErr, Calibrator::GetAttenCalibrator(), Calibrator::GetAttenCorrected(), VldContext::GetDetector(), RecRecordImp< T >::GetHeader(), GetLastPlaneToUse(), RecDataHeader::GetRun(), RecPhysicsHeader::GetSnarl(), NtpSRStrip::GetStripEndId(), ValueErr< T >::GetValue(), RecHeader::GetVldContext(), NtpMCTruth::iaction, compactStrip_h::icharge, idact, idnu, idres, NtpSRStrip::index, Calibrator::Instance(), NtpMCTruth::inu, NtpMCTruth::iresonance, AttenCorr::lE, AttenCorr::lW, NtpStRecord::mc, meanPlane, meanU, meanV, ndstripno(), NtpTHEvent::neumc, nphysics, nPlanes, nremoved, NtpSREvent::nshower, NtpSRTrack::nstrip, NtpSRShower::nstrip, NtpSREventSummary::nstrip, NtpSREvent::nstrip, NtpSREvent::ntrack, nxtalk, nxtalk_mistagged, nxtalk_tagged, NtpMCTruth::p4neu, NtpSRPulseHeight::pe, NtpSRStrip::ph0, NtpSRStrip::ph1, compactStrip_h::plane, NtpSRStrip::plane, NtpSRStrip::planeview, AttenCorr::qpecor, Qtot, Qtotraw, CalScheme::Reset(), Run, PlexStripEndId::SetEnd(), SetPEThreshold(), NtpSREvent::shw, NtpStRecord::shw, NtpSRPulseHeight::sigcor, Snarl, NtpSRTrack::stp, NtpSRShower::stp, NtpStRecord::stp, NtpSREvent::stp, NtpSRTrack::stpph0gev, NtpSRShower::stpph0gev, NtpSRTrack::stpph1gev, NtpSRShower::stpph1gev, compactStrip_h::strip, NtpSRStrip::strip, NtpStRecord::thevt, NtpSRStrip::tpos, NtpSREvent::trk, NtpStRecord::trk, UStrips, VStrips, NtpMCTruth::y, and y. { Qtot = 0; Qtotraw = 0; ChargeType = qtype; // need to be able to modify the record (xtalk removal) NtpStRecord *record = (NtpStRecord*)record_const->Clone(); // xtalk removal -- if (qtype==2 || qtype==4) { // we want to apply the xtalk filter, so build a module and use it // (it would be better if there were a convenient way to keep one // persistent, but making one anew each time is not too bad.) XTalkFilter *xtalkfilter = new XTalkFilter(); xtalkfilter->Config(xtalkfilter->DefaultConfig()); xtalkfilter->DoTrueFilter(record,eventno); delete xtalkfilter; } //build a geometry handle UgliGeomHandle ugh(record->GetHeader().GetVldContext()); const int detector = record->GetHeader().GetVldContext().GetDetector(); const NtpSREvent* event = dynamic_cast<const NtpSREvent*>(record->evt->At(eventno)); assert(event); const NtpMCTruth* mcevent = NULL; if(record && record->thevt->GetEntries()!=0){ const NtpTHEvent* thevent = dynamic_cast<const NtpTHEvent*>(record->thevt->At(eventno)); mcevent = dynamic_cast<const NtpMCTruth*>(record->mc->At(thevent->neumc)); } bool planes[500]; for(int i=0;i<500;++i)planes[i]=false; chargeScale = 10.; Double_t ChargeToPe = 1.0; //For qtype 1-4 and 6, this is the approximate charge in units of qtype found in 1 pe. //It is identical to the sigcorscale in the HitProbTable used with this qtype. if (qtype == 1 || qtype == 2) ChargeToPe = 70.0; //Roughly 70 sigmaps per pe. if (qtype == 3 || qtype == 4 || qtype == 6) ChargeToPe = 8.0; //Rougly 8 MeV per pe. if(Detector::kFar == detector){//FD SetPEThreshold(3.0); } else SetPEThreshold(3.0); // set the global quantities Run = record->GetHeader().GetRun(); Snarl = record->GetHeader().GetSnarl(); // cout << "*************************************************" << endl; //cout << " RUN/SNARL : " << Run << " : " << Snarl << endl; // set any MC quantities if(mcevent){ eNu = mcevent->p4neu[3]; y = mcevent->y; idact = mcevent->iaction; idres = mcevent->iresonance; idnu = mcevent->inu; } else { eNu = -1; y = -1; idact = -1; idres = -1; idnu = -1; } const int nstrips = event->nstrip; //MCNN version of xtalk removal no longer supported. These data members //are being left in for backward compatibility. nxtalk=0; nxtalk_tagged=0; nxtalk_mistagged=0; nphysics=0; nremoved=0; // --- Z trimming --- // Decide if there is a plane past which we should ignore everything (i.e., trailing hits) // Only do this for the newer charge types (but not qtype = 5, which is pe-scaled sigcors)... // Now, qtype=6 is the same as qtype=3 but without the z-trimming Int_t lastPlaneToUse = 99999; if (qtype>0 && qtype != 5 && qtype != 6) lastPlaneToUse = GetLastPlaneToUse(record, eventno); // loop over the strips to determine number of u and v strips to be stored int nU = 0; int nV = 0; int nUKept = 0; int nVKept = 0; for(int istp = 0; istp< nstrips; istp++){ if(event->stp[istp]<0) continue; const NtpSRStrip* strip = dynamic_cast<const NtpSRStrip*>(record->stp->At(event->stp[istp])); float qpe = strip->ph0.pe+strip->ph1.pe; if(qpe>_peThreshold && qpe < 1000 && strip->plane<=lastPlaneToUse){ planes[strip->plane]=true; if(strip->planeview==2)nU++; if(strip->planeview==3)nV++; } } nPlanes = 0; int minPlane = -999; int maxPlane = 999; int ncount = 0; for(int i=0;i<500;++i){ if(planes[i]){ nPlanes++; if(minPlane<0)minPlane=i; ncount++; if(ncount==PLANE_WINDOW)maxPlane =i; } } //Array to hold qpe totals Float_t qpe_totU[201]={0.}; Float_t qpe_totV[201]={0.}; //Array to hold strip totals Int_t stp_totU[201]={0}; Int_t stp_totV[201]={0}; Int_t strip_count_u = 0; Int_t strip_count_v = 0; // now find charge weighted mean strip and plane in first // AVERAGE_OVER_PLANES planes double sumU = 0.; double sumV = 0.; double sumZ = 0.; double sumQ = 0.; double UsumQ = 0.; double VsumQ = 0.; int striptrue = 0; for(int istp = 0; istp< nstrips; istp++){ if(event->stp[istp]<0) continue; const NtpSRStrip* strip = dynamic_cast<const NtpSRStrip*>(record->stp->At(event->stp[istp])); float qpe = strip->ph0.pe+strip->ph1.pe; if(qpe>_peThreshold && qpe < 1000){ if(strip->plane>=minPlane&&strip->plane<=maxPlane){ if(strip->planeview==2){ striptrue = ndstripno(strip->plane, strip->strip,strip->planeview, detector); qpe_totU[striptrue] += qpe; stp_totU[striptrue]++; strip_count_u++; } if(strip->planeview==3){ striptrue = ndstripno(strip->plane, strip->strip,strip->planeview, detector); qpe_totV[striptrue] += qpe; stp_totV[striptrue]++; strip_count_v++; } } } } Float_t u_qtot=0; Int_t u_stot=0; Float_t u_qmax=-1; Int_t u_smax=-1; Float_t u_qmax_nocut=-1; Int_t u_smax_nocut=-1; Float_t v_qtot=0; Int_t v_stot=0; Float_t v_qmax=-1; Int_t v_smax=-1; Float_t v_qmax_nocut=-1; Int_t v_smax_nocut=-1; for (Int_t ii=0;ii<201;ii++){ u_qtot=0.; v_qtot=0.; u_stot=0; v_stot=0; for (Int_t jj = (1 - STRIP_WINDOW); jj<(STRIP_WINDOW); jj++){ if (((ii+jj)>=0)&&((ii+jj)<201)){ u_qtot+=qpe_totU[ii+jj]; v_qtot+=qpe_totV[ii+jj]; u_stot+=stp_totU[ii+jj]; v_stot+=stp_totV[ii+jj]; } } //Without cut on numbers of strips if (v_qtot>v_qmax_nocut) { v_smax_nocut=ii; v_qmax_nocut=v_qtot; } //With careful attention to outlying noise strips if (v_qtot>v_qmax){ if (strip_count_v>5&&v_stot>=3) { v_qmax=v_qtot; v_smax=ii; } else if (strip_count_v<=5&&strip_count_v>2&&v_stot>=2) { v_qmax=v_qtot; v_smax=ii; } else if (strip_count_v<=2&&strip_count_v>0){ v_qmax=v_qtot; v_smax=ii; } } //Without cut on numbers of strips if (u_qtot>u_qmax_nocut) { u_smax_nocut=ii; u_qmax_nocut=u_qtot; } //With careful attention to outlying noise strips if (u_qtot>u_qmax){ if (strip_count_u>5&&u_stot>=3) { u_qmax=u_qtot; u_smax=ii; } else if (strip_count_u<=5&&strip_count_u>2&&u_stot>=2) { u_qmax=u_qtot; u_smax=ii; } else if (strip_count_u<=2&&strip_count_u>0){ u_qmax=u_qtot; u_smax=ii; } } } //Revert to just the largest window if everything fails outlier test if (u_smax<0) u_smax=u_smax_nocut; if (v_smax<0) v_smax=v_smax_nocut; int imeanUTemp = u_smax; int imeanVTemp = v_smax; // now do it all again throwing away outlying strips meanU=0.; meanV=0.; sumU = 0.; sumV = 0.; sumZ = 0.; sumQ = 0.; UsumQ = 0.; VsumQ = 0.; double meanUTPos = 0; double meanVTPos = 0; for(int istp = 0; istp< nstrips; istp++){ if(event->stp[istp]<0) continue; const NtpSRStrip* strip = dynamic_cast<const NtpSRStrip*>(record->stp->At(event->stp[istp])); // const NtpTHStrip* stptruth= dynamic_cast<const NtpTHStrip*>(record->thstp->At(event->stp[istp])); // assert(stptruth); // if(stptruth!=NULL && ispurextalk(stptruth->sigflg)) continue; float qpe = strip->ph0.pe+strip->ph1.pe; if(qpe>_peThreshold && qpe < 1000 && strip->plane<=lastPlaneToUse){ if(strip->plane>=minPlane&&strip->plane<=maxPlane){ if(strip->planeview==2 && abs(ndstripno(strip->plane, strip->strip,strip->planeview, detector)-imeanUTemp)<STRIP_WINDOW){ nUKept++; sumQ += qpe; UsumQ += qpe*qpe; sumZ += strip->plane*qpe; sumU += ndstripno(strip->plane, strip->strip,strip->planeview, detector)*qpe*qpe; meanUTPos += strip->tpos*qpe*qpe; // cout << "U STRIP : " << strip->Plane << " : " << strip->Strip << " : " << qpe << endl; } if(strip->planeview==3 && abs(ndstripno(strip->plane, strip->strip,strip->planeview, detector)-imeanVTemp)<STRIP_WINDOW){ nVKept++; sumQ += qpe; VsumQ += qpe*qpe; sumZ += strip->plane*qpe; sumV += ndstripno(strip->plane, strip->strip,strip->planeview, detector)*qpe*qpe; meanVTPos += strip->tpos*qpe*qpe; //cout << "V STRIP : " << strip->Plane << " : " << strip->Strip << " : " << qpe << endl; } } } } // store mean charge-weighted positions meanU = 0.; meanV = 0.; meanPlane = 0; if(UsumQ>0){ meanU = sumU/UsumQ+0.5; meanUTPos = meanUTPos/UsumQ; } if(VsumQ>0){ meanV = sumV/VsumQ+0.5; meanVTPos = meanVTPos/VsumQ; } if(sumQ>0){ meanPlane = static_cast<int>(sumZ/sumQ); } int imeanU = static_cast<int>(meanU); int imeanV = static_cast<int>(meanV); // cout << " MEANS : " << meanU << ":" << meanV << " " << imeanU << ":" << imeanV << endl; // reserve the appropriate amount of space in vectors // this is purely to optimise memory usage UStrips.reserve(nU); VStrips.reserve(nV); //Up until this point, ALL computations were done using PEs. Now, when the compactStrips //are being built, charge quantities will be PEs, sigcors, or something else. However, threshold //checks will continue to be with PEs. // loop over the strips and build the compactStrips // apply attenuation corrections // cout << "means tpos:" << meanUTPos << " " << meanVTPos <<endl; float sumQcor = 0.; float sumQraw = 0.; //Extracting charge information from tracks and showers making up an event int nrecstrips = (int)record->evthdr.nstrip; float* ph0 = new float[nrecstrips]; float* ph1 = new float[nrecstrips]; if (qtype == 3 || qtype == 4 || qtype == 6) { for (int istp = 0; istp < nrecstrips; istp++) { ph0[istp] = 0; ph1[istp] = 0; } for (int j = 0; j < event->nshower; j++) { NtpSRShower* myshower = dynamic_cast<NtpSRShower*>(record->shw->At(event->shw[j])); for (int k = 0; k < myshower->nstrip; k++) { ph0[myshower->stp[k]] = 1000 * myshower->stpph0gev[k]; //GeV converted to MeV ph1[myshower->stp[k]] = 1000 * myshower->stpph1gev[k]; } } //Tracks are done second so that in case of overlapping hits, the track's //energy information is used. Track positions are known better, resulting //in better attenuation correction. for (int j = 0; j < event->ntrack; j++) { NtpSRTrack* mytrack = dynamic_cast<NtpSRTrack*>(record->trk->At(event->trk[j])); for (int k = 0; k < mytrack->nstrip; k++) { ph0[mytrack->stp[k]] = 1000 * mytrack->stpph0gev[k]; ph1[mytrack->stp[k]] = 1000 * mytrack->stpph1gev[k]; } } } AttenCorr *atcor = new AttenCorr(); //Used to correct sigcor for attenuation, using AttenCorr determination of hit location on strip Calibrator& cal = Calibrator::Instance(); cal.GetAttenCalibrator().Reset(record->GetHeader().GetVldContext()); for(int istp = 0; istp< nstrips; istp++){ if(event->stp[istp]<0) continue; const NtpSRStrip* strip = dynamic_cast<const NtpSRStrip*>(record->stp->At(event->stp[istp])); // const NtpTHStrip* stptruth= dynamic_cast<const NtpTHStrip*>(record->thstp->At(event->stp[istp])); // assert(stptruth); // if(stptruth!=NULL && ispurextalk(stptruth->sigflg)) continue; float qpeE = strip->ph0.pe; float qpeW = strip->ph1.pe; //for qtype = 3, 4, or 6, should check if strip has energy info //it's possible for a strip to have pe info but not energy info if, for example, it has not been included as part of a track or shower //for qtype = 1,2,5, should check if strip somehow doesn't have sigcor info bool checkgev = 1; if (qtype == 3 || qtype == 4 || qtype == 6) { if (ph0[strip->index] + ph1[strip->index] == 0) checkgev = 0; } if (qtype == 1 || qtype == 2 || qtype == 5) { if (strip->ph0.sigcor + strip->ph1.sigcor == 0) checkgev = 0; } if(qpeE+qpeW>_peThreshold && qpeE+qpeW < 1000 && strip->plane<=lastPlaneToUse && checkgev){ float qchargeCor = 0; float qchargeE = qpeE; float qchargeW = qpeW; if (qtype == 0) { atcor->CalcCorr(record,strip,meanUTPos,meanVTPos,0); qchargeCor = atcor->qpecor; } if (qtype == 1 || qtype == 2 ) { FloatErr xstrip = (atcor->lE - atcor->lW) / 2; qchargeE = strip->ph0.sigcor; qchargeW = strip->ph1.sigcor; if (detector==Detector::kNear) { //Sigcors and sigmaps are different in ND qchargeE *= FN_SIGMAP_RATIO; qchargeW *= FN_SIGMAP_RATIO; } PlexStripEndId end[2]; end[0] = strip->GetStripEndId((Detector::Detector_t)detector); end[0].SetEnd(StripEnd::kNegative); end[1] = strip->GetStripEndId((Detector::Detector_t)detector); end[1].SetEnd(StripEnd::kPositive); FloatErr qchargeECor = cal.GetAttenCorrected(FloatErr(qchargeE),xstrip,end[0]); FloatErr qchargeWCor = cal.GetAttenCorrected(FloatErr(qchargeW),xstrip,end[1]); qchargeCor = qchargeECor.GetValue() + qchargeWCor.GetValue(); } if (qtype == 3 || qtype == 4 || qtype == 6) { qchargeE = ph0[strip->index]; qchargeW = ph1[strip->index]; qchargeCor = qchargeE + qchargeW; } if (qtype == 5) { qchargeE = strip->ph0.sigcor; qchargeW = strip->ph1.sigcor; atcor->CalcCorr(record,strip,meanUTPos,meanVTPos,5); qchargeCor = atcor->qpecor; if (detector==Detector::kNear) { qchargeE *= ND_PE_TO_SIGCOR_RATIO; qchargeW *= ND_PE_TO_SIGCOR_RATIO; qchargeCor *= ND_PE_TO_SIGCOR_RATIO; } if (detector==Detector::kFar) { qchargeE *= FD_PE_TO_SIGCOR_RATIO; qchargeW *= FD_PE_TO_SIGCOR_RATIO; qchargeCor *= FD_PE_TO_SIGCOR_RATIO; } } sumQcor+= qchargeCor; sumQraw+= qchargeE+qchargeW; compactStrip_h compactStrip; compactStrip.plane = static_cast<short>(strip->plane-meanPlane+100); if(strip->planeview==2)compactStrip.strip = ndstripno(strip->plane, strip->strip,strip->planeview, detector)-imeanU+100; if(strip->planeview==3)compactStrip.strip = ndstripno(strip->plane, strip->strip,strip->planeview, detector)-imeanV+100; if (qtype == 0 || qtype == 5) { compactStrip.icharge = static_cast<int>(qchargeCor * chargeScale); } if (qtype == 1 || qtype == 2 || qtype == 3 || qtype == 4 || qtype == 6) { compactStrip.icharge = static_cast<int>( (qchargeCor - ChargeToPe/2) * chargeScale / ChargeToPe); } if(compactStrip.strip>=5&&compactStrip.strip<=195&&compactStrip.plane>=5&&compactStrip.plane<=195){ if(strip->planeview==2)UStrips.push_back(compactStrip); if(strip->planeview==3)VStrips.push_back(compactStrip); } }//threshold }//strips loop delete [] ph0; delete [] ph1; Qtot = static_cast<int>(sumQcor); Qtotraw = static_cast<int>(sumQraw); return; }

MinosCompactEvent::MinosCompactEvent (  const MinosCompactEvent *  event, int  stripCompressionFactor )

Definition at line 744 of file MinosCompactEvent.cxx. References _peThreshold, chargeScale, ChargeType, eNu, compactStrip_h::icharge, idact, idnu, idres, meanPlane, meanU, meanV, nphysics, nPlanes, nremoved, nxtalk, nxtalk_mistagged, nxtalk_tagged, compactStrip_h::plane, Qtot, Qtotraw, Run, SetPEThreshold(), Snarl, compactStrip_h::strip, UStrips, VStrips, and y. { // PE Scale factor for integer conversion: icharge = qpe * chargeScale chargeScale = event->chargeScale; // PE Threshold SetPEThreshold(event->_peThreshold); // set the global quantities Run = event->Run; Snarl = event->Snarl; // set any MC quantities eNu = event->eNu; y = event->y; idact = event->idact; idres = event->idres; idnu = event->idnu; // reco quantities Qtot = event->Qtot; nPlanes = event->nPlanes; meanU = event->meanU; meanV = event->meanV; meanPlane = event->meanPlane; nxtalk = event->nxtalk; nxtalk_tagged = event->nxtalk_tagged; nxtalk_mistagged = event->nxtalk_mistagged; nphysics = event->nphysics; nremoved = event->nremoved; ChargeType = event->ChargeType; //MHO0609 - Discovered this wasn't getting copied Qtotraw = event->Qtotraw; // loop over the U strips int imeanU = static_cast<int>(meanU); float fracU = meanU - static_cast<float>(imeanU); const int nustrips = event->UStrips.size(); for(int istp = 0; istp< nustrips; istp++){ int plane = event->UStrips[istp].plane; int strip = event->UStrips[istp].strip; int icharge = event->UStrips[istp].icharge; float cstrip = (static_cast<float>(strip) -100.0+stripCompressionFactor/2.0)/stripCompressionFactor + 100.0; if((stripCompressionFactor%2)==0 && fracU>0.5){ cstrip = (static_cast<float>(strip) -101.0+stripCompressionFactor/2.0)/stripCompressionFactor + 100.0; } int compStrip = static_cast<int>(cstrip); bool notFound = true; for(UInt_t i=0;i<UStrips.size() && notFound;++i){ if(UStrips[i].strip==compStrip && UStrips[i].plane==plane){ notFound = false; UStrips[i].icharge += icharge; } } if(notFound){ compactStrip_h newStrip; newStrip.strip = compStrip; newStrip.plane = plane; newStrip.icharge = icharge; UStrips.push_back(newStrip); } } // loop over the V strips int imeanV = static_cast<int>(meanV); float fracV = meanV - static_cast<float>(imeanV); const int nvstrips = event->VStrips.size(); for(int istp = 0; istp< nvstrips; istp++){ int plane = event->VStrips[istp].plane; int strip = event->VStrips[istp].strip; int icharge = event->VStrips[istp].icharge; float cstrip = (static_cast<float>(strip)-100.0+stripCompressionFactor/2.0)/stripCompressionFactor + 100.0; if((stripCompressionFactor%2)==0 && fracV>0.5){ cstrip = (static_cast<float>(strip) -101.0+stripCompressionFactor/2.0)/stripCompressionFactor + 100.0; } int compStrip = static_cast<int>(cstrip); bool notFound = true; for(UInt_t i=0;i<VStrips.size() && notFound;++i){ if(VStrips[i].strip==compStrip && VStrips[i].plane==plane){ notFound = false; VStrips[i].icharge += icharge; } } if(notFound){ compactStrip_h newStrip; newStrip.strip = compStrip; newStrip.plane = plane; newStrip.icharge = icharge; VStrips.push_back(newStrip); } } return; }

MinosCompactEvent::MinosCompactEvent (  const MinosCompactEvent *  event, int  pattern[201] )

Definition at line 858 of file MinosCompactEvent.cxx. References _peThreshold, chargeScale, ChargeType, eNu, compactStrip_h::icharge, idact, idnu, idres, meanPlane, meanU, meanV, nphysics, nPlanes, nremoved, nxtalk, nxtalk_mistagged, nxtalk_tagged, compactStrip_h::plane, Qtot, Qtotraw, Run, SetPEThreshold(), Snarl, compactStrip_h::strip, UStrips, VStrips, and y. { // PE Scale factor for integer conversion: icharge = qpe * chargeScale chargeScale = event->chargeScale; // PE Threshold SetPEThreshold(event->_peThreshold); // set the global quantities Run = event->Run; Snarl = event->Snarl; // set any MC quantities eNu = event->eNu; y = event->y; idact = event->idact; idres = event->idres; idnu = event->idnu; // reco quantities Qtot = event->Qtot; nPlanes = event->nPlanes; meanU = event->meanU; meanV = event->meanV; meanPlane = event->meanPlane; nxtalk = event->nxtalk; nxtalk_tagged = event->nxtalk_tagged; nxtalk_mistagged = event->nxtalk_mistagged; nphysics = event->nphysics; nremoved = event->nremoved; ChargeType = event->ChargeType; //MHO0609 - Discovered this wasn't getting copied Qtotraw = event->Qtotraw; // loop over the U strips const int nustrips = event->UStrips.size(); for(int istp = 0; istp< nustrips; istp++){ int plane = event->UStrips[istp].plane; int strip = event->UStrips[istp].strip; int icharge = event->UStrips[istp].icharge; int compStrip = pattern[strip]; bool notFound = true; if (compStrip!=-1){ for(UInt_t i=0;i<UStrips.size() && notFound;++i){ if(UStrips[i].strip==compStrip && UStrips[i].plane==plane){ notFound = false; UStrips[i].icharge += icharge; } } if(notFound){ compactStrip_h newStrip; newStrip.strip = compStrip; newStrip.plane = plane; newStrip.icharge = icharge; UStrips.push_back(newStrip); } } } // loop over the V strips const int nvstrips = event->VStrips.size(); for(int istp = 0; istp< nvstrips; istp++){ int plane = event->VStrips[istp].plane; int strip = event->VStrips[istp].strip; int icharge = event->VStrips[istp].icharge; int compStrip = pattern[strip]; bool notFound = true; if (compStrip!=-1){ for(UInt_t i=0;i<VStrips.size() && notFound;++i){ if(VStrips[i].strip==compStrip && VStrips[i].plane==plane){ notFound = false; VStrips[i].icharge += icharge; } } if(notFound){ compactStrip_h newStrip; newStrip.strip = compStrip; newStrip.plane = plane; newStrip.icharge = icharge; VStrips.push_back(newStrip); } } } return; }

MinosCompactEvent::MinosCompactEvent (  const MinosCompactEvent *  event  )

Definition at line 958 of file MinosCompactEvent.cxx. References _peThreshold, chargeScale, ChargeType, eNu, compactStrip_h::icharge, idact, idnu, idres, meanPlane, meanU, meanV, nphysics, nPlanes, nremoved, nxtalk, nxtalk_mistagged, nxtalk_tagged, compactStrip_h::plane, Qtot, Qtotraw, Run, SetPEThreshold(), Snarl, compactStrip_h::strip, UStrips, VStrips, and y. { // PE Scale factor for integer conversion: icharge = qpe * chargeScale chargeScale = event->chargeScale; //_peThreshold SetPEThreshold(event->_peThreshold); // set the global quantities Run = event->Run; Snarl = event->Snarl; // set any MC quantities eNu = event->eNu; y = event->y; idact = event->idact; idres = event->idres; idnu = event->idnu; // reco quantities Qtot = event->Qtot; nPlanes = event->nPlanes; meanU = event->meanU; meanV = event->meanV; meanPlane = event->meanPlane; nxtalk = event->nxtalk; nxtalk_tagged = event->nxtalk_tagged; nxtalk_mistagged = event->nxtalk_mistagged; nphysics = event->nphysics; nremoved = event->nremoved; ChargeType = event->ChargeType; //MHO0609 - Discovered this wasn't getting copied Qtotraw = event->Qtotraw; // loop over the U strips const int nustrips = event->UStrips.size(); for(int istp = 0; istp< nustrips; istp++){ compactStrip_h newStrip; newStrip.strip = event->UStrips[istp].strip; newStrip.plane = event->UStrips[istp].plane; newStrip.icharge = event->UStrips[istp].icharge; UStrips.push_back(newStrip); } // loop over the V strips const int nvstrips = event->VStrips.size(); for(int istp = 0; istp< nvstrips; istp++){ compactStrip_h newStrip; newStrip.strip = event->VStrips[istp].strip; newStrip.plane = event->VStrips[istp].plane; newStrip.icharge = event->VStrips[istp].icharge; VStrips.push_back(newStrip); } return; }

MinosCompactEvent::~MinosCompactEvent (   )  [virtual]

Definition at line 737 of file MinosCompactEvent.cxx. References UStrips, and VStrips. { UStrips.clear(); VStrips.clear(); }

---

Member Function Documentation

Int_t MinosCompactEvent::GetLastPlaneToUse (  const NtpStRecord *  record, int  eventno, int  max_strips_cut = 3, int  max_gap = 3 )

Definition at line 1020 of file MinosCompactEvent.cxx. References _peThreshold, NtpStRecord::evt, NtpSREvent::nstrip, NtpSRPulseHeight::pe, NtpSRStrip::ph0, NtpSRStrip::ph1, NtpSRStrip::plane, NtpStRecord::stp, and NtpSREvent::stp. Referenced by MinosCompactEvent(). { // efficiency not critical here, so keep it simple... const int maxplanes = 500; int planecount[maxplanes]; int firstplane = 999; int lastplane = 0; for (Int_t i=0;i<maxplanes;i++) planecount[i] = 0; const NtpSREvent* event = dynamic_cast<const NtpSREvent*>(record->evt->At(eventno)); const int nstrips = event->nstrip; // fill array of plane counts for(int istp = 0; istp< nstrips; istp++){ if (event->stp[istp]<0) continue; const NtpSRStrip* strip = dynamic_cast<const NtpSRStrip*>(record->stp->At(event->stp[istp])); float qpe=strip->ph0.pe+strip->ph1.pe; if (qpe>_peThreshold && qpe<1000) { planecount[strip->plane]++; if (strip->plane>lastplane) lastplane = strip->plane; if (strip->plane<firstplane) firstplane = strip->plane; } } // find plane upstream of cut-able strips Int_t downstream_strip_count = 0; Int_t searchstart; for (searchstart=lastplane; searchstart>=firstplane;searchstart--) { downstream_strip_count += planecount[searchstart]; if (downstream_strip_count>max_strips_cut) break; } // loop over candidate planes, looking for first big gap Int_t gap_count = 0; Int_t cut_beyond_here = 9999; for (Int_t iP=searchstart+1; iP<=lastplane;iP++) { if (planecount[iP]==0) gap_count++; else gap_count = 0; if (gap_count>max_gap) { cut_beyond_here = iP; break; } } return cut_beyond_here; }

void MinosCompactEvent::Merge (  MinosCompactEvent *  pcce2  )

Definition at line 105 of file MinosCompactEvent.cxx. References _peThreshold, chargeScale, eNu, idact, idnu, idres, meanPlane, meanU, meanV, nphysics, nPlanes, nremoved, nxtalk, nxtalk_mistagged, nxtalk_tagged, Qtot, Run, Snarl, UStrips, VStrips, and y. { //If variables are not identical then set default. if(Run!=pcce2->Run) Run=-1; if(Snarl!=pcce2->Snarl) Snarl=-1; if(chargeScale!=pcce2->chargeScale) chargeScale=-1; if(_peThreshold!=pcce2->_peThreshold) _peThreshold=-1; if(meanU!=pcce2->meanU) meanU=-1; if(meanV!=pcce2->meanV) meanV=-1; if(meanPlane!=pcce2->meanPlane) meanPlane=-1; if(Qtot!=pcce2->Qtot) Qtot=-1; if(nPlanes!=pcce2->nPlanes) nPlanes=-1; if(eNu!=pcce2->eNu) eNu=-1; if(y!=pcce2->y) y=-1; if(idact!=pcce2->idact) idact=-1; if(idres!=pcce2->idres) idres=-1; if(idnu!=pcce2->idnu) idnu=-1; if(nxtalk!=pcce2->nxtalk) nxtalk=-1; if(nxtalk_tagged!=pcce2->nxtalk_tagged) nxtalk_tagged=-1; if(nxtalk_mistagged!=pcce2->nxtalk_mistagged) nxtalk_mistagged=-1; if(nphysics!=pcce2->nphysics) nphysics=-1; if(nremoved!=pcce2->nremoved) nremoved=-1; //Loop over U strips const int nustrips = UStrips.size(); const int nustrips2 = pcce2->UStrips.size(); for(int istp2 = 0; istp2< nustrips2; istp2++){ Bool_t added=false; for(int istp = 0; istp < nustrips; istp++){ if(UStrips[istp].plane == pcce2->UStrips[istp2].plane && UStrips[istp].strip == pcce2->UStrips[istp2].strip && added==false ){ UStrips[istp].icharge += pcce2->UStrips[istp2].icharge; added=true; } } if(added==false){ UStrips.push_back(pcce2->UStrips[istp2]); } } //Loop over V strips const int nvstrips = VStrips.size(); const int nvstrips2 = pcce2->VStrips.size(); for(int istp2 = 0; istp2< nvstrips2; istp2++){ Bool_t added=false; for(int istp = 0; istp < nvstrips; istp++){ if(VStrips[istp].plane == pcce2->VStrips[istp2].plane && VStrips[istp].strip == pcce2->VStrips[istp2].strip && added==false ){ VStrips[istp].icharge += pcce2->VStrips[istp2].icharge; added=true; } } if(added==false){ VStrips.push_back(pcce2->VStrips[istp2]); } } }

void MinosCompactEvent::Print (   )

Definition at line 186 of file MinosCompactEvent.cxx. References chargeScale, ChargeType, eNu, idact, idnu, idres, meanPlane, meanU, meanV, nphysics, nPlanes, nremoved, nxtalk, nxtalk_mistagged, nxtalk_tagged, Qtot, Qtotraw, Run, Snarl, UStrips, VStrips, and y. { cout << "***Printing MinosCompactEvent" << endl; cout << "Run: " << Run << endl; cout << "Snarl: " << Snarl << endl; cout << "chargeScale: " << chargeScale << endl; cout << "meanU and meanV: " << meanU << " , " << meanV << endl; cout << "meanPlane: " << meanPlane << endl; cout << "Qtot: " << Qtot << endl; //MHO0509 cout << "Qtotraw: " << Qtotraw << endl; cout << "nPlanes: " << nPlanes << endl; cout << "eNu: " << eNu << endl; cout << "y: " << y << endl; cout << "idnu and idact: " << idnu << " , " << idact << endl; cout << "idres: " << idres << endl; cout << "nxtalk: " << nxtalk << endl; cout << "nxtalk_tagged: " << nxtalk_tagged << endl; cout << "nxtalk_mistagged: " << nxtalk_mistagged << endl; cout << "nphysics: " << nphysics << endl; cout << "nremoved: " << nremoved << endl; //MHO0509 cout << "ChargeType: " << ChargeType << endl; const int nustrips = UStrips.size(); cout << "--> U strips (pln,stp,q):" << nustrips << endl; for(int istp = 0; istp< nustrips; istp++){ cout << UStrips[istp].plane << "," << UStrips[istp].strip << "," << UStrips[istp].icharge << endl; } const int nvstrips = VStrips.size(); cout << "--> V strips (pln,stp,q):" << nvstrips << endl; for(int istp = 0; istp< nvstrips; istp++){ cout << VStrips[istp].plane << "," << VStrips[istp].strip << "," << VStrips[istp].icharge << endl; } }

void MinosCompactEvent::ScaleCharges (  float  factor  )

Definition at line 172 of file MinosCompactEvent.cxx. References UStrips, and VStrips. { const int nustrips = UStrips.size(); for(int istp = 0; istp< nustrips; istp++){ UStrips[istp].icharge=(int)(UStrips[istp].icharge*factor); } const int nvstrips = VStrips.size(); for(int istp = 0; istp< nvstrips; istp++){ VStrips[istp].icharge=(int)(VStrips[istp].icharge*factor); } }

void MinosCompactEvent::SetPEThreshold (  float  qpe  )

Definition at line 93 of file MinosCompactEvent.cxx. References _peThreshold. Referenced by MinosCompactEvent(). { _peThreshold = q; }

int MinosCompactEvent::SizeOf (   )

Definition at line 722 of file MinosCompactEvent.cxx. References total(), UStrips, and VStrips. { // Calculate the size of the object including what's in the vectors int total = 0 ; total += sizeof(*this); int nU = UStrips.capacity(); int nV = VStrips.capacity(); total += sizeof(UStrips[0])*(nU+nV); return total; }

---

Member Data Documentation

float MinosCompactEvent::_peThreshold

Definition at line 49 of file MinosCompactEvent.h. Referenced by GetLastPlaneToUse(), Merge(), MinosCompactEvent(), and SetPEThreshold().

float MinosCompactEvent::chargeScale

Definition at line 53 of file MinosCompactEvent.h. Referenced by MCNNRunner::CompareEvents(), MinosEventDisplay::Draw(), Merge(), MinosCompactEvent(), and Print().

unsigned short MinosCompactEvent::ChargeType

Definition at line 79 of file MinosCompactEvent.h. Referenced by MCNNRunner::CompareEvents(), MinosCompactEvent(), and Print().

float MinosCompactEvent::eNu

Definition at line 62 of file MinosCompactEvent.h. Referenced by Merge(), MinosCompactEvent(), Print(), ComparisonResult::SetNeutrino(), and MinosExtraCompactResult::SetNu().

short MinosCompactEvent::idact

Definition at line 64 of file MinosCompactEvent.h. Referenced by Merge(), MinosCompactEvent(), Print(), ComparisonResult::SetNeutrino(), and MinosExtraCompactResult::SetNu().

short MinosCompactEvent::idnu

Definition at line 66 of file MinosCompactEvent.h. Referenced by Merge(), MinosCompactEvent(), Print(), ComparisonResult::SetNeutrino(), and MinosExtraCompactResult::SetNu().

short MinosCompactEvent::idres

Definition at line 65 of file MinosCompactEvent.h. Referenced by Merge(), MinosCompactEvent(), Print(), ComparisonResult::SetNeutrino(), and MinosExtraCompactResult::SetNu().

int MinosCompactEvent::meanPlane

Definition at line 58 of file MinosCompactEvent.h. Referenced by MCNNFiller::FillMCNN(), Merge(), MinosCompactEvent(), Print(), and MinosExtraCompactResult::SetNu().

float MinosCompactEvent::meanU

Definition at line 56 of file MinosCompactEvent.h. Referenced by MCNNFiller::FillMCNN(), Merge(), MinosCompactEvent(), Print(), and MinosExtraCompactResult::SetNu().

float MinosCompactEvent::meanV

Definition at line 57 of file MinosCompactEvent.h. Referenced by MCNNFiller::FillMCNN(), Merge(), MinosCompactEvent(), Print(), and MinosExtraCompactResult::SetNu().

int MinosCompactEvent::nphysics

Definition at line 74 of file MinosCompactEvent.h. Referenced by Merge(), MinosCompactEvent(), and Print().

int MinosCompactEvent::nPlanes

Definition at line 61 of file MinosCompactEvent.h. Referenced by MCNNRunner::CompactInput(), MCNNFiller::FillMCNN(), MCNNRunner::MakeComparison(), Merge(), MinosCompactEvent(), Print(), and MinosExtraCompactResult::SetNu().

int MinosCompactEvent::nremoved

Definition at line 75 of file MinosCompactEvent.h. Referenced by Merge(), MinosCompactEvent(), and Print().

int MinosCompactEvent::nxtalk

Definition at line 71 of file MinosCompactEvent.h. Referenced by Merge(), MinosCompactEvent(), and Print().

int MinosCompactEvent::nxtalk_mistagged

Definition at line 73 of file MinosCompactEvent.h. Referenced by Merge(), MinosCompactEvent(), and Print().

int MinosCompactEvent::nxtalk_tagged

Definition at line 72 of file MinosCompactEvent.h. Referenced by Merge(), MinosCompactEvent(), and Print().

int MinosCompactEvent::Qtot

Definition at line 59 of file MinosCompactEvent.h. Referenced by MCNNRunner::CompactInput(), MCNNRunner::MakeComparison(), Merge(), MinosCompactEvent(), Print(), ComparisonResult::SetNeutrino(), and MinosExtraCompactResult::SetNu().

int MinosCompactEvent::Qtotraw

Definition at line 60 of file MinosCompactEvent.h. Referenced by MinosCompactEvent(), and Print().

int MinosCompactEvent::Run

Definition at line 50 of file MinosCompactEvent.h. Referenced by Merge(), MinosCompactEvent(), Print(), ComparisonResult::SetNeutrino(), and MinosExtraCompactResult::SetNu().

int MinosCompactEvent::Snarl

Definition at line 51 of file MinosCompactEvent.h. Referenced by Merge(), MinosCompactEvent(), Print(), and ComparisonResult::SetNeutrino().

std::vector<compactStrip_h> MinosCompactEvent::UStrips

Definition at line 76 of file MinosCompactEvent.h. Referenced by MCNNRunner::ClearWorkSpaceA(), MCNNRunner::ClearWorkSpaceB(), MCNNRunner::CompactInput(), MCNNRunner::CompareEvents(), MinosEventDisplay::Draw(), MCNNRunner::FillWorkSpaceA(), MCNNRunner::FillWorkSpaceB(), MCNNRunner::MakeComparison(), Merge(), MinosCompactEvent(), Print(), ScaleCharges(), ComparisonResult::SetNeutrino(), SizeOf(), and ~MinosCompactEvent().

std::vector<compactStrip_h> MinosCompactEvent::VStrips

Definition at line 77 of file MinosCompactEvent.h. Referenced by MCNNRunner::ClearWorkSpaceA(), MCNNRunner::ClearWorkSpaceB(), MCNNRunner::CompactInput(), MCNNRunner::CompareEvents(), MinosEventDisplay::Draw(), MCNNRunner::FillWorkSpaceA(), MCNNRunner::FillWorkSpaceB(), MCNNRunner::MakeComparison(), Merge(), MinosCompactEvent(), Print(), ScaleCharges(), ComparisonResult::SetNeutrino(), SizeOf(), and ~MinosCompactEvent().

float MinosCompactEvent::y

Definition at line 63 of file MinosCompactEvent.h. Referenced by Merge(), MinosCompactEvent(), Print(), ComparisonResult::SetNeutrino(), and MinosExtraCompactResult::SetNu().

---

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

• MinosCompactEvent.h
• MinosCompactEvent.cxx

---