loon: MadBase Class Reference

00016 {
00017 
00018   fCurRun = -1;
00019   lastEntry = -1;
00020   if(!chainSR) {
00021     record = 0;
00022     emrecord = 0;
00023     mcrecord = 0;
00024     threcord = 0;
00025     strecord = 0;
00026     Clear();
00027     whichSource = -1;
00028     isMC = true;
00029     isTH = true;
00030     isEM = true;
00031     isST = false;
00032     Nentries = -1;
00033     fCurRun = -1;
00034     return;
00035   }
00036 
00037   InitChain(chainSR,chainMC,chainTH,chainEM);
00038   whichSource = 0;
00039 
00040 }

00043 {
00044   record = 0;
00045   emrecord = 0;
00046   mcrecord = 0;
00047   threcord = 0;
00048   strecord = 0;
00049   Clear();
00050   isMC = true;
00051   isTH = true;
00052   isEM = true;
00053   isST = false;
00054   Nentries = entries;
00055   whichSource = 1;
00056   jcPath = path;
00057   fCurRun = -1;
00058   lastEntry = -1;
00059   fJC = j;
00060   fChain = NULL;
00061 }

00064 {
00065   if(fChain) delete fChain;
00066 }

00201                    {
00202 
00203   ntpHeader = 0;
00204   shieldSummary = 0;
00205   eventSummary = 0;
00206   ntpSlice=0;
00207   ntpEvent=0;
00208   ntpTrack=0;
00209   ntpCluster=0;
00210   ntpShower=0;
00211   ntpStrip=0;
00212   ntpShieldStrip=0;
00213 
00214   ntpTruth=0;
00215   ntpStdHep=0;
00216 
00217   ntpTHSlice=0;
00218   ntpTHTrack=0;
00219   ntpTHShower=0;
00220 
00221   ntpEMSummary = 0;
00222   ntpEMShower = 0;
00223 
00224 }

00755                                               {
00756   if(!LoadCluster(i)) return 0;
00757   else return ntpCluster;
00758 }

00829                                               {
00830   if(!LoadEMShower(i)) return 0;
00831   else return ntpEMShower;
00832 }

00075 {
00076   //zero everything before next snarl
00077   Clear();
00078   
00079   //get records
00080   int status = 0;
00081   if(whichSource==-1) return 0;
00082   else if(whichSource==0) {
00083     if(entry!=lastEntry) {
00084       status = fChain->Get(entry);
00085       lastEntry = entry;
00086     }
00087     else status = 1;
00088     record = fChain->Record;
00089     strecord = fChain->stRecord;
00090     mcrecord = fChain->mcRecord;
00091     threcord = fChain->thRecord;
00092     emrecord = fChain->emRecord;
00093   }
00094   else if(whichSource==1) {
00095     //allow for possibility that reco path can change event by event:
00096     isMC = isTH = isEM = true; 
00097     //Get entry:
00098     //cout << "Getting Cand entry " << entry << " from " 
00099     // << jcPath.c_str() << endl;
00100     if(entry!=lastEntry) {
00101       if(entry<lastEntry) fJC->Input.Prev(lastEntry-entry-2);
00102       //else fJC->Input.Next(entry-lastEntry);
00103       fJC->Path(jcPath.c_str()).RunNin(1);
00104       lastEntry = entry;
00105     }
00106     //Look for records in mom:
00107     record   = (NtpSRRecord*) fJC->Mom.GetFragment("NtpSRRecord");
00108     mcrecord = (NtpMCRecord*) fJC->Mom.GetFragment("NtpMCRecord");
00109     threcord = (NtpTHRecord*) fJC->Mom.GetFragment("NtpTHRecord");
00110     emrecord = (NtpEMRecord*) fJC->Mom.GetFragment("NtpEMRecord");
00111     //if no SR record quit
00112     if(record==0) return 0;
00113     //otherwise check for other records:
00114     status = 1;
00115     if(mcrecord==0) isMC = false;
00116     if(threcord==0) isTH = false;
00117     if(emrecord==0) isEM = false;
00118   }
00119   else return 0;
00120   
00121   //set other things:
00122   if(isST){
00123     ntpHeader = &(strecord->GetHeader());
00124     mcHeader = &(strecord->mchdr);
00125     shieldSummary = &(strecord->vetohdr);
00126     eventSummary = &(strecord->evthdr);
00127     dmxStatus = &(strecord->dmxstatus);
00128     detStatus = &(strecord->detstatus);
00129     if(mcHeader->nmc==0) {
00130       isMC = false; isTH = false;
00131     }
00132     else {
00133       isMC = true;
00134       TClonesArray &array = *(strecord->thstp);
00135       if(array.GetEntries()>0) isTH = true;      
00136     }
00137   }
00138   else {
00139     ntpHeader = &(record->GetHeader());
00140     shieldSummary = &(record->vetohdr);
00141     eventSummary = &(record->evthdr);
00142     dmxStatus = &(record->dmxstatus);
00143     detStatus = &(record->detstatus);
00144   }
00145   fCurRun = ntpHeader->GetRun();
00146 
00147   LoadSlice(0);  
00148   LoadEvent(0);
00149   LoadTrack(0);
00150   LoadCluster(0);
00151   LoadShower(0);
00152   LoadShieldStrip(0);
00153 
00154   if(isEM) {
00155     ntpEMSummary = &(emrecord->emhdr);
00156     LoadEMShower(0);
00157   }
00158 
00159   if(isMC) {
00160     if(isST) mcHeader = &(strecord->mchdr);
00161     else mcHeader = &(mcrecord->mchdr);
00162     LoadTruth(0);
00163     LoadStdHep(0);
00164   }
00165 
00166   if(isTH) {
00167     LoadTHSlice(0);
00168     LoadTHEvent(0);
00169     LoadTHTrack(0);
00170     LoadTHShower(0);
00171   }
00172   return status;
00173 
00174 }

00069 {
00070   if(whichSource==0) return GetEntry(fChain->GetEntryNumber(run,snarl));
00071   return 0;
00072 }

00767                                           {
00768   if(!LoadEvent(i)) return 0;
00769   else return ntpEvent;
00770 }

00222 {return eventSummary;}

00223 {return ntpHeader;}

00759                                                                      {
00760   if(!LoadLargestShowerFromEvent(i,j)) return 0;
00761   else return ntpShower;
00762 }

00747                                                                    {
00748   if(!LoadLargestTrackFromEvent(i,j)) return 0;
00749   else return ntpTrack;
00750 }

00775                                                       {
00776   if(!LoadShieldStrip(i)) return 0;
00777   else return ntpShieldStrip;
00778   
00779 }

00751                                             {
00752   if(!LoadShower(i)) return 0;
00753   else return ntpShower;
00754 }

00763                                                                           {
00764   if(!LoadShowerAtTrackVertex(i,j,k)) return 0;
00765   else return ntpShower;
00766 }

00771                                           {
00772   if(!LoadSlice(i)) return 0;
00773   else return ntpSlice;
00774 }

00800                                                             {
00801   if(!LoadSliceForRecoTH(i,j)) return 0;
00802   else return ntpTHSlice;
00803 }

00790                                             {
00791   if(!LoadStdHep(i)) return 0;
00792   else return ntpStdHep;
00793 }

00780                                           {
00781   if(!LoadStrip(i)) return 0;
00782   else return ntpStrip;
00783 }

00814                                             {
00815   if(!LoadTHEvent(i)) return 0;
00816   else return ntpTHEvent;
00817 }

00819                                               {
00820   if(!LoadTHShower(i)) return 0;
00821   else return ntpTHShower;
00822 }

00824                                             {
00825   if(!LoadTHSlice(i)) return 0;
00826   else return ntpTHSlice;
00827 }

00809                                             {
00810   if(!LoadTHTrack(i)) return 0;
00811   else return ntpTHTrack;
00812 }

00741                                           {
00742   if(!LoadTrack(i)) return 0;
00743   else return ntpTrack;
00744 
00745 }

00785                                           {
00786   if(!LoadTruth(i)) return 0;
00787   else return ntpTruth;
00788 }

00795                                                           {
00796   if(!LoadTruthForReco(i,j)) return 0;
00797   else return ntpTruth;
00798 }

00804                                                             {
00805   if(!LoadTruthForRecoTH(i,j)) return 0;
00806   else return ntpTruth;
00807 }

00178 {
00179 
00180   record = 0;
00181   emrecord = 0;
00182   mcrecord = 0;
00183   threcord = 0;
00184   strecord = 0;
00185 
00186   fChain = new MadChain(chainSR,chainMC,chainTH,chainEM,build_index);
00187   isMC = fChain->isMC;
00188   isTH = fChain->isTH;
00189   isEM = fChain->isEM;
00190   isST = fChain->isST;
00191 
00192   Nentries = fChain->Nentries;  
00193 
00194   if(isST) std::cout << "ST Present" << std::endl;
00195   if(isMC) std::cout << "MC Present" << std::endl;
00196   if(isTH) std::cout << "TH Present" << std::endl;
00197   if(isEM) std::cout << "EM Present" << std::endl;
00198   
00199 }

00306                                      {
00307  
00308   Bool_t status = false;
00309   TClonesArray* pointClusterArray = NULL;
00310   if(isST) pointClusterArray = (strecord->clu);
00311   else pointClusterArray = (record->clu);
00312   TClonesArray& clusterArray = *pointClusterArray;
00313 //MAK:06/06/05  if(iclu>=0&&iclu<clusterArray.GetEntries()) {
00314   if(iclu>=0&&iclu<clusterArray.GetEntriesFast()) {
00315     ntpCluster = dynamic_cast<NtpSRCluster *>(clusterArray[iclu]);
00316     status = true;
00317   }
00318   else ntpCluster = 0;
00319    
00320   return status;
00321 }

00726                                       {
00727 
00728   Bool_t status = false;
00729   if(!isEM) return status; 
00730   TClonesArray& showerArray = *(emrecord->emshw);
00731 //MAK:06/06/05  if(ishw>=0&&ishw<showerArray.GetEntries()) {
00732   if(ishw>=0&&ishw<showerArray.GetEntries()) {
00733     ntpEMShower = dynamic_cast<NtpEMShower *>(showerArray[ishw]);
00734     status = true;
00735   }
00736   else ntpEMShower = 0;
00737   
00738   return status;
00739 }

00536                                    {
00537 
00538   Bool_t status = false;
00539   TClonesArray* pointEventArray = NULL;
00540   if(isST) pointEventArray = (strecord->evt);
00541   else pointEventArray = (record->evt);
00542   TClonesArray& eventArray = *pointEventArray;
00543 //MAK:06/06/05  if(ievt>=0&&ievt<eventArray.GetEntries()) {
00544   if(ievt>=0&&ievt<eventArray.GetEntriesFast()) {
00545     ntpEvent = dynamic_cast<NtpSREvent *>(eventArray[ievt]);
00546     status = true;
00547   }
00548   else ntpEvent = 0;
00549   
00550   return status;
00551 }

00340                                                                 {
00341 
00342   Bool_t status = false;
00343   ntpShower = 0;
00344   if(!LoadEvent(ievt)) return status;
00345   
00346   Float_t largest_ph = 0;
00347   int *showers = ntpEvent->shw;  
00348   for(int i=0;i<ntpEvent->nshower;i++){    
00349     if(!LoadShower(showers[i])) continue;
00350     if(ntpShower->ph.gev>largest_ph) {
00351       ishw = showers[i];
00352       largest_ph = ntpShower->ph.gev;
00353     }
00354   }
00355   ntpShower = 0;
00356   if(largest_ph>0){
00357     status = true;
00358     LoadShower(ishw);
00359   } 
00360   return status;
00361 }

00244                                                                {
00245 
00246   Bool_t status = false;  
00247   ntpTrack = 0;
00248   if(!LoadEvent(ievt)) return status;
00249 
00250   Float_t largest_ph = 0;
00251   int *tracks = ntpEvent->trk;  
00252   for(int i=0;i<ntpEvent->ntrack;i++){    
00253     if(!LoadTrack(tracks[i])) continue;
00254     // MAK: trklen should be an absolute value
00255     // MAK: Also, it shouldn't matter for beam events
00256     Int_t trklen=abs(ntpTrack->plane.end-ntpTrack->plane.beg+1);
00257     if(trklen>largest_ph) {
00258       itrk = tracks[i];
00259       largest_ph = trklen;
00260     }
00261   }
00262   ntpTrack = 0;
00263   if(largest_ph>0){
00264     status = true;
00265     LoadTrack(itrk);
00266   } 
00267   return status;
00268 }

00709                                          {
00710 
00711   Bool_t status = false;
00712   TClonesArray* pointStripArray = NULL;
00713   if(isST) pointStripArray = (strecord->vetostp);
00714   else pointStripArray = (record->vetostp);
00715   TClonesArray& stripArray = *pointStripArray;
00716 //MAK:06/06/05  if(istp>=0&&istp<stripArray.GetEntries()) {
00717   if(istp>=0&&istp<stripArray.GetEntriesFast()) {
00718     ntpShieldStrip = dynamic_cast<NtpSRShieldStrip *>(stripArray[istp]);
00719     status = true;
00720   }
00721   else ntpShieldStrip = 0;
00722   
00723   return status;
00724 }

00323                                     {
00324 
00325   Bool_t status = false;
00326   TClonesArray* pointShowerArray = NULL;
00327   if(isST) pointShowerArray = (strecord->shw);
00328   else pointShowerArray = (record->shw);
00329   TClonesArray& showerArray = *pointShowerArray;
00330 //MAK:06/06/05  if(ishw>=0&&ishw<showerArray.GetEntries()) {
00331   if(ishw>=0&&ishw<showerArray.GetEntriesFast()) {
00332     ntpShower = dynamic_cast<NtpSRShower *>(showerArray[ishw]);
00333     status = true;
00334   }
00335   else ntpShower = 0;
00336   
00337   return status;
00338 }

00363                                                                     {
00364 
00365   Bool_t status = false;
00366   ntpShower = 0;
00367   if(!LoadEvent(ievt)) return status;
00368   int *showers = ntpEvent->shw;  
00369   if(ntpEvent->ntrack==0 && ntpEvent->nshower>0) {
00370    ishw = showers[0];
00371    ntpShower = 0;  
00372    status = true;
00373    LoadShower(ishw);
00374   }
00375   if(ntpEvent->primshw<0) return false;
00376 
00377   if(ntpEvent->nshower>0 && ntpEvent->ntrack> 0) {
00378    if(!LoadShower(showers[0])) return status;
00379    ishw = showers[0];
00380    ntpShower = 0;    
00381    LoadShower(ishw);
00382    int track_index   = -1;
00383    LoadLargestTrackFromEvent(ievt,track_index);  
00384    Double_t reco_eshwcc,reco_eshwccw; 
00385    Int_t shwtype=0;  
00386    shwtype=0;
00387    reco_eshwcc       = RecoShwEnergy(ishw,shwtype,detector);
00388    shwtype=1;
00389    reco_eshwccw      = RecoShwEnergy(ishw,shwtype,detector); 
00390    if(track_index!=-1){
00391       Double_t trvz= ntpTrack ->vtx.z; 
00392       Double_t shvz= ntpShower->vtx.z;
00393       if(fabs(trvz-shvz)<0.5 || (fabs(trvz-shvz)>=0.5 && reco_eshwcc > 2)) {
00394        status=true;       
00395       }
00396       else if(fabs(trvz-shvz)>=0.5 && reco_eshwcc <= 2) {
00397        status=false;      
00398      }
00399     }
00400   }
00401   if(!status) ishw=-1;
00402   
00403   return status;
00404 }

00436                                                                         {
00437 
00438   Bool_t status = false;
00439   ntpShower = 0;
00440   if(!LoadEvent(ievt)) return status;
00441   if(!LoadTrack(itrk)) return status;
00442 
00443   Float_t closest_ph = 0;
00444   Float_t closest_vtx = 1000.;
00445   const Float_t close_enough=7*0.06; // about 1 interaction length
00446   int *showers = ntpEvent->shw;
00447   for(int i=0;i<ntpEvent->nshower;i++){
00448     if(!LoadShower(showers[i])) continue;
00449     /*
00450     Float_t vtx_sep = TMath::Sqrt(TMath::Power(ntpShower->vtx.x-ntpTrack->vtx.x,2) +
00451                                   TMath::Power(ntpShower->vtx.y-ntpTrack->vtx.y,2) +
00452                                   TMath::Power(ntpShower->vtx.z-ntpTrack->vtx.z,2));
00453     */
00454     Float_t vtx_sep = TMath::Abs(ntpShower->vtx.z-ntpTrack->vtx.z);
00455 
00456     // if this is the closest shower
00457     if(vtx_sep < closest_vtx) {
00458       ishw = showers[i];
00459       closest_vtx = vtx_sep;
00460       // this is a check to make sure we have R1.16 or greater shw variables
00461       if(ntpShower->shwph.linCCgev>0) closest_ph = ntpShower->shwph.linCCgev;
00462       else closest_ph=ntpShower->ph.gev;
00463     }
00464     // if this isn't the closest shower but it's within close_enough m of the
00465     // track vertex and has a larger pulseheight
00466     else if(vtx_sep<close_enough && ntpShower->ph.gev>closest_ph){
00467       ishw = showers[i];
00468       closest_vtx = vtx_sep;
00469 
00470       if(ntpShower->shwph.linCCgev>0) closest_ph = ntpShower->shwph.linCCgev;
00471       else closest_ph=ntpShower->ph.gev;
00472     }
00473   }
00474   ntpShower = 0;
00475   // only associate showers within close_enough m of the track vertex
00476   if(closest_vtx<close_enough){
00477     status = true;
00478     LoadShower(ishw);
00479   }
00480   return status;
00481 }

00501                                    {
00502 
00503   Bool_t status = false;
00504   TClonesArray* pointSliceArray = NULL;
00505   if(isST) pointSliceArray = (strecord->slc);
00506   else pointSliceArray = (record->slc);
00507   TClonesArray& sliceArray = *pointSliceArray;
00508 //MAK:06/06/05  if(islc>=0&&islc<sliceArray.GetEntries()) {
00509   if(islc>=0&&islc<sliceArray.GetEntriesFast()) {
00510     ntpSlice = dynamic_cast<NtpSRSlice *>(sliceArray[islc]);
00511     status = true;
00512   }
00513   else ntpSlice = 0;
00514   
00515   return status;
00516 }

00627                                                           {
00628 
00629   Bool_t status = false;
00630   ntpSlice = 0;
00631   if(!LoadEvent(ievt)) return status;
00632   if(!isMC) return status;
00633   if(!isTH) return status;
00634 
00635   /*
00636     Int_t itru = 0;
00637     if(LoadTruthForRecoTH(ievt,itru)){
00638     Int_t count = 0;
00639     while(!status){
00640     if(!LoadTHSlice(count)) break;
00641     if(ntpTHSlice->neumc==itru) {
00642     if(LoadSlice(count)){
00643     islice = count;
00644     status = true;
00645     }
00646     }
00647     count += 1;
00648     }
00649     }
00650   */
00651 
00652   //Tingjun's sugggested change:
00653   islice = ntpEvent->slc;
00654   if (LoadSlice(islice)&&LoadTHSlice(islice)) status = true;
00655   
00656   return status;
00657 }

00571                                    {
00572   
00573   Bool_t status = false;
00574   if(!isMC) return status;
00575   TClonesArray* pointStdhepArray = NULL;
00576   if(isST) pointStdhepArray = (strecord->stdhep);
00577   else pointStdhepArray = (mcrecord->stdhep);
00578   TClonesArray& stdhepArray = *pointStdhepArray;
00579 //MAK:06/06/05  if(ish>=0&&ish<stdhepArray.GetEntries()) {
00580   if(ish>=0&&ish<stdhepArray.GetEntriesFast()) {
00581     ntpStdHep = dynamic_cast<NtpMCStdHep *>(stdhepArray[ish]);
00582     status = true;
00583   }
00584   else ntpStdHep = 0;
00585   
00586   return status;
00587 }

00692                                    {
00693 
00694   Bool_t status = false;
00695   TClonesArray* pointStripArray = NULL;
00696   if(isST) pointStripArray = (strecord->stp);
00697   else pointStripArray = (record->stp);
00698   TClonesArray& stripArray = *pointStripArray;
00699   //MAK:06/06/05 if(istp>=0&&istp<stripArray.GetEntries()) { 
00700   if(istp>=0&&istp<stripArray.GetEntriesFast()) {
00701     ntpStrip = dynamic_cast<NtpSRStrip *>(stripArray[istp]);
00702     status = true;
00703   }
00704   else ntpStrip = 0;
00705   
00706   return status;
00707 }

00270                                      {
00271 
00272   Bool_t status = false;
00273   if(!isTH) return status; 
00274   TClonesArray* pointEventArray = NULL;
00275   if(isST) pointEventArray = (strecord->thevt);
00276   else pointEventArray = (threcord->thevt);
00277   TClonesArray& eventArray = *pointEventArray;
00278   //MAK:06/06/05  if(ievt>=0&&ievt<eventArray.GetEntries()) {
00279   if(ievt>=0&&ievt<eventArray.GetEntriesFast()) {
00280     ntpTHEvent = dynamic_cast<NtpTHEvent *>(eventArray[ievt]);
00281     status = true;
00282   }
00283   else ntpTHEvent = 0;
00284   
00285   return status;
00286 }

00483                                       {
00484 
00485   Bool_t status = false;
00486   if(!isTH) return status; 
00487   TClonesArray* pointShowerArray = NULL;
00488   if(isST) pointShowerArray = (strecord->thshw);
00489   else pointShowerArray = (threcord->thshw);
00490   TClonesArray& showerArray = *pointShowerArray;
00491 //MAK:06/06/05  if(ishw>=0&&ishw<showerArray.GetEntries()) {
00492   if(ishw>=0&&ishw<showerArray.GetEntriesFast()) {
00493     ntpTHShower = dynamic_cast<NtpTHShower *>(showerArray[ishw]);
00494     status = true;
00495   }
00496   else ntpTHShower = 0;
00497   
00498   return status;
00499 }

00518                                      {
00519 
00520   Bool_t status = false;
00521   if(!isTH) return status;
00522   TClonesArray* pointSliceArray = NULL;
00523   if(isST) pointSliceArray = (strecord->thslc);
00524   else pointSliceArray = (threcord->thslc);
00525   TClonesArray& sliceArray = *pointSliceArray;
00526 //MAK:06/06/05  if(islc>=0&&islc<sliceArray.GetEntries()) {
00527   if(islc>=0&&islc<sliceArray.GetEntriesFast()) {
00528     ntpTHSlice = dynamic_cast<NtpTHSlice *>(sliceArray[islc]);
00529     status = true;
00530   }
00531   else ntpTHSlice = 0;
00532   
00533   return status;
00534 }

00288                                      {
00289 
00290   Bool_t status = false;
00291   if(!isTH) return status; 
00292   TClonesArray* pointTrackArray = NULL;
00293   if(isST) pointTrackArray = (strecord->thtrk);
00294   else pointTrackArray = (threcord->thtrk);
00295   TClonesArray& trackArray = *pointTrackArray;
00296 //MAK:06/06/05  if(itrk>=0&&itrk<trackArray.GetEntries()) {
00297   if(itrk>=0&&itrk<trackArray.GetEntriesFast()) {
00298     ntpTHTrack = dynamic_cast<NtpTHTrack *>(trackArray[itrk]);
00299     status = true;
00300   }
00301   else ntpTHTrack = 0;
00302   
00303   return status;
00304 }

00227                                    {
00228 
00229   Bool_t status = false;
00230   TClonesArray* pointTrackArray = NULL;
00231   if(isST) pointTrackArray = (strecord->trk);
00232   else pointTrackArray = (record->trk);
00233   TClonesArray& trackArray = *pointTrackArray;
00234 //MAK:06/06/05  if(itrk>=0&&itrk<trackArray.GetEntries()) {
00235   if(itrk>=0&&itrk<trackArray.GetEntriesFast()) {
00236     ntpTrack = dynamic_cast<NtpSRTrack *>(trackArray[itrk]);
00237     status = true;
00238   }
00239   else ntpTrack = 0;
00240   
00241   return status;
00242 }

00553                                   {
00554   
00555   Bool_t status = false;
00556   if(!isMC) return status;
00557   TClonesArray* pointMcArray = NULL;
00558   if(isST) pointMcArray = (strecord->mc);
00559   else pointMcArray = (mcrecord->mc);
00560   TClonesArray& mcArray = *pointMcArray;
00561 //MAK:06/06/05  if(itr>=0&&itr<mcArray.GetEntries()) {
00562   if(itr>=0&&itr<mcArray.GetEntriesFast()) {
00563     ntpTruth = dynamic_cast<NtpMCTruth *>(mcArray[itr]);
00564     status = true;
00565   }
00566   else ntpTruth = 0;
00567   
00568   return status;
00569 }

00589                                                         {
00590 
00591   Bool_t status = false;  
00592   ntpTruth = 0;
00593   if(!LoadEvent(ievt)) return status;
00594   if(!isMC) return status;
00595 
00596   TClonesArray* pointMcArray = NULL;
00597   if(isST) pointMcArray = (strecord->mc);
00598   else pointMcArray = (mcrecord->mc);
00599   TClonesArray& mcArray = *pointMcArray;
00600   if(mcArray.GetEntries()==1) { //if only one MC event is present just load it
00601     LoadTruth(0);
00602     return true;
00603   }
00604 
00605   float mindist = 999;
00606   int itr = 0;
00607   //loop over all MC events and look for closest vertex to reco vertex
00608   for(int i=0;i<mcArray.GetEntries();i++){
00609     ntpTruth = dynamic_cast<NtpMCTruth *>(mcArray[i]);
00610     float dist = sqrt(TMath::Power(ntpTruth->vtxx/100.-ntpEvent->vtx.x,2)
00611                       +TMath::Power(ntpTruth->vtxy/100.-ntpEvent->vtx.y,2)
00612                       +TMath::Power(ntpTruth->vtxz/100.-ntpEvent->vtx.z,2));
00613     if(dist<mindist) { 
00614       itr = i;
00615       mindist = dist;
00616     }
00617   }
00618 
00619   if(mindist<0.5) {  //Need to place a fairly loose cut to pick up showers
00620     status = true;   //From looking at FarDet events, a cut of 0.5m 
00621     LoadTruth(itr);  //correctly pairs up 95% of events (LE beam,unoscillated) 
00622     itruth = itr;
00623   }
00624   return status;
00625 }

00660                                                           {
00661 
00662   Bool_t status = false;
00663   ntpTruth = 0;
00664   if(!LoadEvent(ievt)) return status;
00665   if(!isMC) return status;
00666   if(!isTH) return status;
00667   
00668   if(ntpEvent->ntrack>0) {
00669     int *tracks = ntpEvent->trk;
00670     if(LoadTHTrack(int(tracks[0]))){
00671       int ind = ntpTHTrack->neumc;
00672       if(LoadTruth(ind)) {
00673         itruth = ind;
00674         status = true;
00675       }
00676     }
00677   }
00678   if(!status&&ntpEvent->nshower>0) {
00679     int *showers = ntpEvent->shw;    
00680     if(LoadTHShower(int(showers[0]))){
00681       int ind = ntpTHShower->neumc;
00682       if(LoadTruth(ind)) {
00683         itruth = ind;
00684         status = true;
00685       }
00686     }
00687   }
00688   return status;
00689 
00690 }

00406                                                               {
00407   //use SR reco
00408   Float_t shower_ene=0;
00409                                                                                                                                          
00410   if(LoadShower(ishw)) {
00411   if(det==1){
00412     if(opt==-1) shower_ene = ntpShower->ph.gev;
00413     if(opt==0)  shower_ene = CorrectShowerEnergyNear(ntpShower->shwph.linCCgev,CandShowerHandle::kCC);
00414     if(opt==1)  shower_ene = CorrectShowerEnergyNear(ntpShower->shwph.wtCCgev,CandShowerHandle::kWtCC);
00415     if(opt==2)  shower_ene = CorrectShowerEnergyNear(ntpShower->shwph.linNCgev,CandShowerHandle::kNC);
00416     if(opt==3)  shower_ene = CorrectShowerEnergyNear(ntpShower->shwph.wtNCgev,CandShowerHandle::kWtNC);
00417     if(opt==4)  shower_ene = ntpShower->shwph.EMgev;
00418     return shower_ene;
00419   }
00420    if(det==2){
00421     if(opt==-1) shower_ene = ntpShower->ph.gev;
00422     if(opt==0)  shower_ene = CorrectShowerEnergyFar(ntpShower->shwph.linCCgev,CandShowerHandle::kCC);
00423     if(opt==1)  shower_ene = CorrectShowerEnergyFar(ntpShower->shwph.wtCCgev,CandShowerHandle::kWtCC);
00424     if(opt==2)  shower_ene = CorrectShowerEnergyFar(ntpShower->shwph.linNCgev,CandShowerHandle::kNC);
00425     if(opt==3)  shower_ene = CorrectShowerEnergyFar(ntpShower->shwph.wtNCgev,CandShowerHandle::kWtNC);
00426     if(opt==4)  shower_ene = ntpShower->shwph.EMgev;
00427     return shower_ene;
00428                                                                                                                                          
00429   }
00430 }
00431   return 0;
00432 }


Public Member Functions
	MadBase (TChain chainSR=0, TChain chainMC=0, TChain chainTH=0, TChain chainEM=0)
	MadBase (JobC *, string, int)
	~MadBase ()
Int_t	GetEntry (Int_t run, Int_t snarl)
Int_t	GetEntry (Int_t entry)
void	InitChain (TChain chainSR, TChain chainMC, TChain chainTH, TChain chainEM, bool build_index=false)
void	Clear ()
const NtpSREventSummary *	GetEventSummary ()
const RecCandHeader *	GetHeader ()
const NtpSRTrack *	GetTrack (Int_t)
const NtpSRTrack *	GetLargestTrackFromEvent (Int_t, Int_t &)
const NtpSRShower *	GetShower (Int_t)
const NtpSRCluster *	GetCluster (Int_t)
const NtpSRShower *	GetLargestShowerFromEvent (Int_t, Int_t &)
const NtpSRShower *	GetShowerAtTrackVertex (Int_t, Int_t, Int_t &)
const NtpSREvent *	GetEvent (Int_t)
const NtpSRSlice *	GetSlice (Int_t)
const NtpSRShieldStrip *	GetShieldStrip (Int_t)
const NtpSRStrip *	GetStrip (Int_t)
const NtpMCTruth *	GetTruth (Int_t)
const NtpMCStdHep *	GetStdHep (Int_t)
const NtpMCTruth *	GetTruthForReco (Int_t, Int_t &)
const NtpTHSlice *	GetSliceForRecoTH (Int_t, Int_t &)
const NtpMCTruth *	GetTruthForRecoTH (Int_t, Int_t &)
const NtpTHTrack *	GetTHTrack (Int_t)
const NtpTHEvent *	GetTHEvent (Int_t)
const NtpTHShower *	GetTHShower (Int_t)
const NtpTHSlice *	GetTHSlice (Int_t)
const NtpEMShower *	GetEMShower (Int_t)
Protected Member Functions
Bool_t	LoadTrack (Int_t idx)
Bool_t	LoadShower (Int_t idx)
Bool_t	LoadCluster (Int_t idx)
Bool_t	LoadEvent (Int_t idx)
Bool_t	LoadSlice (Int_t idx)
Bool_t	LoadShieldStrip (Int_t idx)
Bool_t	LoadStrip (Int_t idx)
Bool_t	LoadTruth (Int_t idx)
Bool_t	LoadStdHep (Int_t idx)
Bool_t	LoadTHTrack (Int_t)
Bool_t	LoadTHEvent (Int_t)
Bool_t	LoadTHShower (Int_t)
Bool_t	LoadTHSlice (Int_t)
Bool_t	LoadEMShower (Int_t)
Bool_t	LoadLargestTrackFromEvent (Int_t event, Int_t &trkidx)
Bool_t	LoadShower_Jim (Int_t event, Int_t &shwidx, Int_t detector)
Bool_t	LoadLargestShowerFromEvent (Int_t event, Int_t &shwidx)
Bool_t	LoadShowerAtTrackVertex (Int_t event, Int_t track, Int_t &shwidx)
Bool_t	LoadTruthForReco (Int_t, Int_t &)
Bool_t	LoadTruthForRecoTH (Int_t, Int_t &)
Bool_t	LoadSliceForRecoTH (Int_t, Int_t &)
Float_t	RecoShwEnergy (Int_t ishw=0, Int_t opt=-1, Int_t det=1)
Protected Attributes
MadChain *	fChain
JobC *	fJC
string	jcPath
int	fCurRun
int	lastEntry
int	whichSource
NtpStRecord *	strecord
NtpSRRecord *	record
const RecCandHeader *	ntpHeader
NtpSRShieldSummary *	shieldSummary
NtpSREventSummary *	eventSummary
NtpSRDmxStatus *	dmxStatus
NtpSRDetStatus *	detStatus
NtpSREvent *	ntpEvent
NtpSRTrack *	ntpTrack
NtpSRShower *	ntpShower
NtpSRCluster *	ntpCluster
NtpSRSlice *	ntpSlice
NtpSRShieldStrip *	ntpShieldStrip
NtpSRStrip *	ntpStrip
NtpMCRecord *	mcrecord
NtpMCSummary *	mcHeader
NtpMCTruth *	ntpTruth
NtpMCStdHep *	ntpStdHep
NtpTHRecord *	threcord
NtpTHSlice *	ntpTHSlice
NtpTHEvent *	ntpTHEvent
NtpTHTrack *	ntpTHTrack
NtpTHShower *	ntpTHShower
NtpEMRecord *	emrecord
NtpEMSummary *	ntpEMSummary
NtpEMShower *	ntpEMShower
Bool_t	isMC
Bool_t	isTH
Bool_t	isEM
Bool_t	isST
Int_t	Nentries

MadBase Class Reference

Public Member Functions

Protected Member Functions

Protected Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation