TBeamSummaryDataModule.cxx

Go to the documentation of this file.

#include "TBeamSummaryDataModule.hxx"

#include <TFile.h>
#include <TSystem.h>
#include <TBeamDataSingleton.hxx>

ClassImp(ND::TBeamSummaryDataModule::TBeamSummaryData);
ClassImp(ND::TBeamSummaryDataModule::TBeamSummaryData::TOtherData);


#include "../cvstags/TBeamSummaryDataModule.cxx"


ND::TBeamSummaryDataModule::TBeamSummaryDataModule(const char* name,
                                                   const char* title) {
  SetNameTitle(name, title);
  // Enable this module by default:
  fIsEnabled = kTRUE;
  fDescription =
      "Module incorporating Beam Summary Data as provided by the beamline "
      "group";
  fCVSTagName = CVSTAG;
  fCVSID = CVSID;
  fBeamSummaryData =
      new TClonesArray("ND::TBeamSummaryDataModule::TBeamSummaryData", 200);

  fTotalEvents = 0;
  fEventsWithNoBSD = 0;
}

ND::TBeamSummaryDataModule::~TBeamSummaryDataModule() {
  ND280Log("TBeamSummaryDataModule summary; total events processed = "
           << fTotalEvents
           << "; total events with no BSD information = " << fEventsWithNoBSD);
}

void ND::TBeamSummaryDataModule::InitializeModule() {}

void ND::TBeamSummaryDataModule::InitializeBranches() {
  // HEADER INFO
  fOutputTree->Branch("BeamSummaryDataStatus", &fBeamSummaryDataStatus,
                      "BeamSummaryDataStatus/I", fBufferSize);
  fOutputTree->Branch("ND280Spill", &fND280Spill, "ND280Spill/I", fBufferSize);
  fOutputTree->Branch("BeamSummaryData", &fBeamSummaryData, fBufferSize,
                      fSplitLevel);
  fOutputTree->GetBranch("BeamSummaryDataStatus")
      ->SetTitle(
          "  Flag : Beam Summary Data is available or not in the spill. 1 = "
          "BSD is available. 0 is not.");
  fOutputTree->GetBranch("ND280Spill")
      ->SetTitle("  ND280 Spill Number. 16 bit.");
}

void ND::TBeamSummaryDataModule::FillConfigTree(TTree* configTree){

  if(fFilledConfigTree){
    ND280NamedWarn("TBeamSummaryDataModule", "Module: " << this->GetName()
      << " has already written the config tree this run.");
  }
  configTree->Branch("TotalEvents", &fTotalEvents);
  configTree->Branch("EventsWithNoBSD", &fEventsWithNoBSD);

  TAnalysisModuleBase::FillConfigTree(configTree);
}

// finding spill and filling information //
bool ND::TBeamSummaryDataModule::FillTree(ND::TND280Event& event) {
  fBeamSummaryDataStatus = 0;
  fTotalEvents++;

  if (event.GetContext().IsMC()) return true;

  ND::TRawBeamData& fRawBeamData = ND::TBeamDataSingleton::Get();
  fBeamSummaryData->Clear();

  Int_t spill = event.GetHeader().GetSpillNumber();
  fND280Spill = spill;
  Int_t mcmTime = event.GetHeader().GetMCMSecond();
  Int_t trigger = event.GetHeader().GetTriggerBits();

  if (trigger != 1) {
    return true;
  }

  bool ret = fRawBeamData.GetSpill(spill, mcmTime, 1);

  if (ret == true && (mcmTime - fRawBeamData.GetTriggerTime(0)) >= 0) {
    fBeamSummaryDataStatus = 1;
    TBeamSummaryData* bsd = new ((*fBeamSummaryData)[0]) TBeamSummaryData;

    bsd->BeamRunNumber = fRawBeamData.GetBeamRunNumber();
    bsd->SpillNumber = fRawBeamData.GetSpillNumber();
    bsd->GPS1TriggerTime = fRawBeamData.GetTriggerTime(0);
    bsd->GPS1TriggerTimeNanoSecond = fRawBeamData.GetTriggerTimeNanoSecond(0);
    bsd->CT5ProtonsPerSpill = fRawBeamData.GetProtonsPerSpill(4);
    bsd->GoodSpillFlag = fRawBeamData.GetGoodSpillFlag();
    bsd->Horn1CurrentSum = fRawBeamData.GetHornCurrent(0);
    bsd->Horn2CurrentSum = fRawBeamData.GetHornCurrent(1);
    bsd->Horn3CurrentSum = fRawBeamData.GetHornCurrent(2);
    bsd->BSDVersion = fRawBeamData.GetBSDVersion();

    // We have to think about numbering spills. //
    for (int bunch_1 = 0; bunch_1 < 8; ++bunch_1) {
      bsd->CT5ProtonsPerBunch[bunch_1] =
          fRawBeamData.GetProtonsPerBunch(4, bunch_1 + 1);
      bsd->CT5BeamBunchTiming[bunch_1] =
          fRawBeamData.GetBeamBunchTiming(4, bunch_1 + 1);
      bsd->CT5BeamBunchFlag[bunch_1] =
          fRawBeamData.GetBeamBunchFlag(4, bunch_1 + 1);
    }

    // Using calculating the official values for Protons per spill
    // Also need to set this up for the proper variables.  Will
    // change to beamData variables once things are set up
    // there.  End user should use any variable with the name
    // starting Official rather than CT5
    int tmpct = -1;
    bsd->OfficialProtonsPerSpill =
        fRawBeamData.GetCTPOT(0);  // Using official POT for total POT per spill
    for (int whichct = 0; whichct < 5;
         ++whichct) {  // loop to find official CT number
      if (fRawBeamData.GetProtonsPerSpill(whichct) ==
          fRawBeamData.GetCTPOT(0)) {
        bsd->OfficialCTNumber = whichct + 1;
        tmpct = whichct;  // variable to make life in the next few lines easier
      }
    }
    bsd->OfficialBeamFlag = fRawBeamData.GetBeamFlag(tmpct);
    for (int bunch_1 = 0; bunch_1 < 8; ++bunch_1) {
      bsd->OfficialProtonsPerBunch[bunch_1] =
          fRawBeamData.GetCTPOT(bunch_1 + 1);  // Get the official POT/bunch
      bsd->OfficialBeamBunchTiming[bunch_1] =
          fRawBeamData.GetBeamBunchTiming(tmpct, bunch_1 + 1);
      bsd->OfficialBeamBunchFlag[bunch_1] =
          fRawBeamData.GetBeamBunchFlag(tmpct, bunch_1 + 1);
    }

    bsd->OtherData.SpillNumber = fRawBeamData.GetSpillNumber();
    bsd->OtherData.MRRunNumber = fRawBeamData.GetMRRunNumber();
    bsd->OtherData.BeamRunNumber = fRawBeamData.GetBeamRunNumber();
    // bsd->OtherData.MRShotNumber = fRawBeamData.GetMRShotNumber();

    bsd->OtherData.SpillFlag = fRawBeamData.GetSpillFlag();
    bsd->OtherData.TriggerFlag = fRawBeamData.GetTriggerFlag();
    bsd->OtherData.GoodGPSFlag = fRawBeamData.GetGoodGPSFlag();
    bsd->OtherData.GoodSpillFlag = fRawBeamData.GetGoodSpillFlag();

    bsd->OtherData.MagSetID = fRawBeamData.GetMagSetID();
    bsd->OtherData.RunType = fRawBeamData.GetRunType();
    // bsd->OtherData.MidasEvent = fRawBeamData.GetMidasEvent();

    for (int iGPS = 0; iGPS < 3; ++iGPS) {
      bsd->OtherData.TriggerTime[iGPS] = fRawBeamData.GetTriggerTime(iGPS);
      bsd->OtherData.TriggerTimeNanoSecond[iGPS] =
          fRawBeamData.GetTriggerTimeNanoSecond(iGPS);
    }
    bsd->OtherData.GPSStatus[0] = fRawBeamData.GetGPSStatus(0);
    bsd->OtherData.GPSStatus[1] = fRawBeamData.GetGPSStatus(1);

    for (int ct = 0; ct < 5; ++ct) {
      bsd->OtherData.BeamTiming[ct] = fRawBeamData.GetBeamTiming(ct);
      bsd->OtherData.BeamFlag[ct] = fRawBeamData.GetBeamFlag(ct);
      bsd->OtherData.ProtonsPerSpill[ct] = fRawBeamData.GetProtonsPerSpill(ct);

      for (int bunch_2 = 0; bunch_2 < 9; ++bunch_2) {
        bsd->OtherData.ProtonsPerBunch[ct][bunch_2] =
            fRawBeamData.GetProtonsPerBunch(ct, bunch_2);
        bsd->OtherData.BeamBunchTiming[ct][bunch_2] =
            fRawBeamData.GetBeamBunchTiming(ct, bunch_2);
        bsd->OtherData.BeamBunchFlag[ct][bunch_2] =
            fRawBeamData.GetBeamBunchFlag(ct, bunch_2);
      }
    }

    for (int ihorn = 0; ihorn < 3; ++ihorn) {
      bsd->OtherData.HornCurrent[ihorn] = fRawBeamData.GetHornCurrent(ihorn);

      for (int ch = 0; ch < 5; ++ch) {
        bsd->OtherData.HornBusBarCurrent[ihorn][ch] =
            fRawBeamData.GetHornBusBarCurrent(ihorn, ch);
      }
    }
    for (int dir = 0; dir < 2; ++dir) {
      bsd->OtherData.BeamDirectionOnTarget[dir] =
          fRawBeamData.GetBeamDirectionOnTarget(dir);
      bsd->OtherData.BeamSizeOnTarget[dir] =
          fRawBeamData.GetBeamSizeOnTarget(dir);
    }

    bsd->OtherData.MumonSiTotalQ = fRawBeamData.GetMumonSiTotalQ();
    bsd->OtherData.MumonSiPeak = fRawBeamData.GetMumonSiPeak();
    bsd->OtherData.MumonSiX = fRawBeamData.GetMumonSiX();
    bsd->OtherData.MumonSiwX = fRawBeamData.GetMumonSiwX();
    bsd->OtherData.MumonSiY = fRawBeamData.GetMumonSiY();
    bsd->OtherData.MumonSiwY = fRawBeamData.GetMumonSiwY();

    bsd->OtherData.MumonICTotalQ = fRawBeamData.GetMumonICTotalQ();
    bsd->OtherData.MumonICPeak = fRawBeamData.GetMumonICPeak();
    bsd->OtherData.MumonICX = fRawBeamData.GetMumonICX();
    bsd->OtherData.MumonICwX = fRawBeamData.GetMumonICwX();
    bsd->OtherData.MumonICY = fRawBeamData.GetMumonICY();
    bsd->OtherData.MumonICwY = fRawBeamData.GetMumonICwY();

    bsd->OtherData.OTRX = fRawBeamData.GetOTRX();
    bsd->OtherData.OTRY = fRawBeamData.GetOTRY();
    bsd->OtherData.OTRwX = fRawBeamData.GetOTRwX();
    bsd->OtherData.OTRwY = fRawBeamData.GetOTRwY();
    bsd->OtherData.OTRXError = fRawBeamData.GetOTRXError();
    bsd->OtherData.OTRYError = fRawBeamData.GetOTRYError();
    bsd->OtherData.OTRwXError = fRawBeamData.GetOTRwXError();
    bsd->OtherData.OTRwYError = fRawBeamData.GetOTRwYError();
    bsd->OtherData.OTRLightYield = fRawBeamData.GetOTRLightYield();
  }

  if (fBeamSummaryDataStatus == 0) {
    fBeamSummaryDataStatus = -1;
    // throw ND::ENoBeamSummaryData(); // temporarily disable throwing
    // exception; want to be able to process all data.
    fEventsWithNoBSD++;
  }
  return true;
}

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

Bool_t ND::TBeamSummaryDataModule::Configure(std::string& option) {
  SetEnabled(kFALSE);
  /*
     std::string filenameOrDirectory = option;

     void* dirp = gSystem->OpenDirectory(filenameOrDirectory.c_str());

     if(dirp) {
     const char* fname = 0;
     while((fname = gSystem->GetDirEntry(dirp))) {
     std::string filePath = Form("%s/%s", filenameOrDirectory.c_str(), fname);
     TFile *f = new TFile(filePath.c_str());
     if(f && !f->IsZombie() && f->Get("bsd")) {
     fBSDTree->Add(filePath.c_str());
     }
     delete f;
     }
     }
     else {
     TFile *f = new TFile(filenameOrDirectory.c_str());
     if(f && !f->IsZombie() && f->Get("bsd")) {
     fBSDTree->Add(filenameOrDirectory.c_str());;
     }
     delete f;
     }
     */
  return true;
}

ND::TBeamSummaryDataModule::TBeamSummaryData::~TBeamSummaryData() {}
ND::TBeamSummaryDataModule::TBeamSummaryData::TOtherData::~TOtherData() {}