OfflineROOTFile.cc

Go to the documentation of this file.

#include <fwk/CentralConfig.h>

#include <utl/ErrorLogger.h>
#include <utl/SaveCurrentTDirectory.h>
#include <utl/Branch.h>

#include <evt/Event.h>

#include <io/Event_ROOT.h>
#include <io/Config_ROOT.h>
#include <io/Eye_ROOT.h>
#include <io/Telescope_ROOT.h>
#include <io/PMTSimData_ROOT.h>
#include <io/PixelSimData_ROOT.h>
#include <io/Pixel_ROOT.h>
#include <io/ShowerSimData_ROOT.h>
#include <io/PMTSimData_ROOT.h>
#include <io/StationSimData_ROOT.h>
#include <io/Station_ROOT.h>

#include <io/OfflineROOTFile.h>

#include <AugerEvent.h>

#include <TTree.h>
#include <TBranch.h>
#include <TFile.h>
#include <TDataMember.h>
#include <TList.h>
#include <TStreamerInfo.h>

#include <fstream>

using namespace io;
using namespace std;
using evt::Event;


const std::string OfflineROOTFile::kOfflineTreeName = "AugerOffline";
const std::string OfflineROOTFile::kOfflineBranchName = "Event";
const std::string OfflineROOTFile::kConfigBranchName = "Config";
const StreamerSwitch OfflineROOTFile::fgDefaultSwitch;


OfflineROOTFile::OfflineROOTFile(const std::string& filename, const Mode mode,
                                 utl::Branch* const /*branch*/,
                                 const io::StreamerSwitch& streamerSwitch) :
  VROOTFile(filename, mode),
  fStreamerSwitch(streamerSwitch)
{
  // Note that each ROOT file has exactly 1 configuration object
  // associated with it.  Configuration is currently a once-per-run
  // concept.  A single run producing multuple OfflineROOTFiles will
  // write the same configuration into each one.  Multiple runs
  // producing 1 OutputROOTFile each will, of course, write
  // a different configuration into each file.

  fConfig = new Config_ROOT();
}


void
OfflineROOTFile::Open(const std::string& filename, const Mode mode,
                      utl::Branch* const branch)
{
  // If requested, dump the configuration info found
  // in the event into a file

  if (branch && *branch) {

    utl::Branch dumpConfigB = branch->GetChild("DumpConfig");
    if (dumpConfigB) {
      string dumpFileName;
      dumpConfigB.GetData(dumpFileName);
      if (fConfigOut) {
        fConfigOut->close();
        delete fConfigOut;
      }
      fConfigOut = new ofstream(dumpFileName.c_str());
      ostringstream inf;
      inf << "Dumping previous Offline config into output: " << dumpFileName;
      INFO(inf);
    }
  }

  VROOTFile::Open(filename, mode);
}


OfflineROOTFile::~OfflineROOTFile()
{
  if (fConfigOut) {
    fConfigOut->close();
    delete fConfigOut;
    fConfigOut = nullptr;
  }

  delete fCurEvent;
  delete fConfig;
}


void
OfflineROOTFile::Close()
{
  if (fConfigOut) {
    fConfigOut->close();
    delete fConfigOut;
    fConfigOut = nullptr;
  }

  VROOTFile::Close();
}


Status
OfflineROOTFile::GetEventBranch()
{
  // Create new streaming object (in eRead mode it stays NULL)
  if (fMode != eRead) {
    delete fCurEvent;
    fCurEvent = new Event_ROOT();
  }

  // Get existing TTree from file, if there should be one
  if ((fMode == eRead || fMode == eAppend)) {

    if (GetTree(kOfflineTreeName) == -1) {
      ERROR ("Could Not Read because Tree is NULL");
      return eFail;
    }

    // Get TBranch from TTree, or create new TBranch if needed
    fBranch = fTree->GetBranch(kOfflineBranchName.c_str());
    fBranch->SetAddress(&fCurEvent);

  } else { // fMode == eWrite

    const Int_t persistent = 4;

    // Set streamers on or off according to fStreamerSwitch
    if (!fStreamerSwitch.GetRaw())
      Event_ROOT::Class()->GetDataMember("fRawEvent")->SetBit(persistent, false);

    if (!fStreamerSwitch.GetFDRaw())
      AugerEvent::Class()->GetDataMember("Eyes")->SetBit(persistent, false);

    // this switch removes a bunch of data ONLY used during FD simulation
    if (!fStreamerSwitch.GetFDSimPhotonTraces()) {
      Telescope_ROOT::Class()->GetDataMember("fChannels")->SetBit(persistent, false);
      Pixel_ROOT::Class()->GetDataMember("fSimData")->SetBit(persistent, false);
      ShowerSimData_ROOT::Class()->GetDataMember("fFluorescencePhotons")->SetBit(persistent, false);
      ShowerSimData_ROOT::Class()->GetDataMember("fCherenkovPhotons")->SetBit(persistent, false);
      ShowerSimData_ROOT::Class()->GetDataMember("fCherenkovBeamPhotons")->SetBit(persistent, false);
      ShowerSimData_ROOT::Class()->GetDataMember("fCherenkovBeamProductionPhotons")->SetBit(persistent, false);
    }

    if (!fStreamerSwitch.GetFDSimTelescope())
      Telescope_ROOT::Class()->GetDataMember("fSim")->SetBit(persistent, false);
    if (!fStreamerSwitch.GetSDSimPETimeDistribution())
      PMTSimData_ROOT::Class()->GetDataMember("fPETimeDistribution")->SetBit(persistent, false);
    if (!fStreamerSwitch.GetSDSimPMTBaseTimeDistribution())
      PMTSimData_ROOT::Class()->GetDataMember("fBaseSignals")->SetBit(persistent, false);
    if (!fStreamerSwitch.GetSDSimPMTFilterTimeDistribution())
      PMTSimData_ROOT::Class()->GetDataMember("fFilterSignals")->SetBit(persistent, false);
    if (!fStreamerSwitch.GetSDSimTankParticles())
      StationSimData_ROOT::Class()->GetDataMember("fParticles")->SetBit(persistent, false);

    const utl::SaveCurrentTDirectory save;
    fFile->cd();
    delete fTree;
    fTree = new TTree(kOfflineTreeName.c_str(), "Auger Offline Tree");

    fBranch = fTree->Branch(kOfflineBranchName.c_str(), Event_ROOT::Class_Name(), &fCurEvent);
    fConfigBranch = fTree->Branch(kConfigBranchName.c_str(), Config_ROOT::Class_Name(), &fConfig);
    fConfig->fConfigString = fwk::CentralConfig::GetInstance()->GetConfig();
  }

  if (!fBranch) {
    ERROR("Could Not Read branch");
    return eFail;
  }

  return eSuccess;
}


void
OfflineROOTFile::Write(const evt::Event& event)
{
  if (!fTree && GetEventBranch() == eFail)
    throw utl::IOFailureException("IO error while writing");

  *fCurEvent = event;
  fTree->Fill();
}


Status
OfflineROOTFile::Read(evt::Event& event)
{
  if (!fTree && GetEventBranch() == eFail)
    return eFail;

  if (fCurEventNo == (unsigned int)GetNEvents())
    return eEOF;

  fBranch->GetEntry(fCurEventNo++);
  *fCurEvent >> event;

  // Write out configuration (if requested)
  if (fConfigOut)
    *fConfigOut << GetConfig() << endl;

  return eSuccess;
}


Status
OfflineROOTFile::FindEvent(const unsigned int /*evNo*/)
{
  ERROR("OfflineROOTFile::FindEvent not implemented");
  return eFail;
}


Status
OfflineROOTFile::GotoPosition(const unsigned int evNo)
{
  if (evNo > (unsigned int)(GetNEvents())) {
    ERROR("Trying to move past End of File");
    return eEOF;
  }

  fCurEventNo = evNo;
  return eSuccess;
}


int
OfflineROOTFile::GetNEvents()
{
  if (!fTree)
    GetEventBranch();
  if (!fTree)
    return 0;
  return fTree->GetEntries();
}


string
OfflineROOTFile::GetConfig()
{
  if (GetTree(kOfflineTreeName) == -1) {
    ERROR("Could Not Read because Tree is NULL");
    exit(EXIT_FAILURE);
  }

  fConfigBranch = fTree->GetBranch(kConfigBranchName.c_str());
  if (!fConfigBranch) {
    INFO("Could not find a configuration branch. "
         "Is it possible this event was written with Offline version 1.3 or older?");
    return "No configuration data available.";
  }

  fConfigBranch->SetAddress(&fConfig);
  fConfigBranch->GetEntry();
  return fConfig->fConfigString;
}