Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

AtNuAnaUtil Namespace Reference


Functions

AtmosTrack * GetPrimaryTrack (AtmosEvent *event)
AtmosShower * GetPrimaryShower (AtmosEvent *event)
void PrimaryTrackShower (AtmosEvent *event, AtmosTrack *&ptrack, AtmosShower *&pshower)
AtmosTrack * GetPrimaryTrack (vector< AtmosTrack > Tracks, vector< AtmosShower > Showers)
AtmosShower * GetPrimaryShower (vector< AtmosTrack > Tracks, vector< AtmosShower > Showers)
void PrimaryTrackShower (vector< AtmosTrack > Tracks, vector< AtmosShower > Showers, AtmosTrack *&ptrack, AtmosShower *&pshower)
std::set< int > AllShowerStripIds (const AtmosEvent *event)
std::set< int > PrimaryShowerStripIds (const AtmosEvent *event)
std::set< int > PrimaryTrackStripIds (const AtmosEvent *event)
std::set< SetStrip > AllShowerStripSets (const AtmosEvent *event)
std::set< SetStrip > PrimaryShowerStripSets (const AtmosEvent *event)
std::set< SetStrip > PrimaryTrackStripSets (const AtmosEvent *event)

Function Documentation

std::set< int > AtNuAnaUtil::AllShowerStripIds (  const AtmosEvent *  event  ) 
 

Definition at line 193 of file AtNuAnaUtil.cxx.

References AtmosEvent::NShowers, AtmosStrip::Shw, and AtmosEvent::StripList.

00194   {
00195     assert(event);
00196 
00197     std::set<int> shwstps;
00198 
00199     //Only check strips if >0 showers
00200     if(event->NShowers == 0) return(shwstps);
00201 
00202     for (int istp=0; istp<event->StripList->GetEntries(); istp++) {
00203       const AtmosStrip* strip = dynamic_cast<const AtmosStrip*>
00204         (event->StripList->At(istp));
00205       assert(strip);
00206 
00207       if(strip->Shw>0) shwstps.insert(istp);
00208     }
00209 
00210     return(shwstps);
00211   }

std::set< SetStrip > AtNuAnaUtil::AllShowerStripSets (  const AtmosEvent *  event  ) 
 

Definition at line 255 of file AtNuAnaUtil.cxx.

References AtmosEvent::NShowers, AtmosStrip::Shw, and AtmosEvent::StripList.

00256   {
00257     assert(event);
00258 
00259     std::set<SetStrip> shwstps;
00260 
00261     //Only check strips if >0 showers
00262     if(event->NShowers == 0) return(shwstps);
00263 
00264     for (int istp=0; istp<event->StripList->GetEntries(); istp++) {
00265       const AtmosStrip* strip = dynamic_cast<const AtmosStrip*>
00266         (event->StripList->At(istp));
00267       assert(strip);
00268 
00269       if(strip->Shw>0) shwstps.insert(SetStrip(istp, strip));
00270     }
00271 
00272     return(shwstps);
00273   }

AtmosShower * AtNuAnaUtil::GetPrimaryShower (  vector< AtmosTrack >  Tracks,
vector< AtmosShower >  Showers
) 
 

Definition at line 113 of file AtNuAnaUtil.cxx.

References PrimaryTrackShower().

00115   {
00116     // return primary track
00117     // ====================
00118     AtmosTrack* ptrack = 0;
00119     AtmosShower* pshower = 0;
00120 
00121     AtNuAnaUtil::PrimaryTrackShower(Tracks, Showers, ptrack, pshower);
00122 
00123     return pshower;
00124   }

AtmosShower * AtNuAnaUtil::GetPrimaryShower (  AtmosEvent *  event  ) 
 

Definition at line 21 of file AtNuAnaUtil.cxx.

References PrimaryTrackShower().

Referenced by TrackRecoPerf::FillEvent(), ShowerVertexPerf::FillEvent(), ShowerRecoPerf::FillEvent(), ShowerEnergyPerf::FillEvent(), and ShowerDirectionPerf::FillEvent().

00022   {
00023     // return primary track
00024     // ====================
00025     AtmosTrack* ptrack = 0;
00026     AtmosShower* pshower = 0;
00027 
00028     AtNuAnaUtil::PrimaryTrackShower(event,ptrack,pshower);
00029 
00030     return pshower;
00031   }

AtmosTrack * AtNuAnaUtil::GetPrimaryTrack (  vector< AtmosTrack >  Tracks,
vector< AtmosShower >  Showers
) 
 

Definition at line 100 of file AtNuAnaUtil.cxx.

References PrimaryTrackShower().

00102   {
00103     // return primary track
00104     // ====================
00105     AtmosTrack* ptrack = 0;
00106     AtmosShower* pshower = 0;
00107 
00108     AtNuAnaUtil::PrimaryTrackShower(Tracks, Showers, ptrack, pshower);
00109 
00110     return ptrack;
00111   }

AtmosTrack * AtNuAnaUtil::GetPrimaryTrack (  AtmosEvent *  event  ) 
 

Definition at line 9 of file AtNuAnaUtil.cxx.

References PrimaryTrackShower().

00010   {
00011     // return primary track
00012     // ====================
00013     AtmosTrack* ptrack = 0;
00014     AtmosShower* pshower = 0;
00015 
00016     AtNuAnaUtil::PrimaryTrackShower(event,ptrack,pshower);
00017 
00018     return ptrack;
00019   }

std::set< int > AtNuAnaUtil::PrimaryShowerStripIds (  const AtmosEvent *  event  ) 
 

Definition at line 213 of file AtNuAnaUtil.cxx.

References SntpHelpers::GetPrimaryShower(), AtmosShower::Index, and AtmosStrip::Shw.

00214   {
00215     assert(event);
00216 
00217     std::set<int> shwstps;
00218 
00219     //Only check strips if there is a primary shower
00220     AtmosShower *shower = GetPrimaryShower(const_cast<AtmosEvent*>(event));
00221     if( !shower ) return(shwstps);
00222 
00223     for (int istp=0; istp<event->StripList->GetEntries(); istp++) {
00224       const AtmosStrip* strip = dynamic_cast<const AtmosStrip*>
00225         (event->StripList->At(istp));
00226       assert(strip);
00227 
00228       if(strip->Shw == shower->Index) shwstps.insert(istp);
00229     }
00230 
00231     return(shwstps);
00232   }

std::set< SetStrip > AtNuAnaUtil::PrimaryShowerStripSets (  const AtmosEvent *  event  ) 
 

Definition at line 275 of file AtNuAnaUtil.cxx.

References SntpHelpers::GetPrimaryShower(), AtmosShower::Index, and AtmosStrip::Shw.

Referenced by TrackRecoPerf::FillEvent(), and ShowerRecoPerf::FillEvent().

00276   {
00277     assert(event);
00278 
00279     std::set<SetStrip> shwstps;
00280 
00281     //Only check strips if there is a primary shower
00282     AtmosShower *shower = GetPrimaryShower(const_cast<AtmosEvent*>(event));
00283     if( !shower ) return(shwstps);
00284 
00285     for (int istp=0; istp<event->StripList->GetEntries(); istp++) {
00286       const AtmosStrip* strip = dynamic_cast<const AtmosStrip*>
00287         (event->StripList->At(istp));
00288       assert(strip);
00289 
00290       if(strip->Shw == shower->Index) shwstps.insert(SetStrip(istp, strip));
00291     }
00292 
00293     return(shwstps);
00294   }

void AtNuAnaUtil::PrimaryTrackShower (  vector< AtmosTrack >  Tracks,
vector< AtmosShower >  Showers,
AtmosTrack *&  ptrack,
AtmosShower *&  pshower
) 
 

Definition at line 126 of file AtNuAnaUtil.cxx.

References AtmosShower::Nplanes, AtmosTrack::Nplanes, AtmosTrack::NplanesTrackOnly, and AtmosTrack::TrkLikePlanes.

00129   {
00130     // reset track/shower pointers  
00131     // ===========================
00132     ptrack = 0; pshower = 0;
00133 
00134     // select longest track
00135     // ====================
00136     AtmosTrack* mytrack = 0;
00137     for (unsigned int itrk=0; itrk<Tracks.size(); itrk++){
00138       AtmosTrack* track = &(Tracks[itrk]);
00139       if (track) { 
00140         if(mytrack==0) mytrack = track;
00141         else if(track->Nplanes>mytrack->Nplanes) mytrack = track;
00142       }
00143     }
00144 
00145     // select longest shower
00146     // =====================
00147     AtmosShower* myshower = 0;
00148     for (unsigned int ishw=0; ishw<Showers.size(); ishw++){
00149       AtmosShower* shower = &(Showers[ishw]);
00150       if (shower) {
00151         if(myshower==0) myshower = shower;
00152         else if(shower->Nplanes>myshower->Nplanes) myshower = shower;
00153       }
00154     }
00155 
00156     // for both track AND shower
00157     // =========================
00158     if( mytrack && myshower ){
00159       Int_t trkplanes = 0;
00160       if( mytrack->Nplanes>=8
00161        && mytrack->Nplanes-myshower->Nplanes>=-5
00162        && mytrack->TrkLikePlanes>=5 ) trkplanes = mytrack->Nplanes;
00163       Int_t rawtrkplanes = mytrack->Nplanes;
00164    
00165       Int_t shwplanes = 0;
00166       if( myshower->Nplanes>=5
00167        && myshower->Nplanes-mytrack->Nplanes>=-5
00168        && mytrack->NplanesTrackOnly<=10
00169        && mytrack->TrkLikePlanes<=15
00170        && mytrack->Nplanes<=25 ) shwplanes = myshower->Nplanes;
00171       Int_t rawshwplanes = myshower->Nplanes;
00172 
00173       if( trkplanes+shwplanes>0 ){
00174         if( trkplanes>shwplanes ) ptrack = mytrack;
00175         else pshower = myshower;
00176       }
00177       else if( rawtrkplanes+rawshwplanes>0 ){
00178         if( rawtrkplanes>rawshwplanes ) ptrack = mytrack;
00179         else pshower = myshower;
00180       }
00181     }
00182 
00183     // just track OR just shower
00184     // =========================
00185     else{
00186       ptrack = mytrack;
00187       pshower = myshower;
00188     }
00189     
00190     return;
00191   }

void AtNuAnaUtil::PrimaryTrackShower (  AtmosEvent *  event,
AtmosTrack *&  track,
AtmosShower *&  shower
) 
 

Definition at line 33 of file AtNuAnaUtil.cxx.

References AtmosShower::Nplanes, AtmosTrack::Nplanes, AtmosTrack::NplanesTrackOnly, AtmosEvent::NShowers, AtmosEvent::NTracks, AtmosEvent::ShowerList, AtmosEvent::TrackList, and AtmosTrack::TrkLikePlanes.

Referenced by GetPrimaryShower(), and GetPrimaryTrack().

00035   {
00036     // reset track/shower pointers  
00037     // ===========================
00038     ptrack = 0; pshower = 0;
00039 
00040     // select longest track
00041     // ====================
00042     AtmosTrack* mytrack = 0;
00043     for( Int_t i=0; i<event->NTracks; i++){
00044       AtmosTrack* track = (AtmosTrack*)(event->TrackList->At(i));
00045       if( track ){
00046         if( mytrack==0 ) mytrack = track;
00047         else if( track->Nplanes>mytrack->Nplanes ) mytrack = track;
00048       }
00049     }
00050 
00051     // select longest shower
00052     // =====================
00053     AtmosShower* myshower = 0;
00054     for( Int_t i=0; i<event->NShowers; i++){
00055       AtmosShower* shower = (AtmosShower*)(event->ShowerList->At(i));
00056       if( shower ){
00057         if( myshower==0 ) myshower = shower;
00058         else if( shower->Nplanes>myshower->Nplanes ) myshower = shower;
00059       }
00060     }
00061 
00062     // for both track AND shower
00063     // =========================
00064     if( mytrack && myshower ){
00065       Int_t trkplanes = 0;
00066       if( mytrack->Nplanes>=8
00067        && mytrack->Nplanes-myshower->Nplanes>=-5
00068        && mytrack->TrkLikePlanes>=5 ) trkplanes = mytrack->Nplanes;
00069       Int_t rawtrkplanes = mytrack->Nplanes;
00070    
00071       Int_t shwplanes = 0;
00072       if( myshower->Nplanes>=5
00073        && myshower->Nplanes-mytrack->Nplanes>=-5
00074        && mytrack->NplanesTrackOnly<=10
00075        && mytrack->TrkLikePlanes<=15
00076        && mytrack->Nplanes<=25 ) shwplanes = myshower->Nplanes;
00077       Int_t rawshwplanes = myshower->Nplanes;
00078 
00079       if( trkplanes+shwplanes>0 ){
00080         if( trkplanes>shwplanes ) ptrack = mytrack;
00081         else pshower = myshower;
00082       }
00083       else if( rawtrkplanes+rawshwplanes>0 ){
00084         if( rawtrkplanes>rawshwplanes ) ptrack = mytrack;
00085         else pshower = myshower;
00086       }
00087     }
00088 
00089     // just track OR just shower
00090     // =========================
00091     else{
00092       ptrack = mytrack;
00093       pshower = myshower;
00094     }
00095     
00096     return;
00097   }

std::set< int > AtNuAnaUtil::PrimaryTrackStripIds (  const AtmosEvent *  event  ) 
 

Definition at line 234 of file AtNuAnaUtil.cxx.

References SntpHelpers::GetPrimaryTrack(), AtmosTrack::Index, and AtmosStrip::Trk.

00235   {
00236     assert(event);
00237 
00238     std::set<int> trkstps;
00239 
00240     //Only check strips if there is a primary track
00241     AtmosTrack *track = GetPrimaryTrack(const_cast<AtmosEvent*>(event));
00242     if( !track ) return(trkstps);
00243 
00244     for (int istp=0; istp<event->StripList->GetEntries(); istp++) {
00245       const AtmosStrip* strip = dynamic_cast<const AtmosStrip*>
00246         (event->StripList->At(istp));
00247       assert(strip);
00248 
00249       if(strip->Trk == track->Index) trkstps.insert(istp);
00250     }
00251 
00252     return(trkstps);
00253   }

std::set< SetStrip > AtNuAnaUtil::PrimaryTrackStripSets (  const AtmosEvent *  event  ) 
 

Definition at line 296 of file AtNuAnaUtil.cxx.

References SntpHelpers::GetPrimaryTrack(), AtmosTrack::Index, and AtmosStrip::Trk.

00297   {
00298     assert(event);
00299 
00300     std::set<SetStrip> trkstps;
00301 
00302     //Only check strips if there is a primary track
00303     AtmosTrack *track = GetPrimaryTrack(const_cast<AtmosEvent*>(event));
00304     if( !track ) return(trkstps);
00305 
00306     for (int istp=0; istp<event->StripList->GetEntries(); istp++) {
00307       const AtmosStrip* strip = dynamic_cast<const AtmosStrip*>
00308         (event->StripList->At(istp));
00309       assert(strip);
00310 
00311       if(strip->Trk == track->Index) trkstps.insert(SetStrip(istp, strip));
00312     }
00313 
00314     return(trkstps);
00315   }

Generated on Sat Nov 21 22:52:48 2009 for loon by  doxygen 1.3.9.1