PmtMap.cxx

Go to the documentation of this file.

#include <cstdlib>

#include "MuonRemoval/PmtMap.h"
#include "MessageService/MsgService.h"
#include "MuonRemoval/RawDigitInfo.h"
#include "Plex/PlexHandle.h"

CVSID("$Id: PmtMap.cxx,v 1.4 2009/02/28 21:46:14 gmieg Exp $");

ElecChannel::ElecChannel():
  adc(0),
  tdc(0),
  valid(0),
  index(-1)
{
}

void ElecChannel::PrintSummary(){  
  if(rcid.GetElecType()==ElecType::kVA)
    MSG("EvtMrg",Msg::kInfo) << rcid.GetCrate() << " " << rcid.GetVarcId() << " " 
                             << rcid.GetVfb() << " " << rcid.GetVaAdcSel() << " " 
                             << rcid.GetVaChip() << " " << rcid.GetVaChannel() << " " 
                             << adc << " " << tdc << " " << ((valid!=0)?' ':'X') << " " 
                             << index << endl;  
  else if(rcid.GetElecType()==ElecType::kQIE)
    MSG("EvtMrg",Msg::kInfo) << rcid.GetCrate() << " " << rcid.GetMaster() << " " 
                             << rcid.GetMinder() << " " << rcid.GetMenu() << " " 
                             << adc << " " << tdc << " " << ((valid!=0)?' ':'X') 
                             << " " << index << endl;  
}


//
// The detector map
//
PmtMap::PmtMap()
{
}

    
bool PmtMap::BuildMap(const vector<const RawDigit*>& digitlist, 
                      const vector<int>& digit_index,const VldContext *vldc)
{
  //set elecType:
  if(digitlist.size()==0) return false;
  elecType = digitlist[0]->GetChannel().GetElecType();
  //fill vector:
  if(elecType==ElecType::kVA){
    const unsigned int ndigit = digitlist.size(); 
    for(unsigned int idigit= 0 ; idigit<ndigit; idigit++){    
      RawChannelId rcid = digitlist[idigit]->GetChannel();
      Int_t        tdc  = digitlist[idigit]->GetTDC();
      Int_t        adc  = digitlist[idigit]->GetADC();
      bool found = 0;
      const unsigned int nchannel = channel.size();
      for(unsigned int ichannel = 0; ichannel<nchannel; ichannel++){
        if(channel[ichannel].rcid == rcid){
          MSG("EvtMrg",Msg::kError) << "Found duplicate RCID RawDigits:" 
                                    << channel[ichannel].tdc << "  cf " 
                                    << digitlist[idigit]->GetTDC() << endl;
          found = 1;
        }
      }
      ElecChannel tmpch;
      tmpch.rcid = rcid;
      tmpch.tdc  = tdc;
      tmpch.adc  = adc;
      tmpch.valid = 1;
      tmpch.index = digit_index[idigit];
      channel.push_back(tmpch);
    }  
  }
  else if(elecType==ElecType::kQIE){
    PlexHandle ph(*vldc);
    const unsigned int ndigit = digitlist.size();
    for(unsigned int idigit= 0 ; idigit<ndigit; idigit++){
      RawChannelId rcid = digitlist[idigit]->GetChannel();
      Int_t        tdc  = digitlist[idigit]->GetTDC();
      Int_t        adc  = digitlist[idigit]->GetADC();
      Int_t        pln  = ph.GetSEIdAltL(rcid).GetPlane();
      bool found = 0;
      const unsigned int nchannel = channel.size();
      for(unsigned int ichannel = 0; ichannel<nchannel; ichannel++){
        if(channel[ichannel].rcid == rcid && channel[ichannel].tdc == tdc){
          if(pln>=121) found = 1;  //spectrometer
          else { 
            MSG("EvtMrg",Msg::kError) << "Found duplicate RCID RawDigits with same TDC (ADC) " 
                                      << channel[ichannel].tdc << " (" 
                                      << channel[ichannel].adc << ") cf " 
                                      << tdc << " (" << adc << ") in plane " << pln << endl;
            
          }
        }
      }
      // not going to add multiple spectrometer digits; these come from previous reco pass
      if(!found){
        ElecChannel tmpch;
        tmpch.rcid = rcid;
        tmpch.tdc  = tdc;
        tmpch.adc  = adc;
        tmpch.valid = 1;
        tmpch.index = digit_index[idigit];
        channel.push_back(tmpch);
      }
    }
  }
  return true;
}
  
  
bool PmtMap::BuildMap(const TClonesArray*  rawdigits)
{  
  if(rawdigits->GetEntries()==0) return false;
  elecType = ((RawDigitInfo*) rawdigits->At(0))->rcid.GetElecType();
  if(elecType==ElecType::kVA){
    TIter iter(rawdigits);
    while(RawDigitInfo *digit = dynamic_cast<RawDigitInfo*>(iter())){
      bool found = 0;
      const unsigned int nchannel = channel.size();
      for(unsigned int ichannel = 0; ichannel<nchannel; ichannel++){
        if(channel[ichannel].rcid == digit->rcid){      
          MSG("EvtMrg",Msg::kError) << "Found duplicate RCID RawDigitsInfo" <<endl;      
          found = 1;
        }
      }
      ElecChannel tmpch;
      tmpch.rcid = digit->rcid;
      tmpch.tdc  = (int)digit->tdc;
      tmpch.adc  = (int)digit->adc;
      tmpch.valid = 1;
      channel.push_back(tmpch);
    }
  }
  else if(elecType==ElecType::kQIE){
    TIter iter(rawdigits);
    while(RawDigitInfo *digit = dynamic_cast<RawDigitInfo*>(iter())  ){
      bool found = 0;
      const unsigned int nchannel = channel.size();
      for(unsigned int ichannel = 0; ichannel<nchannel; ichannel++){
        if(channel[ichannel].rcid == digit->rcid && 
           channel[ichannel].tdc == digit->tdc){        
          MSG("EvtMrg",Msg::kDebug) << "Found duplicate RCID RawDigits with same TDC (ADC) " 
                                    << channel[ichannel].tdc << " (" 
                                    << channel[ichannel].adc << ") cf " 
                                    << digit->tdc << " (" << digit->adc << ")" << endl;   
          // if we we're generating electrons independently
          // these digits would already be merged, so merge now:
          channel[ichannel].adc += (int)digit->adc;
          found = 1;
          break;
        }
      }
      if(!found) {
        ElecChannel tmpch;
        tmpch.rcid = digit->rcid;
        tmpch.tdc  = (int)digit->tdc;
        tmpch.adc  = (int)digit->adc;
        tmpch.valid = 1;
        channel.push_back(tmpch);
      }
    }
  }
  return true;
}


bool PmtMap::Merge(PmtMap& lhs, PmtMap& rhs){
  //look at lhs and add in any overlapping digits
  if(lhs.elecType!=rhs.elecType) return false;
  elecType = lhs.elecType;
  if(elecType==ElecType::kVA){
    Int_t max_index = 0;
    const unsigned int nlhs = lhs.channel.size();
    const unsigned int nrhs = rhs.channel.size();  
    for(unsigned int ilhs=0; ilhs<nlhs; ilhs++){   
      ElecChannel tmp;
      tmp.rcid = lhs.channel[ilhs].rcid;
      tmp.adc = lhs.channel[ilhs].adc;
      tmp.tdc = lhs.channel[ilhs].tdc;
      tmp.index = lhs.channel[ilhs].index;
      tmp.valid = 1;        
      for(unsigned int irhs=0; irhs<nrhs; irhs++){
        if(lhs.channel[ilhs].rcid == rhs.channel[irhs].rcid && rhs.channel[irhs].valid){
          MSG("EvtMrg",Msg::kVerbose) 
            << "Merging digits Dt:" << abs(tmp.tdc  - rhs.channel[irhs].tdc) 
            <<  "  Different time:" 
            << ((abs(tmp.tdc  - rhs.channel[irhs].tdc)>3200)?" Okay " : " combine" ) << endl;
          if(abs(tmp.tdc  - rhs.channel[irhs].tdc)<3200){
            tmp.adc+=rhs.channel[irhs].adc;
            if(rhs.channel[irhs].tdc< tmp.tdc) tmp.tdc = rhs.channel[irhs].tdc;
            if(rhs.channel[irhs].index!=-1) tmp.index = rhs.channel[irhs].index;
            rhs.channel[irhs].valid = 0;
          }
        }
      }
      this->channel.push_back(tmp);
      if(tmp.index>max_index) max_index = tmp.index;
    }

    //
    //pick up any remaining digits
    //
    for(unsigned int irhs=0; irhs<nrhs; irhs++){
      if(rhs.channel[irhs].valid){
        ElecChannel tmp;
        tmp.rcid = rhs.channel[irhs].rcid;
        tmp.adc = rhs.channel[irhs].adc;
        tmp.tdc = rhs.channel[irhs].tdc;
        tmp.valid = 1;        
        tmp.index = max_index; //rhs.channel[irhs].index;
        this->channel.push_back(tmp);
      }
    }
  }
  else if(elecType==ElecType::kQIE){
    const unsigned int nlhs = lhs.channel.size();
    const unsigned int nrhs = rhs.channel.size();
    Int_t max_index = 0;
    for(unsigned int ilhs=0; ilhs<nlhs; ilhs++){
      ElecChannel tmp;
      tmp.rcid = lhs.channel[ilhs].rcid;
      tmp.adc = lhs.channel[ilhs].adc;
      tmp.tdc = lhs.channel[ilhs].tdc;
      tmp.index = lhs.channel[ilhs].index;
      tmp.valid = 1;
      for(unsigned int irhs=0; irhs<nrhs; irhs++){
        if(lhs.channel[ilhs].rcid == rhs.channel[irhs].rcid && 
           lhs.channel[ilhs].tdc  == rhs.channel[irhs].tdc && 
           rhs.channel[irhs].valid){
          MSG("EvtMrg",Msg::kVerbose) << "Merging digits RCID = " << tmp.rcid 
                                      << " TDC = " << tmp.tdc << endl;
          tmp.adc+=rhs.channel[irhs].adc;
          rhs.channel[irhs].valid = 0;
        }
    }
      this->channel.push_back(tmp);
      if(tmp.index>max_index) max_index = tmp.index;
    }
    
    //
    //pick up any remaining digits
    //
    for(unsigned int irhs=0; irhs<nrhs; irhs++){
      if(rhs.channel[irhs].valid){
        ElecChannel tmp;
        tmp.rcid = rhs.channel[irhs].rcid;
        tmp.adc = rhs.channel[irhs].adc;
        tmp.tdc = rhs.channel[irhs].tdc;
        tmp.valid = 1;
        tmp.index = max_index;
        this->channel.push_back(tmp);
        rhs.channel[irhs].valid = 0;
      }
    }
  }
  return true;  
}

void PmtMap::PrintSummary(){
  const unsigned int nchannel = channel.size();
  for(unsigned int ichannel = 0; ichannel<nchannel; ichannel++){
    channel[ichannel].PrintSummary();
  }
}

---