TLowLevelInfoModule.cxx

Go to the documentation of this file.

#include "TLowLevelInfoModule.hxx"
#include "TGeomInfo.hxx"
#include "THit.hxx"
#include "TIntegerDatum.hxx"
#include "TTFBChannelId.hxx"
#include "TTFBDigit.hxx"

ClassImp(ND::TLowLevelInfoModule::TLowLevelTFBDigit);
ClassImp(ND::TLowLevelInfoModule::TLowLevelHit);

ND::TLowLevelInfoModule::TLowLevelInfoModule(const char* name,
                                             const char* title) {
  SetNameTitle(name, title);
  // Enable this module by default:
  fIsEnabled = kTRUE;
  fDescription =
      "Module for extracting TDigit and THit level info from the output of "
      "eventUnpack";
  fLowLevelTFBDigits =
      new TClonesArray("ND::TLowLevelInfoModule::TLowLevelTFBDigit", 100);
  fLowLevelHits =
      new TClonesArray("ND::TLowLevelInfoModule::TLowLevelHit", 100);
}
void ND::TLowLevelInfoModule::InitializeBranches() {
  // DIGIT AND HIT INFO
  fOutputTree->Branch("TFBDigitArray", &fLowLevelTFBDigits, fBufferSize,
                      fSplitLevel);
  fOutputTree->Branch("HitArray", &fLowLevelHits, fBufferSize, fSplitLevel);
}

bool ND::TLowLevelInfoModule::FillTree(ND::TND280Event& event) {
  fEventNumber = event.GetEventId();

  // ===========================================================================
  // First get mcmTrig info
  //
  Long64_t fTdcTrig = 0;

  ND::THandle<ND::TIntegerDatum> mcmTrigTime =
      event.Get<ND::TIntegerDatum>("mcmTrigTime");
  if (mcmTrigTime) {
    UInt_t trigger_mcmTDC = static_cast<UInt_t>(mcmTrigTime->GetValue());
    const Long64_t mcmTick(4LL);
    fTdcTrig = mcmTick * trigger_mcmTDC;
  }

  Long64_t fTdcRead = 0;
  Float_t fTimeRead = 0;
  ND::THandle<ND::TIntegerDatum> mcmTimeSinceBusy =
      event.Get<ND::TIntegerDatum>("mcmTimeSinceBusy");
  if (mcmTimeSinceBusy) {
    UInt_t dt_bktTrig_mcmTDC =
        static_cast<UInt_t>(mcmTimeSinceBusy->GetValue());
    const Long64_t mcmTick(4LL);
    fTdcRead = mcmTick * dt_bktTrig_mcmTDC;
    fTimeRead = (fTdcRead % 260) * 2.5;
  }

  // ===========================================================================
  // Get the TFBDigits
  //
  ND::THandle<ND::TDataVector> digitV = event.Get<ND::TDataVector>("digits");
  if (digitV) {
    ND280Debug("\nFound a vector of digit containers!");
    fNLowLevelTFBDigits = 0;
    for (ND::TDataVector::iterator diter = digitV->begin();
         diter != digitV->end(); diter++) {
      ND::TDigitContainer* digList = dynamic_cast<ND::TDigitContainer*>(*diter);
      if (digList) {
        std::string dt_name = digList->GetName();
        dt_name += "digits";
        std::string dt_name_full = (digList->GetFullName()).Data();
        dt_name_full += "digits";

        EDigitType digit_type = this->GetDigitType(digList->GetName());

        /// For now just do for ecal defined digits but could expand this to
        /// work for
        /// other sub-systems such as ingrid, smrd etc...
        if (digit_type == kECalDigits) {
          ND280Debug("Found an ecal digit container with name = "
                     << dt_name << " and " << digList->size() << " elements");
          ND::TDigitContainer::iterator digItr;
          for (digItr = digList->begin(); digItr != digList->end(); ++digItr) {
            TTFBDigit* digit = dynamic_cast<TTFBDigit*>(*digItr);
            if (!digit) {
              continue;
            }
            // Now make a new lowleveltfbdigit and add it to the clones array.
            ND::TLowLevelInfoModule::TLowLevelTFBDigit* fTFBDigit =
                new ((*fLowLevelTFBDigits)[fNLowLevelTFBDigits++])
                    ND::TLowLevelInfoModule::TLowLevelTFBDigit();
            // Fill in the lowleveldigit fields.
            TTFBChannelId id(digit->GetChannelId());
            fTFBDigit->Chan = id.GetChannel() + 16 * id.GetTripChip();
            fTFBDigit->Tfb = id.GetTFB();
            fTFBDigit->Rmm = id.GetRMM();
            fTFBDigit->Subdet = id.GetSubDetector();
            fTFBDigit->Side = 0;
            fTFBDigit->Err = 0;
            fTFBDigit->Err += (digit->CheckTimeDiscriminator() ? 0x1 : 0);
            fTFBDigit->Tdc =
                (digit->GetTimeCounter() * 4) + digit->GetTimeQuad();
            fTFBDigit->Adc_lo = digit->GetLowGainADC();
            fTFBDigit->Adc_hi = digit->GetHighGainADC();
            fTFBDigit->TdcTrig = fTdcTrig;
            fTFBDigit->TdcRead = fTdcRead;
          }  // end of loop over digits in container
        }    // for ecal digits
      }      // if(digList)
    }        // end of loop over digit containers
  }          // end of if(event.Has...

  // ===========================================================================
  //  Now get the Hits.
  //
  ND::THandle<ND::TDataVector> hitV = event.Get<ND::TDataVector>("hits");
  if (hitV) {
    ND280Debug("Found a hits container!");
    fNLowLevelHits = 0;
    for (ND::TDataVector::iterator hiter = hitV->begin(); hiter != hitV->end();
         ++hiter) {
      ND::THitSelection* hitList = dynamic_cast<ND::THitSelection*>(*hiter);
      if (hitList) {
        EHitType hit_type = this->GetHitType(hitList->GetName());
        /// ====================================================================
        /// For now just do for ecal defined hits but could expand this to work
        /// for other sub-systems such as ingrid, smrd etc...
        if (hit_type == kECalHits) {
          ND::THitSelection::iterator hitItr;
          for (hitItr = hitList->begin(); hitItr != hitList->end(); ++hitItr) {
            // Now make a new lowlevelecal hit and add it to the clones array.
            ND::TLowLevelInfoModule::TLowLevelHit* fTFBHit =
                new ((*fLowLevelHits)[fNLowLevelHits++])
                    ND::TLowLevelInfoModule::TLowLevelHit();
            // Fill in the lowlevelhit fields.
            ND::THandle<ND::THit> hit = (*hitItr);
            fTFBHit->Time = hit->GetTime();
            fTFBHit->Charge = hit->GetCharge();
            fTFBHit->GeomId = hit->GetGeomId().AsInt();
            fTFBHit->PosX = hit->GetPosition().X();
            fTFBHit->PosY = hit->GetPosition().Y();
            fTFBHit->PosZ = hit->GetPosition().Z();
            std::string nodename =
                ND::TGeomInfo::Get().NodeName(hit->GetGeomId());
            fTFBHit->XLayer = this->LayerXFromName(nodename);
            fTFBHit->YLayer = this->LayerYFromName(nodename);
            fTFBHit->Bar = this->BarFromName(nodename);
            fTFBHit->End = -1;
            fTFBHit->TimeRead = fTimeRead;
            // fTFBHit->Adc.hi = srcdigit->GetHighGainADC();
          }  // end of loop over digits in container
        }    // for ecal digits
      }      // if(digList)
    }        // end of loop over digit containers
  }          // end of if(event.Has...

  return true;
}

Bool_t ND::TLowLevelInfoModule::ProcessFirstEvent(ND::TND280Event&) {
  return true;
}

int ND::TLowLevelInfoModule::BarFromName(std::string name) {
  std::string match("Bar_");
  if (name.find(match) == name.npos) return -1;
  std::string ss = name.substr(name.find(match) + match.size());
  return atoi(ss.c_str());
}

int ND::TLowLevelInfoModule::LayerXFromName(std::string name) {
  std::string match("ScintX1_");
  if (name.find(match) == name.npos) return -1;
  std::string ss = name.substr(name.find(match) + match.size());
  return atoi(ss.c_str());
}

int ND::TLowLevelInfoModule::LayerYFromName(std::string name) {
  std::string match("ScintY1_");
  if (name.find(match) == name.npos) return -1;
  std::string ss = name.substr(name.find(match) + match.size());
  return atoi(ss.c_str());
}
ND::TLowLevelInfoModule::EDigitType ND::TLowLevelInfoModule::GetDigitType(
    const char* name) {
  std::string digit_str(name);
  EDigitType digit_type = kOtherDigits;
  if (digit_str.compare("ecal") == 0) {
    digit_type = kECalDigits;
  } else if (digit_str.compare("p0d") == 0) {
    digit_type = kP0DDigits;
  } else if (digit_str.compare("smrd") == 0) {
    digit_type = kSMRDDigits;
  } else if (digit_str.compare("ingrid") == 0) {
    digit_type = kINGRIDDigits;
  }
  return digit_type;
}
ND::TLowLevelInfoModule::EHitType ND::TLowLevelInfoModule::GetHitType(
    const char* name) {
  std::string hit_str(name);
  EHitType hit_type = kOtherHits;
  if (hit_str.find("ecal") != std::string::npos ||
      hit_str.find("barrel") != std::string::npos) {
    hit_type = kECalHits;
  } else if (hit_str.compare("p0d") == 0) {
    hit_type = kP0DHits;
  } else if (hit_str.compare("smrd") == 0) {
    hit_type = kSMRDHits;
  } else if (hit_str.compare("ingrid") == 0) {
    hit_type = kINGRIDHits;
  }
  return hit_type;
}