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)
void FillAllStrips ()
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_hUStrips
std::vector< compactStrip_hVStrips
std::vector< compactStrip_hAllStrips
unsigned short ChargeType

Detailed Description

Definition at line 41 of file MinosCompactEvent.h.


Constructor & Destructor Documentation

MinosCompactEvent::MinosCompactEvent ( unsigned short  qtype = 0  ) 

Definition at line 68 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.

00069 {
00070 
00071   Run = -1;
00072   Snarl = -1;
00073   chargeScale = -1;
00074   meanU = -1;
00075   meanV = -1;
00076   meanPlane = -1;
00077   Qtot = -1;
00078   nPlanes = -1;
00079   eNu = -1;
00080   y = -1;
00081   idact = -1;
00082   idres = -1;
00083   idnu = -1;
00084   nxtalk = -1;
00085   nxtalk_tagged = -1;
00086   nxtalk_mistagged = -1;
00087   nphysics = -1;
00088   nremoved = -1;
00089   //UStrips.reserve(1);
00090   //VStrips.reserve(1);
00091 
00092   ChargeType = qtype;
00093 
00094 }

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

Definition at line 230 of file MinosCompactEvent.cxx.

References _peThreshold, AttenCorr::CalcCorr(), CD_PE_TO_SIGCOR_RATIO, chargeScale, ChargeType, XTalkFilter::Config(), XTalkFilter::DefaultConfig(), XTalkFilter::DoTrueFilter(), eNu, NtpStRecord::evt, NtpStRecord::evthdr, FD_PE_TO_SIGCOR_RATIO, FillAllStrips(), FN_SIGMAP_RATIO, 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, Detector::kCalDet, Detector::kFar, Detector::kNear, StripEnd::kNegative, StripEnd::kPositive, AttenCorr::lE, AttenCorr::lW, NtpStRecord::mc, meanPlane, meanU, meanV, ND_PE_TO_SIGCOR_RATIO, ndstripno(), NtpTHEvent::neumc, nphysics, nPlanes, nremoved, NtpSREventSummary::nstrip, NtpSRTrack::nstrip, NtpSRShower::nstrip, nxtalk, nxtalk_mistagged, nxtalk_tagged, NtpMCTruth::p4neu, NtpSRPulseHeight::pe, NtpSRStrip::ph0, NtpSRStrip::ph1, NtpSRStrip::plane, compactStrip_h::plane, PLANE_WINDOW, NtpSRStrip::planeview, AttenCorr::qpecor, Qtot, Qtotraw, CalScheme::Reset(), Run, PlexStripEndId::SetEnd(), SetPEThreshold(), NtpStRecord::shw, NtpSRPulseHeight::sigcor, Snarl, NtpSRShower::stp, NtpStRecord::stp, NtpSRTrack::stp, NtpSRShower::stpph0gev, NtpSRTrack::stpph0gev, NtpSRShower::stpph1gev, NtpSRTrack::stpph1gev, compactStrip_h::strip, NtpSRStrip::strip, STRIP_WINDOW, NtpStRecord::thevt, NtpSRStrip::tpos, NtpStRecord::trk, UStrips, VStrips, y, and NtpMCTruth::y.

00231 {
00232 
00233   Qtot = 0;
00234   Qtotraw = 0;
00235 
00236   ChargeType = qtype;
00237 
00238   // need to be able to modify the record (xtalk removal)
00239   NtpStRecord *record = (NtpStRecord*)record_const->Clone();
00240 
00241   // xtalk removal --
00242   if (qtype==2 || qtype==4) {
00243     // we want to apply the xtalk filter, so build a module and use it
00244     // (it would be better if there were a convenient way to keep one
00245     // persistent, but making one anew each time is not too bad.)
00246     XTalkFilter *xtalkfilter = new XTalkFilter();
00247     xtalkfilter->Config(xtalkfilter->DefaultConfig());
00248     xtalkfilter->DoTrueFilter(record,eventno);
00249     delete xtalkfilter;
00250   }
00251 
00252   //build a geometry handle
00253   UgliGeomHandle ugh(record->GetHeader().GetVldContext());
00254 
00255   const int detector = record->GetHeader().GetVldContext().GetDetector();
00256 
00257   const NtpSREvent* event = dynamic_cast<const NtpSREvent*>(record->evt->At(eventno));
00258   //assert(event); //If event==0, should create blank MinosCompactEvent, with the correct run and snarl numbers,
00259   //in order to maintain synchronization with AnaNue tree (NueModule::Reco creates a AnaNue tree with default values
00260   //when event==0)
00261   if (!event) {
00262     Run   = record->GetHeader().GetRun();
00263     Snarl = record->GetHeader().GetSnarl();
00264 
00265     //Remainder copied from default constructor
00266     SetPEThreshold(3.0);
00267     chargeScale = -1;
00268     meanU = -1;
00269     meanV = -1;
00270     meanPlane = -1;
00271     Qtot = -1;
00272     nPlanes = -1;
00273     eNu = -1;
00274     y = -1;
00275     idact = -1;
00276     idres = -1;
00277     idnu = -1;
00278     nxtalk = -1;
00279     nxtalk_tagged = -1;
00280     nxtalk_mistagged = -1;
00281     nphysics = -1;
00282     nremoved = -1;
00283     //UStrips.reserve(1);
00284     //VStrips.reserve(1);
00285     return;
00286   }
00287 
00288   const NtpMCTruth* mcevent  = NULL;
00289   if(record && record->thevt->GetEntries()!=0){
00290     const NtpTHEvent* thevent = dynamic_cast<const NtpTHEvent*>(record->thevt->At(eventno));
00291     mcevent = dynamic_cast<const NtpMCTruth*>(record->mc->At(thevent->neumc));
00292   }
00293   
00294   bool planes[500];
00295   for(int i=0;i<500;++i)planes[i]=false;  
00296 
00297   chargeScale = 10.;
00298 
00299   Double_t ChargeToPe = 1.0; //For qtype 1-4 and 6, this is the approximate charge in units of qtype found in 1 pe.
00300                              //It is identical to the sigcorscale in the HitProbTable used with this qtype.
00301   if (qtype == 1 || qtype == 2) ChargeToPe = 70.0; //Roughly 70 sigmaps per pe.
00302   if (qtype == 3 || qtype == 4 || qtype == 6) ChargeToPe = 8.0; //Rougly 8 MeV per pe.
00303 
00304   if(Detector::kFar == detector){//FD
00305     SetPEThreshold(3.0);
00306   } else SetPEThreshold(3.0); 
00307 
00308 
00309   // set the global quantities
00310   Run   = record->GetHeader().GetRun();
00311   Snarl = record->GetHeader().GetSnarl();
00312 
00313   // cout << "*************************************************" << endl;
00314   //cout << " RUN/SNARL : " << Run << " : " << Snarl << endl;
00315  
00316   // set any MC quantities
00317   if(mcevent){
00318     eNu   = mcevent->p4neu[3];
00319     y     = mcevent->y;
00320     idact = mcevent->iaction; 
00321     idres = mcevent->iresonance;
00322     idnu  = mcevent->inu;
00323   } else {
00324     eNu   = -1;
00325     y     = -1;
00326     idact = -1; 
00327     idres = -1;
00328     idnu  = -1;
00329   }
00330 
00331   const int nstrips = event->nstrip;
00332 
00333   //MCNN version of xtalk removal no longer supported. These data members
00334   //are being left in for backward compatibility.
00335   nxtalk=0;
00336   nxtalk_tagged=0;
00337   nxtalk_mistagged=0;
00338   nphysics=0;
00339   nremoved=0;
00340 
00341 
00342   // --- Z trimming ---
00343   // Decide if there is a plane past which we should ignore everything (i.e., trailing hits)
00344   // Only do this for the newer charge types (but not qtype = 5, which is pe-scaled sigcors)...
00345   // Now, qtype=6 is the same as qtype=3 but without the z-trimming
00346   Int_t lastPlaneToUse = 99999;
00347   if (qtype>0 && qtype != 5 && qtype != 6) lastPlaneToUse = GetLastPlaneToUse(record, eventno);
00348 
00349   // loop over the strips to determine number of u and v strips to be stored
00350   int nU = 0;
00351   int nV = 0;
00352   int nUKept = 0;
00353   int nVKept = 0;
00354   for(int istp = 0; istp< nstrips; istp++){
00355     if(event->stp[istp]<0) continue;
00356     const NtpSRStrip* strip = dynamic_cast<const NtpSRStrip*>(record->stp->At(event->stp[istp]));
00357     if (!strip) continue; //protecting against null strip pointer
00358     float qpe = strip->ph0.pe+strip->ph1.pe;
00359     
00360     if(qpe>_peThreshold && qpe < 1000 && strip->plane<=lastPlaneToUse){
00361       planes[strip->plane]=true;
00362       if(strip->planeview==2)nU++;
00363       if(strip->planeview==3)nV++;
00364     }
00365   }
00366 
00367   nPlanes = 0;
00368   int minPlane = -999;
00369   int maxPlane = 999;
00370   int ncount   = 0;
00371   for(int i=0;i<500;++i){
00372     if(planes[i]){
00373       nPlanes++;
00374       if(minPlane<0)minPlane=i;
00375       ncount++;
00376       if(ncount==PLANE_WINDOW)maxPlane =i;
00377     }
00378   }
00379 
00380   //Array to hold qpe totals
00381   Float_t qpe_totU[201]={0.};
00382   Float_t qpe_totV[201]={0.};
00383 
00384   //Array to hold strip totals
00385   Int_t stp_totU[201]={0};
00386   Int_t stp_totV[201]={0};
00387 
00388   Int_t strip_count_u = 0;
00389   Int_t strip_count_v = 0;
00390 
00391 
00392   // now find charge weighted mean strip and plane in first  
00393   //    AVERAGE_OVER_PLANES planes
00394 
00395   double sumU = 0.;
00396   double sumV = 0.;
00397   double sumZ = 0.;
00398   double sumQ = 0.;
00399   double UsumQ = 0.;
00400   double VsumQ = 0.;
00401   int striptrue = 0;
00402 
00403   for(int istp = 0; istp< nstrips; istp++){
00404     if(event->stp[istp]<0) continue;
00405     const NtpSRStrip* strip = dynamic_cast<const NtpSRStrip*>(record->stp->At(event->stp[istp]));
00406     if (!strip) continue; //protecting against null strip pointer
00407     float qpe = strip->ph0.pe+strip->ph1.pe;
00408 
00409     if(qpe>_peThreshold && qpe < 1000){
00410       if(strip->plane>=minPlane&&strip->plane<=maxPlane){
00411         if(strip->planeview==2){
00412           striptrue = ndstripno(strip->plane, strip->strip,strip->planeview, detector);
00413           qpe_totU[striptrue] += qpe;
00414           stp_totU[striptrue]++;
00415           strip_count_u++;
00416         }
00417         if(strip->planeview==3){
00418           striptrue = ndstripno(strip->plane, strip->strip,strip->planeview, detector);
00419           qpe_totV[striptrue] += qpe;
00420           stp_totV[striptrue]++;
00421           strip_count_v++;
00422         }
00423       }
00424     }
00425   }
00426   
00427   
00428   Float_t u_qtot=0;
00429   Int_t u_stot=0;
00430   Float_t u_qmax=-1;
00431   Int_t u_smax=-1;
00432   Float_t u_qmax_nocut=-1;
00433   Int_t u_smax_nocut=-1;
00434 
00435   Float_t v_qtot=0;
00436   Int_t v_stot=0;
00437   Float_t v_qmax=-1;
00438   Int_t v_smax=-1;
00439   Float_t v_qmax_nocut=-1;
00440   Int_t v_smax_nocut=-1;
00441 
00442   for (Int_t ii=0;ii<201;ii++){
00443     u_qtot=0.;
00444     v_qtot=0.; 
00445     u_stot=0;
00446     v_stot=0;
00447 
00448     for (Int_t jj = (1 - STRIP_WINDOW); jj<(STRIP_WINDOW); jj++){
00449 
00450       if (((ii+jj)>=0)&&((ii+jj)<201)){
00451         u_qtot+=qpe_totU[ii+jj];
00452         v_qtot+=qpe_totV[ii+jj];
00453         u_stot+=stp_totU[ii+jj];
00454         v_stot+=stp_totV[ii+jj];
00455       }
00456     }
00457 
00458 
00460  
00461     //Without cut on numbers of strips
00462     if (v_qtot>v_qmax_nocut) {
00463       v_smax_nocut=ii;
00464       v_qmax_nocut=v_qtot;
00465     }
00466     
00467 
00468     //With careful attention to outlying noise strips
00469     if (v_qtot>v_qmax){
00470       
00471       if (strip_count_v>5&&v_stot>=3) {
00472         v_qmax=v_qtot;
00473         v_smax=ii;
00474       }
00475       else if (strip_count_v<=5&&strip_count_v>2&&v_stot>=2) {
00476         v_qmax=v_qtot;
00477         v_smax=ii;
00478       } 
00479       else if (strip_count_v<=2&&strip_count_v>0){
00480         v_qmax=v_qtot;
00481         v_smax=ii;
00482       }
00483       
00484     }
00485 
00487 
00488     //Without cut on numbers of strips
00489     if (u_qtot>u_qmax_nocut) {
00490       u_smax_nocut=ii;
00491       u_qmax_nocut=u_qtot;
00492     }
00493     
00494 
00495     //With careful attention to outlying noise strips
00496     if (u_qtot>u_qmax){
00497       
00498       if (strip_count_u>5&&u_stot>=3) {
00499         u_qmax=u_qtot;
00500         u_smax=ii;
00501       }
00502       else if (strip_count_u<=5&&strip_count_u>2&&u_stot>=2) {
00503         u_qmax=u_qtot;
00504         u_smax=ii;
00505       } 
00506       else if (strip_count_u<=2&&strip_count_u>0){
00507         u_qmax=u_qtot;
00508         u_smax=ii;
00509       }
00510       
00511     }
00512  
00513   }
00514 
00515   //Revert to just the largest window if everything fails outlier test
00516   if (u_smax<0) u_smax=u_smax_nocut;
00517   if (v_smax<0) v_smax=v_smax_nocut;
00518 
00519   int imeanUTemp = u_smax;
00520   int imeanVTemp = v_smax;
00521 
00522 
00523   // now do it all again throwing away outlying strips  
00524   meanU=0.;
00525   meanV=0.;
00526   sumU = 0.;
00527   sumV = 0.;
00528   sumZ = 0.;
00529   sumQ = 0.;
00530   UsumQ = 0.;
00531   VsumQ = 0.;
00532   double meanUTPos = 0;
00533   double meanVTPos = 0;
00534 
00535   for(int istp = 0; istp< nstrips; istp++){
00536     if(event->stp[istp]<0) continue;
00537     const NtpSRStrip* strip = dynamic_cast<const NtpSRStrip*>(record->stp->At(event->stp[istp]));
00538     if (!strip) continue; //protecting against null strip pointer
00539 //     const NtpTHStrip* stptruth= dynamic_cast<const NtpTHStrip*>(record->thstp->At(event->stp[istp]));
00540 //     assert(stptruth);
00541 //     if(stptruth!=NULL && ispurextalk(stptruth->sigflg)) continue;
00542 
00543     float qpe = strip->ph0.pe+strip->ph1.pe;
00544 
00545     if(qpe>_peThreshold && qpe < 1000 && strip->plane<=lastPlaneToUse){
00546       if(strip->plane>=minPlane&&strip->plane<=maxPlane){
00547         if(strip->planeview==2 && abs(ndstripno(strip->plane, strip->strip,strip->planeview, detector)-imeanUTemp)<STRIP_WINDOW){
00548           nUKept++;
00549           sumQ  += qpe;
00550           UsumQ += qpe*qpe;
00551           sumZ  += strip->plane*qpe;
00552           sumU  += ndstripno(strip->plane, strip->strip,strip->planeview, detector)*qpe*qpe;
00553           meanUTPos += strip->tpos*qpe*qpe;
00554           //      cout << "U STRIP : " << strip->Plane << " : " << strip->Strip << " : " << qpe << endl;
00555         }
00556         if(strip->planeview==3 && abs(ndstripno(strip->plane, strip->strip,strip->planeview, detector)-imeanVTemp)<STRIP_WINDOW){
00557           nVKept++;
00558           sumQ += qpe;
00559           VsumQ += qpe*qpe;
00560           sumZ += strip->plane*qpe;
00561           sumV  += ndstripno(strip->plane, strip->strip,strip->planeview, detector)*qpe*qpe;
00562           meanVTPos += strip->tpos*qpe*qpe;
00563          //cout << "V STRIP : " << strip->Plane << " : " << strip->Strip << " : " << qpe << endl;
00564         }
00565       }
00566     }
00567   } 
00568 
00569   // store mean charge-weighted positions
00570   meanU = 0.;
00571   meanV = 0.;
00572   meanPlane = 0;
00573   if(UsumQ>0){
00574     meanU = sumU/UsumQ+0.5;
00575     meanUTPos = meanUTPos/UsumQ;
00576   }
00577   if(VsumQ>0){
00578     meanV = sumV/VsumQ+0.5;
00579     meanVTPos = meanVTPos/VsumQ;
00580   }
00581   if(sumQ>0){
00582     meanPlane = static_cast<int>(sumZ/sumQ);
00583   }
00584     
00585   int imeanU = static_cast<int>(meanU);
00586   int imeanV = static_cast<int>(meanV);
00587   // cout << " MEANS : " << meanU << ":" << meanV << "  " <<  imeanU << ":" << imeanV << endl;
00588   
00589   // reserve the appropriate amount of space in vectors
00590   // this is purely to optimise memory usage
00591   UStrips.reserve(nU);
00592   VStrips.reserve(nV);
00593 
00594   //Up until this point, ALL computations were done using PEs. Now, when the compactStrips
00595   //are being built, charge quantities will be PEs, sigcors, or something else. However, threshold
00596   //checks will continue to be with PEs.
00597 
00598   // loop over the strips and build the compactStrips
00599   // apply attenuation corrections 
00600 
00601   // cout << "means tpos:" << meanUTPos << "   " << meanVTPos <<endl;
00602 
00603   float sumQcor = 0.;
00604   float sumQraw = 0.;
00605 
00606   //Extracting charge information from tracks and showers making up an event
00607   int nrecstrips = (int)record->evthdr.nstrip;
00608   float* ph0 = new float[nrecstrips];
00609   float* ph1 = new float[nrecstrips];
00610 
00611   if (qtype == 3 || qtype == 4 || qtype == 6) {
00612     
00613     for (int istp = 0; istp < nrecstrips; istp++) {
00614       ph0[istp] = 0;
00615       ph1[istp] = 0;
00616     }
00617     
00618     for (int j = 0; j < event->nshower; j++) {
00619       NtpSRShower* myshower = dynamic_cast<NtpSRShower*>(record->shw->At(event->shw[j]));
00620       for (int k = 0; k < myshower->nstrip; k++) {
00621         ph0[myshower->stp[k]] = 1000 * myshower->stpph0gev[k]; //GeV converted to MeV
00622         ph1[myshower->stp[k]] = 1000 * myshower->stpph1gev[k];
00623       }
00624     }
00625 
00626     //Tracks are done second so that in case of overlapping hits, the track's
00627     //energy information is used. Track positions are known better, resulting
00628     //in better attenuation correction.
00629     for (int j = 0; j < event->ntrack; j++) {
00630       NtpSRTrack* mytrack = dynamic_cast<NtpSRTrack*>(record->trk->At(event->trk[j]));
00631       for (int k = 0; k < mytrack->nstrip; k++) {
00632         ph0[mytrack->stp[k]] = 1000 * mytrack->stpph0gev[k];
00633         ph1[mytrack->stp[k]] = 1000 * mytrack->stpph1gev[k];
00634       }
00635     }
00636     
00637   }
00638   
00639   AttenCorr *atcor = new AttenCorr();
00640 
00641   //Used to correct sigcor for attenuation, using AttenCorr determination of hit location on strip
00642   Calibrator& cal = Calibrator::Instance();
00643   if (detector != Detector::kCalDet) cal.GetAttenCalibrator().Reset(record->GetHeader().GetVldContext());
00644   else {
00645     cout << "VldContext has not been set on Calibrator instance because this is CalDet data or MC!" << endl;
00646     cout << "You should NOT be running qtype 1 or 2." << endl;
00647   }
00648 
00649   for(int istp = 0; istp< nstrips; istp++){
00650     if(event->stp[istp]<0) continue;
00651     const NtpSRStrip* strip = dynamic_cast<const NtpSRStrip*>(record->stp->At(event->stp[istp]));
00652     if (!strip) continue; //protecting against null strip pointer
00653 //     const NtpTHStrip* stptruth= dynamic_cast<const NtpTHStrip*>(record->thstp->At(event->stp[istp]));
00654 //     assert(stptruth);
00655 //     if(stptruth!=NULL && ispurextalk(stptruth->sigflg)) continue;
00656 
00657     float qpeE = strip->ph0.pe;
00658     float qpeW = strip->ph1.pe;
00659 
00660     //for qtype = 3, 4, or 6, should check if strip has energy info
00661     //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
00662     //for qtype = 1,2,5, should check if strip somehow doesn't have sigcor info
00663     bool checkgev = 1;
00664     if (qtype == 3 || qtype == 4 || qtype == 6) {
00665       if (ph0[strip->index] + ph1[strip->index] == 0) checkgev = 0; //MHO(041010): Wondering if the conditional should be <= 0 instead of == 0 (a very small number of strips end up with negative energies)
00666     }
00667     if (qtype == 1 || qtype == 2 || qtype == 5) {
00668       if (strip->ph0.sigcor + strip->ph1.sigcor == 0) checkgev = 0;
00669     }
00670         
00671     if(qpeE+qpeW>_peThreshold && qpeE+qpeW < 1000 && strip->plane<=lastPlaneToUse && checkgev){
00672 
00673       float qchargeCor = 0;
00674       float qchargeE = qpeE;
00675       float qchargeW = qpeW;
00676 
00677       if (qtype == 0) {
00678         atcor->CalcCorr(record,strip,meanUTPos,meanVTPos,0);
00679         qchargeCor = atcor->qpecor;
00680       }
00681 
00682       if (qtype == 1 || qtype == 2 ) {
00683         FloatErr xstrip = (atcor->lE - atcor->lW) / 2;
00684         qchargeE = strip->ph0.sigcor;
00685         qchargeW = strip->ph1.sigcor;
00686         if (detector==Detector::kNear) { //Sigcors and sigmaps are different in ND
00687           qchargeE *= FN_SIGMAP_RATIO;
00688           qchargeW *= FN_SIGMAP_RATIO;
00689         }
00690         PlexStripEndId end[2];
00691         end[0] = strip->GetStripEndId((Detector::Detector_t)detector); end[0].SetEnd(StripEnd::kNegative);
00692         end[1] = strip->GetStripEndId((Detector::Detector_t)detector); end[1].SetEnd(StripEnd::kPositive);
00693         FloatErr qchargeECor = cal.GetAttenCorrected(FloatErr(qchargeE),xstrip,end[0]);
00694         FloatErr qchargeWCor = cal.GetAttenCorrected(FloatErr(qchargeW),xstrip,end[1]);
00695         qchargeCor = qchargeECor.GetValue() + qchargeWCor.GetValue();
00696       }
00697 
00698       if (qtype == 3 || qtype == 4 || qtype == 6) {
00699         qchargeE = ph0[strip->index];
00700         qchargeW = ph1[strip->index];
00701         qchargeCor = qchargeE + qchargeW;
00702       }
00703 
00704       if (qtype == 5) {
00705         qchargeE = strip->ph0.sigcor;
00706         qchargeW = strip->ph1.sigcor;
00707 
00708         atcor->CalcCorr(record,strip,meanUTPos,meanVTPos,5);
00709         qchargeCor = atcor->qpecor;
00710 
00711         if (detector==Detector::kNear) {
00712           qchargeE *= ND_PE_TO_SIGCOR_RATIO;
00713           qchargeW *= ND_PE_TO_SIGCOR_RATIO;
00714           qchargeCor *= ND_PE_TO_SIGCOR_RATIO;
00715         }
00716         
00717         if (detector==Detector::kFar) {
00718           qchargeE *= FD_PE_TO_SIGCOR_RATIO;
00719           qchargeW *= FD_PE_TO_SIGCOR_RATIO;
00720           qchargeCor *= FD_PE_TO_SIGCOR_RATIO;
00721         }
00722 
00723         if (detector==Detector::kCalDet) {
00724           qchargeE *= CD_PE_TO_SIGCOR_RATIO;
00725           qchargeW *= CD_PE_TO_SIGCOR_RATIO;
00726           qchargeCor *= CD_PE_TO_SIGCOR_RATIO;
00727         }
00728 
00729       }
00730 
00731       sumQcor+= qchargeCor;
00732       sumQraw+= qchargeE+qchargeW;
00733 
00734       compactStrip_h compactStrip;
00735       compactStrip.plane = static_cast<short>(strip->plane-meanPlane+100);
00736       if(strip->planeview==2)compactStrip.strip = ndstripno(strip->plane, strip->strip,strip->planeview, detector)-imeanU+100;
00737       if(strip->planeview==3)compactStrip.strip = ndstripno(strip->plane, strip->strip,strip->planeview, detector)-imeanV+100;
00738 
00739       if (qtype == 0 || qtype == 5) {
00740         compactStrip.icharge = static_cast<int>(qchargeCor * chargeScale);
00741       }
00742       if (qtype == 1 || qtype == 2 || qtype == 3 || qtype == 4 || qtype == 6) {
00743         compactStrip.icharge = static_cast<int>( (qchargeCor - ChargeToPe/2) * chargeScale / ChargeToPe);
00744       }
00745 
00746       if(compactStrip.strip>=5&&compactStrip.strip<=195&&compactStrip.plane>=5&&compactStrip.plane<=195){
00747         if(strip->planeview==2)UStrips.push_back(compactStrip);
00748         if(strip->planeview==3)VStrips.push_back(compactStrip);
00749       }
00750            
00751 
00752     }//threshold    
00753 
00754   }//strips loop
00755 
00756   delete [] ph0;
00757   delete [] ph1;
00758 
00759   delete record;
00760 
00761   Qtot = static_cast<int>(sumQcor);
00762   Qtotraw = static_cast<int>(sumQraw);
00763 
00764   FillAllStrips();
00765 
00766   return;  
00767 
00768 }

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

Definition at line 793 of file MinosCompactEvent.cxx.

References _peThreshold, chargeScale, ChargeType, eNu, FillAllStrips(), 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.

00793                                                                                               {
00794 
00795   // PE Scale factor for integer conversion: icharge = qpe * chargeScale
00796   chargeScale = event->chargeScale;
00797 
00798   // PE Threshold
00799   SetPEThreshold(event->_peThreshold);
00800 
00801   // set the global quantities
00802   Run   = event->Run;
00803   Snarl = event->Snarl;
00804  
00805   // set any MC quantities
00806   eNu = event->eNu;
00807   y   = event->y;
00808   idact = event->idact; 
00809   idres = event->idres;
00810   idnu  = event->idnu;
00811   
00812   
00813   // reco quantities
00814   Qtot = event->Qtot;
00815   nPlanes = event->nPlanes;
00816   meanU = event->meanU;
00817   meanV = event->meanV;
00818   meanPlane = event->meanPlane;
00819 
00820   nxtalk = event->nxtalk;
00821   nxtalk_tagged = event->nxtalk_tagged;
00822   nxtalk_mistagged = event->nxtalk_mistagged;
00823   nphysics = event->nphysics;
00824   nremoved = event->nremoved;
00825 
00826   ChargeType = event->ChargeType;
00827 
00828   //MHO0609 - Discovered this wasn't getting copied
00829   Qtotraw = event->Qtotraw;
00830 
00831   // loop over the U strips
00832 
00833   int imeanU = static_cast<int>(meanU);
00834   float fracU = meanU - static_cast<float>(imeanU);
00835 
00836   const int nustrips = event->UStrips.size();
00837   for(int istp = 0; istp< nustrips; istp++){
00838     int plane = event->UStrips[istp].plane;
00839     int strip = event->UStrips[istp].strip;
00840     int icharge  = event->UStrips[istp].icharge;
00841     float cstrip = (static_cast<float>(strip) -100.0+stripCompressionFactor/2.0)/stripCompressionFactor + 100.0;
00842     if((stripCompressionFactor%2)==0 && fracU>0.5){
00843       cstrip = (static_cast<float>(strip) -101.0+stripCompressionFactor/2.0)/stripCompressionFactor + 100.0;
00844     }
00845 
00846 
00847     int compStrip = static_cast<int>(cstrip);
00848 
00849 
00850     bool notFound = true;
00851     for(UInt_t i=0;i<UStrips.size() && notFound;++i){
00852       if(UStrips[i].strip==compStrip && UStrips[i].plane==plane){
00853         notFound = false;
00854         UStrips[i].icharge += icharge;
00855       }
00856     }
00857     if(notFound){
00858       compactStrip_h newStrip;
00859       newStrip.strip = compStrip;
00860       newStrip.plane = plane;
00861       newStrip.icharge  = icharge;
00862       UStrips.push_back(newStrip);
00863     }
00864   }
00865 
00866 
00867   // loop over the V strips
00868 
00869 
00870   int imeanV = static_cast<int>(meanV);
00871   float fracV = meanV - static_cast<float>(imeanV);
00872   const int nvstrips = event->VStrips.size();
00873   for(int istp = 0; istp< nvstrips; istp++){
00874     int plane = event->VStrips[istp].plane;
00875     int strip = event->VStrips[istp].strip;
00876     int icharge  = event->VStrips[istp].icharge;
00877     float cstrip = (static_cast<float>(strip)-100.0+stripCompressionFactor/2.0)/stripCompressionFactor + 100.0;
00878     if((stripCompressionFactor%2)==0 && fracV>0.5){
00879       cstrip = (static_cast<float>(strip) -101.0+stripCompressionFactor/2.0)/stripCompressionFactor + 100.0;
00880     }
00881 
00882     int compStrip = static_cast<int>(cstrip);
00883 
00884     bool notFound = true;
00885     for(UInt_t i=0;i<VStrips.size() && notFound;++i){
00886       if(VStrips[i].strip==compStrip && VStrips[i].plane==plane){
00887         notFound = false;
00888         VStrips[i].icharge += icharge;
00889       }
00890     }
00891     if(notFound){
00892       compactStrip_h newStrip;
00893       newStrip.strip = compStrip;
00894       newStrip.plane = plane;
00895       newStrip.icharge  = icharge;
00896       VStrips.push_back(newStrip);
00897     }
00898   }
00899 
00900   FillAllStrips();
00901 
00902   return;
00903 
00904 }

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

Definition at line 909 of file MinosCompactEvent.cxx.

References _peThreshold, chargeScale, ChargeType, eNu, FillAllStrips(), 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.

00909                                                                                     {
00910 
00911   // PE Scale factor for integer conversion: icharge = qpe * chargeScale
00912   chargeScale = event->chargeScale;
00913 
00914   // PE Threshold
00915   SetPEThreshold(event->_peThreshold);
00916 
00917   // set the global quantities
00918   Run   = event->Run;
00919   Snarl = event->Snarl;
00920  
00921   // set any MC quantities
00922   eNu = event->eNu;
00923   y   = event->y;
00924   idact = event->idact; 
00925   idres = event->idres;
00926   idnu  = event->idnu;
00927   
00928   
00929   // reco quantities
00930   Qtot = event->Qtot;
00931   nPlanes = event->nPlanes;
00932   meanU = event->meanU;
00933   meanV = event->meanV;
00934   meanPlane = event->meanPlane;
00935 
00936   nxtalk = event->nxtalk;
00937   nxtalk_tagged = event->nxtalk_tagged;
00938   nxtalk_mistagged = event->nxtalk_mistagged;
00939   nphysics = event->nphysics;
00940   nremoved = event->nremoved;
00941 
00942   ChargeType = event->ChargeType;
00943 
00944   //MHO0609 - Discovered this wasn't getting copied
00945   Qtotraw = event->Qtotraw;
00946 
00947   // loop over the U strips
00948 
00949   const int nustrips = event->UStrips.size();
00950   for(int istp = 0; istp< nustrips; istp++){
00951     int plane = event->UStrips[istp].plane;
00952     int strip = event->UStrips[istp].strip;
00953     int icharge  = event->UStrips[istp].icharge;
00954     int compStrip = pattern[strip];
00955     bool notFound = true;
00956 
00957     if (compStrip!=-1){
00958 
00959       for(UInt_t i=0;i<UStrips.size() && notFound;++i){
00960         if(UStrips[i].strip==compStrip && UStrips[i].plane==plane){
00961           notFound = false;
00962           UStrips[i].icharge += icharge;
00963         }
00964       }
00965       if(notFound){
00966         compactStrip_h newStrip;
00967         newStrip.strip = compStrip;
00968         newStrip.plane = plane;
00969         newStrip.icharge  = icharge;
00970         UStrips.push_back(newStrip);
00971       }
00972     }
00973   }
00974 
00975   // loop over the V strips
00976 
00977 
00978   const int nvstrips = event->VStrips.size();
00979   for(int istp = 0; istp< nvstrips; istp++){
00980     int plane = event->VStrips[istp].plane;
00981     int strip = event->VStrips[istp].strip;
00982     int icharge  = event->VStrips[istp].icharge;
00983     int compStrip = pattern[strip];
00984 
00985     bool notFound = true;
00986 
00987     if (compStrip!=-1){
00988 
00989       for(UInt_t i=0;i<VStrips.size() && notFound;++i){
00990         if(VStrips[i].strip==compStrip && VStrips[i].plane==plane){
00991           notFound = false;
00992           VStrips[i].icharge += icharge;
00993         }
00994       }
00995       if(notFound){
00996         compactStrip_h newStrip;
00997         newStrip.strip = compStrip;
00998         newStrip.plane = plane;
00999         newStrip.icharge  = icharge;
01000         VStrips.push_back(newStrip);
01001       }
01002     }
01003   }
01004 
01005   FillAllStrips();
01006 
01007   return;
01008 
01009 }

MinosCompactEvent::MinosCompactEvent ( const MinosCompactEvent event  ) 

Definition at line 1011 of file MinosCompactEvent.cxx.

References _peThreshold, chargeScale, ChargeType, eNu, FillAllStrips(), 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.

01011                                                                   {
01012 
01013   // PE Scale factor for integer conversion: icharge = qpe * chargeScale
01014   chargeScale = event->chargeScale;
01015 
01016   //_peThreshold
01017   SetPEThreshold(event->_peThreshold);
01018 
01019   // set the global quantities
01020   Run   = event->Run;
01021   Snarl = event->Snarl;
01022  
01023   // set any MC quantities
01024   eNu = event->eNu;
01025   y   = event->y;
01026   idact = event->idact; 
01027   idres = event->idres;
01028   idnu  = event->idnu;
01029     
01030   // reco quantities
01031   Qtot = event->Qtot;
01032   nPlanes = event->nPlanes;
01033   meanU = event->meanU;
01034   meanV = event->meanV;
01035   meanPlane = event->meanPlane;
01036 
01037   nxtalk = event->nxtalk;
01038   nxtalk_tagged = event->nxtalk_tagged;
01039   nxtalk_mistagged = event->nxtalk_mistagged;
01040   nphysics = event->nphysics;
01041   nremoved = event->nremoved;
01042 
01043   ChargeType = event->ChargeType;
01044 
01045   //MHO0609 - Discovered this wasn't getting copied
01046   Qtotraw = event->Qtotraw;
01047 
01048   // loop over the U strips
01049   const int nustrips = event->UStrips.size();
01050   for(int istp = 0; istp< nustrips; istp++){
01051     compactStrip_h newStrip;
01052     newStrip.strip = event->UStrips[istp].strip;
01053     newStrip.plane = event->UStrips[istp].plane;
01054     newStrip.icharge  = event->UStrips[istp].icharge;
01055     UStrips.push_back(newStrip);
01056   }
01057 
01058   // loop over the V strips
01059   const int nvstrips = event->VStrips.size();
01060   for(int istp = 0; istp< nvstrips; istp++){
01061     compactStrip_h newStrip;
01062     newStrip.strip = event->VStrips[istp].strip;
01063     newStrip.plane = event->VStrips[istp].plane;
01064     newStrip.icharge  = event->VStrips[istp].icharge;
01065     VStrips.push_back(newStrip);
01066   }
01067 
01068   FillAllStrips();
01069 
01070   return;
01071 
01072 }

MinosCompactEvent::~MinosCompactEvent (  )  [virtual]

Definition at line 786 of file MinosCompactEvent.cxx.

References UStrips, and VStrips.

00786                                      {
00787 
00788   UStrips.clear();
00789   VStrips.clear();
00790 }


Member Function Documentation

void MinosCompactEvent::FillAllStrips (  ) 

Definition at line 1126 of file MinosCompactEvent.cxx.

References AllStrips, UStrips, and VStrips.

Referenced by MinosCompactEvent(), and MCNNRunner::NextLibraryEvent().

01127 {
01128   AllStrips = UStrips;
01129   AllStrips.insert(AllStrips.end(), VStrips.begin(), VStrips.end());
01130   std::sort(AllStrips.begin(), AllStrips.end());
01131 }

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

Definition at line 1075 of file MinosCompactEvent.cxx.

References _peThreshold, NtpStRecord::evt, NtpSRPulseHeight::pe, NtpSRStrip::ph0, NtpSRStrip::ph1, NtpSRStrip::plane, and NtpStRecord::stp.

Referenced by MinosCompactEvent().

01075                                                                                                                   {
01076 
01077   // efficiency not critical here, so keep it simple...
01078 
01079   const int maxplanes = 500;
01080   int planecount[maxplanes];
01081 
01082   int firstplane = 999;
01083   int lastplane  = 0;
01084   for (Int_t i=0;i<maxplanes;i++) planecount[i] = 0;
01085 
01086   const NtpSREvent* event = dynamic_cast<const NtpSREvent*>(record->evt->At(eventno));
01087   const int nstrips = event->nstrip;
01088 
01089   // fill array of plane counts
01090   for(int istp = 0; istp< nstrips; istp++){
01091     if (event->stp[istp]<0) continue;
01092     const NtpSRStrip* strip = dynamic_cast<const NtpSRStrip*>(record->stp->At(event->stp[istp]));
01093     if (!strip) continue; //protecting against null strip pointer
01094     float qpe=strip->ph0.pe+strip->ph1.pe;
01095     if (qpe>_peThreshold && qpe<1000) {
01096       planecount[strip->plane]++;
01097       if (strip->plane>lastplane) lastplane = strip->plane;
01098       if (strip->plane<firstplane) firstplane = strip->plane;      
01099     }
01100   }
01101 
01102   // find plane upstream of cut-able strips
01103   Int_t downstream_strip_count = 0;
01104   Int_t searchstart;
01105   for (searchstart=lastplane; searchstart>=firstplane;searchstart--) {
01106     downstream_strip_count += planecount[searchstart];
01107     if (downstream_strip_count>max_strips_cut) break;
01108   }
01109 
01110   // loop over candidate planes, looking for first big gap
01111   Int_t gap_count = 0;
01112   Int_t cut_beyond_here = 9999;
01113   for (Int_t iP=searchstart+1; iP<=lastplane;iP++) {
01114     if (planecount[iP]==0) gap_count++;
01115     else gap_count = 0;
01116     if (gap_count>max_gap) {
01117       cut_beyond_here = iP;
01118       break;
01119     }
01120   }
01121 
01122   return cut_beyond_here;
01123 }

void MinosCompactEvent::Merge ( MinosCompactEvent pcce2  ) 

Definition at line 108 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.

00108                                                      {
00109 
00110   //If variables are not identical then set default. 
00111   if(Run!=pcce2->Run) Run=-1;
00112   if(Snarl!=pcce2->Snarl) Snarl=-1;
00113   if(chargeScale!=pcce2->chargeScale) chargeScale=-1;
00114   if(_peThreshold!=pcce2->_peThreshold) _peThreshold=-1;
00115   if(meanU!=pcce2->meanU) meanU=-1;
00116   if(meanV!=pcce2->meanV) meanV=-1;
00117   if(meanPlane!=pcce2->meanPlane) meanPlane=-1;
00118   if(Qtot!=pcce2->Qtot) Qtot=-1;
00119   if(nPlanes!=pcce2->nPlanes) nPlanes=-1;
00120   if(eNu!=pcce2->eNu) eNu=-1;
00121   if(y!=pcce2->y) y=-1;
00122   if(idact!=pcce2->idact) idact=-1;
00123   if(idres!=pcce2->idres) idres=-1;
00124   if(idnu!=pcce2->idnu) idnu=-1;
00125   if(nxtalk!=pcce2->nxtalk) nxtalk=-1;
00126   if(nxtalk_tagged!=pcce2->nxtalk_tagged) nxtalk_tagged=-1;
00127   if(nxtalk_mistagged!=pcce2->nxtalk_mistagged) nxtalk_mistagged=-1;
00128   if(nphysics!=pcce2->nphysics) nphysics=-1;
00129   if(nremoved!=pcce2->nremoved) nremoved=-1;
00130 
00131   //Loop over U strips
00132   const int nustrips = UStrips.size();
00133   const int nustrips2 = pcce2->UStrips.size();
00134 
00135   for(int istp2 = 0; istp2< nustrips2; istp2++){
00136     Bool_t added=false; 
00137     for(int istp = 0; istp < nustrips; istp++){
00138       if(UStrips[istp].plane == pcce2->UStrips[istp2].plane 
00139          && UStrips[istp].strip == pcce2->UStrips[istp2].strip
00140          && added==false
00141          ){
00142         UStrips[istp].icharge += pcce2->UStrips[istp2].icharge;
00143         added=true;
00144       }
00145       
00146     }
00147     if(added==false){
00148       UStrips.push_back(pcce2->UStrips[istp2]);
00149     }
00150   }
00151 
00152   //Loop over V strips
00153   const int nvstrips = VStrips.size();
00154   const int nvstrips2 = pcce2->VStrips.size();
00155   
00156   for(int istp2 = 0; istp2< nvstrips2; istp2++){
00157     Bool_t added=false;
00158     for(int istp = 0; istp < nvstrips; istp++){
00159       if(VStrips[istp].plane == pcce2->VStrips[istp2].plane 
00160          && VStrips[istp].strip == pcce2->VStrips[istp2].strip
00161          && added==false
00162          ){
00163         VStrips[istp].icharge += pcce2->VStrips[istp2].icharge;
00164         added=true;
00165       }
00166       
00167     }
00168     if(added==false){
00169       VStrips.push_back(pcce2->VStrips[istp2]);
00170     }
00171   }
00172   
00173 }

void MinosCompactEvent::Print (  ) 

Definition at line 189 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.

00189                              {
00190 
00191   cout << "***Printing MinosCompactEvent" << endl;
00192   cout << "Run: " << Run << endl;
00193   cout << "Snarl: " << Snarl << endl;
00194   cout << "chargeScale: " << chargeScale << endl;
00195   cout << "meanU and meanV: " << meanU << " , " << meanV << endl;
00196   cout << "meanPlane: " << meanPlane << endl;
00197   cout << "Qtot: " << Qtot << endl;
00198 
00199   //MHO0509
00200   cout << "Qtotraw: " << Qtotraw << endl;
00201 
00202   cout << "nPlanes: " << nPlanes << endl;
00203   cout << "eNu: " << eNu << endl;
00204   cout << "y: " << y << endl;
00205   cout << "idnu and idact: " << idnu << " , " << idact << endl;
00206   cout << "idres: " << idres << endl;
00207   cout << "nxtalk: " << nxtalk << endl;
00208   cout << "nxtalk_tagged: " << nxtalk_tagged << endl;
00209   cout << "nxtalk_mistagged: " << nxtalk_mistagged << endl;
00210   cout << "nphysics: " << nphysics << endl;
00211   cout << "nremoved: " << nremoved << endl;
00212   
00213   //MHO0509
00214   cout << "ChargeType: " << ChargeType << endl;
00215 
00216   const int nustrips = UStrips.size();
00217   cout << "--> U strips (pln,stp,q):"  << nustrips << endl;
00218   for(int istp = 0; istp< nustrips; istp++){
00219     cout << UStrips[istp].plane << "," << UStrips[istp].strip << "," << UStrips[istp].icharge << endl;
00220   }
00221   const int nvstrips = VStrips.size();
00222   cout << "--> V strips (pln,stp,q):"  << nvstrips << endl;
00223   for(int istp = 0; istp< nvstrips; istp++){
00224     cout << VStrips[istp].plane << "," << VStrips[istp].strip << "," << VStrips[istp].icharge << endl;
00225   }
00226 
00227 }

void MinosCompactEvent::ScaleCharges ( float  factor  ) 

Definition at line 175 of file MinosCompactEvent.cxx.

References UStrips, and VStrips.

00175                                                 {
00176   
00177   const int nustrips = UStrips.size();
00178   for(int istp = 0; istp< nustrips; istp++){
00179     UStrips[istp].icharge=(int)(UStrips[istp].icharge*factor);
00180   }
00181 
00182   const int nvstrips = VStrips.size();
00183   for(int istp = 0; istp< nvstrips; istp++){
00184     VStrips[istp].icharge=(int)(VStrips[istp].icharge*factor);
00185   }
00186 
00187 }

void MinosCompactEvent::SetPEThreshold ( float  qpe  ) 

Definition at line 96 of file MinosCompactEvent.cxx.

References _peThreshold.

Referenced by MinosCompactEvent().

00097 {
00098 
00099   _peThreshold = q;
00100 
00101 
00102 }

int MinosCompactEvent::SizeOf (  ) 

Definition at line 771 of file MinosCompactEvent.cxx.

References total(), UStrips, and VStrips.

00771                              {
00772 
00773   // Calculate the size of the object including what's in the vectors
00774 
00775   int total = 0 ;
00776   
00777   total += sizeof(*this);
00778   int nU = UStrips.capacity();
00779   int nV = VStrips.capacity();
00780   total += sizeof(UStrips[0])*(nU+nV);
00781 
00782   return total;
00783 }


Member Data Documentation

Definition at line 68 of file MinosCompactEvent.h.

Referenced by GetLastPlaneToUse(), Merge(), MinosCompactEvent(), and SetPEThreshold().

Definition at line 99 of file MinosCompactEvent.h.

Referenced by MCNNRunner::CompareEventsBody(), MinosCompactEvent(), and Print().

Definition at line 93 of file MinosCompactEvent.h.

Referenced by Merge(), MinosCompactEvent(), and Print().

Definition at line 94 of file MinosCompactEvent.h.

Referenced by Merge(), MinosCompactEvent(), and Print().

Definition at line 90 of file MinosCompactEvent.h.

Referenced by Merge(), MinosCompactEvent(), and Print().

Definition at line 92 of file MinosCompactEvent.h.

Referenced by Merge(), MinosCompactEvent(), and Print().

Definition at line 91 of file MinosCompactEvent.h.

Referenced by Merge(), MinosCompactEvent(), and Print().

Definition at line 79 of file MinosCompactEvent.h.

Referenced by MinosCompactEvent(), and Print().

Definition at line 70 of file MinosCompactEvent.h.

Referenced by Merge(), MinosCompactEvent(), and Print().


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

Generated on 2 Nov 2017 for loon by  doxygen 1.6.1