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

PmtMap Class Reference

#include <PmtMap.h>

List of all members.

Public Member Functions

 PmtMap ()
bool BuildMap (const vector< const RawDigit * > &digitlist, const vector< int > &digitindex, const VldContext *vldc)
bool BuildMap (const TClonesArray *rawdigits)
bool Merge (PmtMap &lhs, PmtMap &rhs)
void PrintSummary ()

Public Attributes

vector< ElecChannel > channel
ElecType::EElecType elecType

Constructor & Destructor Documentation

PmtMap::PmtMap (   ) 
 

Definition at line 36 of file PmtMap.cxx.

00037 {
00038 }

Member Function Documentation

bool PmtMap::BuildMap (  const TClonesArray *  rawdigits  ) 
 

Definition at line 111 of file PmtMap.cxx.

References RawDigitInfo::adc, ElecChannel::adc, channel, digit(), elecType, RawChannelId::GetElecType(), MSG, RawDigitInfo::rcid, ElecChannel::rcid, RawDigitInfo::tdc, ElecChannel::tdc, and ElecChannel::valid.

00112 {  
00113   if(rawdigits->GetEntries()==0) return false;
00114   elecType = ((RawDigitInfo*) rawdigits->At(0))->rcid.GetElecType();
00115   if(elecType==ElecType::kVA){
00116     TIter iter(rawdigits);
00117     while(RawDigitInfo *digit = dynamic_cast<RawDigitInfo*>(iter())){
00118       bool found = 0;
00119       const unsigned int nchannel = channel.size();
00120       for(unsigned int ichannel = 0; ichannel<nchannel; ichannel++){
00121         if(channel[ichannel].rcid == digit->rcid){      
00122           MSG("EvtMrg",Msg::kError) << "Found duplicate RCID RawDigitsInfo" <<endl;      
00123           found = 1;
00124         }
00125       }
00126       ElecChannel tmpch;
00127       tmpch.rcid = digit->rcid;
00128       tmpch.tdc  = (int)digit->tdc;
00129       tmpch.adc  = (int)digit->adc;
00130       tmpch.valid = 1;
00131       channel.push_back(tmpch);
00132     }
00133   }
00134   else if(elecType==ElecType::kQIE){
00135     TIter iter(rawdigits);
00136     while(RawDigitInfo *digit = dynamic_cast<RawDigitInfo*>(iter())  ){
00137       bool found = 0;
00138       const unsigned int nchannel = channel.size();
00139       for(unsigned int ichannel = 0; ichannel<nchannel; ichannel++){
00140         if(channel[ichannel].rcid == digit->rcid && 
00141            channel[ichannel].tdc == digit->tdc){        
00142           MSG("EvtMrg",Msg::kDebug) << "Found duplicate RCID RawDigits with same TDC (ADC) " 
00143                                     << channel[ichannel].tdc << " (" 
00144                                     << channel[ichannel].adc << ") cf " 
00145                                     << digit->tdc << " (" << digit->adc << ")" << endl;   
00146           // if we we're generating electrons independently
00147           // these digits would already be merged, so merge now:
00148           channel[ichannel].adc += (int)digit->adc;
00149           found = 1;
00150           break;
00151         }
00152       }
00153       if(!found) {
00154         ElecChannel tmpch;
00155         tmpch.rcid = digit->rcid;
00156         tmpch.tdc  = (int)digit->tdc;
00157         tmpch.adc  = (int)digit->adc;
00158         tmpch.valid = 1;
00159         channel.push_back(tmpch);
00160       }
00161     }
00162   }
00163   return true;
00164 }

bool PmtMap::BuildMap (  const vector< const RawDigit * > &  digitlist,
const vector< int > &  digitindex,
const VldContext *  vldc
) 
 

Definition at line 41 of file PmtMap.cxx.

References ElecChannel::adc, channel, elecType, RawChannelId::GetElecType(), PlexSEIdAltL::GetPlane(), PlexHandle::GetSEIdAltL(), ElecChannel::index, MSG, ElecChannel::rcid, ElecChannel::tdc, and ElecChannel::valid.

Referenced by AlgMergeEvent::RunAlg().

00043 {
00044   //set elecType:
00045   if(digitlist.size()==0) return false;
00046   elecType = digitlist[0]->GetChannel().GetElecType();
00047   //fill vector:
00048   if(elecType==ElecType::kVA){
00049     const unsigned int ndigit = digitlist.size(); 
00050     for(unsigned int idigit= 0 ; idigit<ndigit; idigit++){    
00051       RawChannelId rcid = digitlist[idigit]->GetChannel();
00052       Int_t        tdc  = digitlist[idigit]->GetTDC();
00053       Int_t        adc  = digitlist[idigit]->GetADC();
00054       bool found = 0;
00055       const unsigned int nchannel = channel.size();
00056       for(unsigned int ichannel = 0; ichannel<nchannel; ichannel++){
00057         if(channel[ichannel].rcid == rcid){
00058           MSG("EvtMrg",Msg::kError) << "Found duplicate RCID RawDigits:" 
00059                                     << channel[ichannel].tdc << "  cf " 
00060                                     << digitlist[idigit]->GetTDC() << endl;
00061           found = 1;
00062         }
00063       }
00064       ElecChannel tmpch;
00065       tmpch.rcid = rcid;
00066       tmpch.tdc  = tdc;
00067       tmpch.adc  = adc;
00068       tmpch.valid = 1;
00069       tmpch.index = digit_index[idigit];
00070       channel.push_back(tmpch);
00071     }  
00072   }
00073   else if(elecType==ElecType::kQIE){
00074     PlexHandle ph(*vldc);
00075     const unsigned int ndigit = digitlist.size();
00076     for(unsigned int idigit= 0 ; idigit<ndigit; idigit++){
00077       RawChannelId rcid = digitlist[idigit]->GetChannel();
00078       Int_t        tdc  = digitlist[idigit]->GetTDC();
00079       Int_t        adc  = digitlist[idigit]->GetADC();
00080       Int_t        pln  = ph.GetSEIdAltL(rcid).GetPlane();
00081       bool found = 0;
00082       const unsigned int nchannel = channel.size();
00083       for(unsigned int ichannel = 0; ichannel<nchannel; ichannel++){
00084         if(channel[ichannel].rcid == rcid && channel[ichannel].tdc == tdc){
00085           if(pln>=121) found = 1;  //spectrometer
00086           else { 
00087             MSG("EvtMrg",Msg::kError) << "Found duplicate RCID RawDigits with same TDC (ADC) " 
00088                                       << channel[ichannel].tdc << " (" 
00089                                       << channel[ichannel].adc << ") cf " 
00090                                       << tdc << " (" << adc << ") in plane " << pln << endl;
00091             
00092           }
00093         }
00094       }
00095       // not going to add multiple spectrometer digits; these come from previous reco pass
00096       if(!found){
00097         ElecChannel tmpch;
00098         tmpch.rcid = rcid;
00099         tmpch.tdc  = tdc;
00100         tmpch.adc  = adc;
00101         tmpch.valid = 1;
00102         tmpch.index = digit_index[idigit];
00103         channel.push_back(tmpch);
00104       }
00105     }
00106   }
00107   return true;
00108 }

bool PmtMap::Merge (  PmtMap &  lhs,
PmtMap &  rhs
) 
 

Definition at line 167 of file PmtMap.cxx.

References abs(), ElecChannel::adc, channel, elecType, ElecChannel::index, MSG, ElecChannel::rcid, ElecChannel::tdc, and ElecChannel::valid.

Referenced by AlgMergeEvent::RunAlg().

00167                                           {
00168   //look at lhs and add in any overlapping digits
00169   if(lhs.elecType!=rhs.elecType) return false;
00170   elecType = lhs.elecType;
00171   if(elecType==ElecType::kVA){
00172     Int_t max_index = 0;
00173     const unsigned int nlhs = lhs.channel.size();
00174     const unsigned int nrhs = rhs.channel.size();  
00175     for(unsigned int ilhs=0; ilhs<nlhs; ilhs++){   
00176       ElecChannel tmp;
00177       tmp.rcid = lhs.channel[ilhs].rcid;
00178       tmp.adc = lhs.channel[ilhs].adc;
00179       tmp.tdc = lhs.channel[ilhs].tdc;
00180       tmp.index = lhs.channel[ilhs].index;
00181       tmp.valid = 1;        
00182       for(unsigned int irhs=0; irhs<nrhs; irhs++){
00183         if(lhs.channel[ilhs].rcid == rhs.channel[irhs].rcid && rhs.channel[irhs].valid){
00184           MSG("EvtMrg",Msg::kVerbose) 
00185             << "Merging digits Dt:" << abs(tmp.tdc  - rhs.channel[irhs].tdc) 
00186             <<  "  Different time:" 
00187             << ((abs(tmp.tdc  - rhs.channel[irhs].tdc)>3200)?" Okay " : " combine" ) << endl;
00188           if(abs(tmp.tdc  - rhs.channel[irhs].tdc)<3200){
00189             tmp.adc+=rhs.channel[irhs].adc;
00190             if(rhs.channel[irhs].tdc< tmp.tdc) tmp.tdc = rhs.channel[irhs].tdc;
00191             if(rhs.channel[irhs].index!=-1) tmp.index = rhs.channel[irhs].index;
00192             rhs.channel[irhs].valid = 0;
00193           }
00194         }
00195       }
00196       this->channel.push_back(tmp);
00197       if(tmp.index>max_index) max_index = tmp.index;
00198     }
00199 
00200     //
00201     //pick up any remaining digits
00202     //
00203     for(unsigned int irhs=0; irhs<nrhs; irhs++){
00204       if(rhs.channel[irhs].valid){
00205         ElecChannel tmp;
00206         tmp.rcid = rhs.channel[irhs].rcid;
00207         tmp.adc = rhs.channel[irhs].adc;
00208         tmp.tdc = rhs.channel[irhs].tdc;
00209         tmp.valid = 1;        
00210         tmp.index = max_index; //rhs.channel[irhs].index;
00211         this->channel.push_back(tmp);
00212       }
00213     }
00214   }
00215   else if(elecType==ElecType::kQIE){
00216     const unsigned int nlhs = lhs.channel.size();
00217     const unsigned int nrhs = rhs.channel.size();
00218     Int_t max_index = 0;
00219     for(unsigned int ilhs=0; ilhs<nlhs; ilhs++){
00220       ElecChannel tmp;
00221       tmp.rcid = lhs.channel[ilhs].rcid;
00222       tmp.adc = lhs.channel[ilhs].adc;
00223       tmp.tdc = lhs.channel[ilhs].tdc;
00224       tmp.index = lhs.channel[ilhs].index;
00225       tmp.valid = 1;
00226       for(unsigned int irhs=0; irhs<nrhs; irhs++){
00227         if(lhs.channel[ilhs].rcid == rhs.channel[irhs].rcid && 
00228            lhs.channel[ilhs].tdc  == rhs.channel[irhs].tdc && 
00229            rhs.channel[irhs].valid){
00230           MSG("EvtMrg",Msg::kVerbose) << "Merging digits RCID = " << tmp.rcid 
00231                                       << " TDC = " << tmp.tdc << endl;
00232           tmp.adc+=rhs.channel[irhs].adc;
00233           rhs.channel[irhs].valid = 0;
00234         }
00235     }
00236       this->channel.push_back(tmp);
00237       if(tmp.index>max_index) max_index = tmp.index;
00238     }
00239     
00240     //
00241     //pick up any remaining digits
00242     //
00243     for(unsigned int irhs=0; irhs<nrhs; irhs++){
00244       if(rhs.channel[irhs].valid){
00245         ElecChannel tmp;
00246         tmp.rcid = rhs.channel[irhs].rcid;
00247         tmp.adc = rhs.channel[irhs].adc;
00248         tmp.tdc = rhs.channel[irhs].tdc;
00249         tmp.valid = 1;
00250         tmp.index = max_index;
00251         this->channel.push_back(tmp);
00252         rhs.channel[irhs].valid = 0;
00253       }
00254     }
00255   }
00256   return true;  
00257 }

void PmtMap::PrintSummary (   ) 
 

Definition at line 259 of file PmtMap.cxx.

References channel.

00259                          {
00260   const unsigned int nchannel = channel.size();
00261   for(unsigned int ichannel = 0; ichannel<nchannel; ichannel++){
00262     channel[ichannel].PrintSummary();
00263   }
00264 }

Member Data Documentation

vector<ElecChannel> PmtMap::channel
 

Definition at line 31 of file PmtMap.h.

Referenced by BuildMap(), Merge(), PrintSummary(), and AlgMergeEvent::RunAlg().

ElecType::EElecType PmtMap::elecType
 

Definition at line 32 of file PmtMap.h.

Referenced by BuildMap(), and Merge().

The documentation for this class was generated from the following files:
Generated on Mon Feb 15 11:10:05 2010 for loon by  doxygen 1.3.9.1