RadioFileAERAroot.cc

Go to the documentation of this file.

#include <io/RadioFileAERAroot.h>

#include <utl/ErrorLogger.h>
#include <utl/AugerException.h>

#include <config.h>

#include <evt/Event.h>
#include <evt/Header.h>
#include <revt/REvent.h>
#include <revt/Station.h>
#include <revt/Channel.h>
#include <revt/ChannelRecData.h>
#include <revt/ChannelRRecDataQuantities.h>
#include <revt/Header.h>
#include <revt/StationTriggerData.h>
#include <revt/StationGPSData.h>
#include <revt/EventTrigger.h>
#include <revt/StationHeader.h>

#include <utl/Trace.h>
#include <utl/TimeStamp.h>
#include <utl/UTCDateTime.h>
#include <utl/LeapSeconds.h>

#include <det/Detector.h>
#include <rdet/RDetector.h>
#include <rdet/Station.h>
#include <rdet/Channel.h>

#include <TKey.h>
#include <TFile.h>
#include <TTree.h>

#include <RadioFileIO.h>
#include <TBranch.h>
#include <cstddef>
#include <cstdlib>
#include <iostream>
#include <sstream>
#include <map>
#include <vector>

//#include <amsg.h>
//#include <llog.h>

using namespace std;
using namespace utl;
using namespace io;
using namespace evt;
using namespace revt;
//using namespace aera;


void
RadioFileAERAroot::Open(const std::string& filename, const Mode mode, utl::Branch* const b)
{
  Close();

  VROOTFile::Open(filename, mode, b);

  if (mode == eRead) {
    fRadioFileIO = new RadioFileIO();

    if (!fFile->Get("AERAIOTree")) {
      throw utl::IOFailureException("Could not find the AERAIOTree inside the input file. "
                                    "Please check if the correct InputFileType is set or "
                                    "if the file is corrupt or empty!");
    }

    fIOLibTree = (TTree*)fFile->Get("AERAIOTree");
    fIObranch = fIOLibTree->GetBranch("AERAIO");
    fIObranch->SetAddress(&fRadioFileIO);
    fSourceFileName = filename;
  }

  if (mode == eNew)
    fRadioFileIO = new RadioFileIO();

  /*VROOTFile::Open(filename, mode);

  if (!fFile)
    throw utl::IOFailureException("Cannot open file for RadioFileAERAroot io");

  if (fFile->IsZombie())
    throw utl::IOFailureException("Radio file in zombie io state");

  fCurrentEvent = 0;

  if (fMode == eWrite || fMode == eNew || fMode == eAppend)
    fFile->SetCompressionLevel(io::kDefaultCompressionLevel);*/
}


void
RadioFileAERAroot::Close()
{
  if (!fFile)
    return;

  //closeAeraEventFile();
  VROOTFile::Close();
  fHasFileOpen = false;

  fIOLibTree = nullptr;
  fIObranch = nullptr;

  delete fRadioFileIO;
  fRadioFileIO = nullptr;

  delete fFile;
  fFile = nullptr;

  fCurrentEvent = -1;
}


void
RadioFileAERAroot::Print()
{
  fFile->Print();
}


void
RadioFileAERAroot::Write(const evt::Event& event)
{
  const REvent& revent = event.GetREvent();

  // check if there is actually an event we can export
  if (revent.GetAERARootIoEventId() < 0) {
    throw utl::IOFailureException("Could not export RadioAERAroot event, "
                                  "did you use another file type than RadioAERAroot in the EventFileReader?");
  }

  // fixme TH: This is a temporary solution. Write() method should have direct access to last-read event, e.g. via a static member variable.
  fRadioFileIO->WriteSelectedEventsOffline(revent.GetAERARootIoSourceFileName(), fFile, revent.GetAERARootIoEventId());

  //std::map<short, std::map<short, std::vector<short> > >  traces;
  //for(REvent::ConstStationIterator iS = revent.StationsBegin(); iS != revent.StationsEnd(); ++iS) {
  //  std::map<short, std::vector<short> > tmpChannels;
  //  for(revt::Station::ConstChannelIterator iC = iS->ChannelsBegin(); iC != iS->ChannelsEnd(); ++iC) {
  //    std::vector<short> tmpTrace;
  //    const ChannelTimeSeries& trace = iC->GetChannelTimeSeries();
  //    tmpTrace.reserve(trace.GetSize());
  //    for(int i = 0; i < trace.GetSize(); ++i) {
  //      tmpTrace.push_back(trace[i]);
  //    }
  //    short channelId = iC->GetId();
  //    tmpChannels.insert(std::pair<short, std::vector<short> > (channelId - 1, tmpTrace));
  //  }
  //  short stationId = iS->GetId();
  //  traces.insert(std::pair<short, std::map<short, std::vector<short> > > (stationId, tmpChannels));
  //}
  //fRadioFileIO->WriteSelectedEventsOfflineWithTrace(revent.GetAERARootIoSourceFileName(),
  //                                                    fFile, revent.GetAERARootIoEventId(), traces);
}


Status
RadioFileAERAroot::Read(evt::Event& event)
{
  ++fCountEvent;

  if (fCountEvent == fIOLibTree->GetEntries()) {  // reached end of file
    fIsFirstevent = true;
    return eEOF;
  }

  if (event.HasREvent())
    WARNING("Event not cleared - has REvent");
  else
    event.MakeREvent();

  REvent& revent = event.GetREvent();

  // save meta data for later event export
  revent.SetAERARootIoSourceFileName(fSourceFileName);
  revent.SetAERARootIoEventId(fCountEvent);

  fIOLibTree->GetEntry(fCountEvent);

  //if (fRadioFileIO->getAeraRadioFileIOStatus() == 0 || fRadioFileIO->getAeraRadioFileEvent()->getAeraEventStatus() == 0) {
  // WARNING("Event skipped! Header length not correct or event corrupt.");
  //  return eSkipEvent;
  //}

  if (fIOLibTree->GetEntry(fCountEvent) == 0) {
    if (fRadioFileIO->getAeraRadioFileIOStatus() == 0 || fRadioFileIO->getAeraRadioFileEvent()->getAeraEventStatus() == 0) {
      WARNING("Event skipped! Header length not correct or event corrupt.");
      return eSkipEvent;
    }
  } else {
    if (fRadioFileIO->getAeraRadioFileEvent()->getAeraEventStatus() == 0) {
      WARNING("Event skipped! Header length not correct or event corrupt.");
      return eSkipEvent;
    }
  }

  auto aEvent = *fRadioFileIO->getAeraRadioFileEvent();

  const int run_id = aEvent.getAeraEventRunId();
  const int event_id = aEvent.getAeraEventEventId();

  revent.GetHeader().SetId(aEvent.getAeraEventEventId());
  //~ revent.GetHeader().SetEventNumber( aEvent.getAeraEventRunningEventId() );
  revent.GetHeader().SetFileId(aEvent.getAeraEventFileId());
  revent.GetHeader().SetNumberOfStations(aEvent.getAeraEventLsCount());
  revent.GetHeader().SetEventVersion(aEvent.getAeraEventEventVersion());

  revent.GetHeader().SetRunNumber(run_id);
  ostringstream id;
  id << "revt_" << run_id << "_" << event_id;

  event.GetHeader().SetId(id.str()); // string ID for Event

  unsigned int ts_s = aEvent.getAeraEventSeconds();
  const unsigned int ts_ns = aEvent.getAeraEventNanoSeconds();

  utl::TimeStamp ts;
  try {
    ts.SetGPSTime(ts_s, ts_ns);
  } catch (OutOfBoundException&) {
    WARNING("Event skipped! TimeStamp was not filled correctly.");
    return eSkipEvent;
  }

  det::Detector::GetInstance().Update(ts);
  event.GetHeader().SetTime(ts);
  revent.GetHeader().SetTime(ts);
  /*                                            ///////////////////// Maybe station.status as additional check?
  if (!getAeraEventFirstLsData()) {
    WARNING("No Local station data found");
    return eFail;
  }
  */
  if (revent.HasTrigger())
    WARNING("Warning overwrites Event Trigger information");
  else
    revent.MakeTrigger();

  if (aEvent.getAeraEventStatus() == 2) {
    WARNING("Event skipped! Event does not have an active station.");
    return eSkipEvent;
  }

  //int triggersource =0;
  int triggersourceIsAevb = 1;
  int triggersourceIsSelf = 0;
  int triggersourceIsCalib = 0;
  int triggersourceIsScint = 0;
  int triggersourceIsSD = 0;
  int triggersourceIsGui = 0;
  int triggersourceIsFD = 0;
  int triggersourceIsHEAT = 0;
  int triggersourceIsAERAlet = 0;
  int triggersourceIsAIRPLANE = 0;
  int triggersourceIsPeriodic = 0;
  int triggersourceIsPassThrough = 0;

  for (int i = 0; i < aEvent.getAeraEventLsCount(); ++i) {
    auto aStation = *aEvent.getAeraEventStation(i);
    if (aStation.getAeraStationTriggerIsAevb() != 1) {
      // triggersource is only set if not unknown (=0)
      if (!triggersourceIsSelf)
        triggersourceIsSelf = aStation.getAeraStationTriggerIsSelf();
      if (!triggersourceIsCalib)
        triggersourceIsCalib = aStation.getAeraStationTriggerIsCalibration();
      if (!triggersourceIsScint)
        triggersourceIsScint = aStation.getAeraStationTriggerIsScintillator();
      if (!triggersourceIsSD)
        triggersourceIsSD = aStation.getAeraStationTriggerIsSD();
      if (!triggersourceIsGui)
        triggersourceIsGui = aStation.getAeraStationTriggerIsGUI();
      if (!triggersourceIsFD)
        triggersourceIsFD = aStation.getAeraStationTriggerIsFD();
      if (!triggersourceIsHEAT)
        triggersourceIsHEAT = aStation.getAeraStationTriggerIsHEAT();
      if (!triggersourceIsAERAlet)
        triggersourceIsAERAlet = aStation.getAeraStationTriggerIsAERAlet();
      if (!triggersourceIsAIRPLANE)
        triggersourceIsAIRPLANE = aStation.getAeraStationTriggerIsAirplane();
      if (!triggersourceIsPeriodic)
        triggersourceIsPeriodic = aStation.getAeraStationTriggerIsPeriodic();
      if (!triggersourceIsPassThrough)
        triggersourceIsPassThrough = aStation.getAeraStationTriggerIsPassThrough();
      revent.GetTrigger().SetBitPattern(aStation.getAeraStationTriggerFlag());
      //triggersourceIsAevb = 0;
      //break;
    }
  }

  if (triggersourceIsSelf || triggersourceIsCalib || triggersourceIsScint || triggersourceIsSD ||
      triggersourceIsGui || triggersourceIsFD || triggersourceIsHEAT || triggersourceIsAERAlet ||
      triggersourceIsAIRPLANE || triggersourceIsPeriodic || triggersourceIsPassThrough)
    triggersourceIsAevb = 0;

  if (triggersourceIsSelf == 1) {
    revent.GetTrigger().SetSelfTrigger(true);
    WARNING("Event IsSelf");
  }
  if (triggersourceIsCalib == 1) {
    revent.GetTrigger().SetCalibrationTrigger(true);
    WARNING("Event IsCalib");
  }
  if (triggersourceIsScint == 1) {
    revent.GetTrigger().SetScintillatorTrigger(true);
    WARNING("Event IsScint");
  }
  if (triggersourceIsSD == 1) {
    revent.GetTrigger().SetSDTrigger(true);
    WARNING("Event IsSD");
  }
  if (triggersourceIsGui == 1) {
    revent.GetTrigger().SetGUITrigger(true);
    WARNING("Event IsGUI");
  }
  if (triggersourceIsFD == 1) {
    revent.GetTrigger().SetFDTrigger(true);
    WARNING("Event IsFD");
  }
  if (triggersourceIsHEAT == 1) {
    revent.GetTrigger().SetHEATTrigger(true);
    WARNING("Event IsHEAT");
  }
  if (triggersourceIsAERAlet == 1) {
    revent.GetTrigger().SetAERAletTrigger(true);
    WARNING("Event IsAERALET");
  }
  if (triggersourceIsAIRPLANE == 1) {
    revent.GetTrigger().SetAIRPLANETrigger(true);
    WARNING("Event IsAIRPLANE");
  }
  if (triggersourceIsPeriodic == 1) {
    revent.GetTrigger().SetPeriodicTrigger(true);
    WARNING("Event IsPeriodic");
  }
  if (triggersourceIsPassThrough == 1) {
    revent.GetTrigger().SetPassThroughTrigger(true);
    WARNING("Event IsPassThrough");
  }
  if (triggersourceIsSD == 1 || triggersourceIsGui == 1 || triggersourceIsFD == 1 ||
      triggersourceIsHEAT == 1 || triggersourceIsAERAlet == 1 || triggersourceIsAIRPLANE == 1) {
    revent.GetTrigger().SetExternalTrigger(true);
  }
  if (triggersourceIsAevb == 1) {
    WARNING("Event skipped! No known trigger source found.");
    return eSkipEvent;
  }


  for (int i = 0; i < aEvent.getAeraEventLsCount(); ++i) { //LS station loop

    auto aStation = *aEvent.getAeraEventStation(i);

    const int station_id = aStation.getAeraStationLsID();
    if (aStation.getAeraStationTriggerIsAevb() == 1 ||
        aStation.getAeraStationTracelength() == 0)
      continue;  // skip station if aevb Event or no channel data

    ostringstream stationname;

    if (station_id > 200 && station_id < 210)
      stationname << 'M' << (station_id - 200);
    else
      stationname << "AERA_" << station_id;
    try {
      if (revent.HasStation(stationname.str())) {
        const string msg = "Warning overwrites station information";
        WARNING(msg);
      } else
        revent.MakeStation(stationname.str());

      revt::Station& station = revent.GetStationByName(stationname.str());
      const rdet::Station& detstation = det::Detector::GetInstance().GetRDetector().GetStation(station); //Get the RDetector::Station from revt::Station
      if (station.HasTriggerData()) {
        string msg = "Overwriting station trigger information";
        WARNING(msg);
      } else
        station.MakeTriggerData();

      triggersourceIsSelf = aStation.getAeraStationTriggerIsSelf();
      triggersourceIsCalib = aStation.getAeraStationTriggerIsCalibration();
      triggersourceIsScint = aStation.getAeraStationTriggerIsScintillator();
      triggersourceIsSD = aStation.getAeraStationTriggerIsSD();
      triggersourceIsGui = aStation.getAeraStationTriggerIsGUI();
      triggersourceIsFD = aStation.getAeraStationTriggerIsFD();
      triggersourceIsHEAT = aStation.getAeraStationTriggerIsHEAT();
      triggersourceIsAERAlet = aStation.getAeraStationTriggerIsAERAlet();
      triggersourceIsAIRPLANE = aStation.getAeraStationTriggerIsAirplane();
      triggersourceIsPeriodic = aStation.getAeraStationTriggerIsPeriodic();
      triggersourceIsPassThrough = aStation.getAeraStationTriggerIsPassThrough();
      triggersourceIsAevb = aStation.getAeraStationTriggerIsAevb();

      if (triggersourceIsScint)
        station.GetTriggerData().SetTriggerSource(StationTriggerData::eScint);
      else if (triggersourceIsSelf)
        station.GetTriggerData().SetTriggerSource(StationTriggerData::eSelf);
      else if (triggersourceIsCalib)
        station.GetTriggerData().SetTriggerSource(StationTriggerData::eCalib);
      else if (triggersourceIsSD)
        station.GetTriggerData().SetTriggerSource(StationTriggerData::eSD);
      else if (triggersourceIsGui)
        station.GetTriggerData().SetTriggerSource(StationTriggerData::eGUI);
      else if (triggersourceIsFD)
        station.GetTriggerData().SetTriggerSource(StationTriggerData::eFD);
      else if (triggersourceIsHEAT)
        station.GetTriggerData().SetTriggerSource(StationTriggerData::eHEAT);
      else if (triggersourceIsAERAlet)
        station.GetTriggerData().SetTriggerSource(StationTriggerData::eAERAlet);
      else if (triggersourceIsAIRPLANE)
        station.GetTriggerData().SetTriggerSource(StationTriggerData::eAIRPLANE);
      else if (triggersourceIsPeriodic)
        station.GetTriggerData().SetTriggerSource(StationTriggerData::ePeriodic);
      else if (triggersourceIsPassThrough)
        station.GetTriggerData().SetTriggerSource(StationTriggerData::ePassThrough);
      else if (triggersourceIsSD || triggersourceIsGui || triggersourceIsFD || triggersourceIsHEAT ||
               triggersourceIsAERAlet || triggersourceIsAIRPLANE)
        station.GetTriggerData().SetTriggerSource(StationTriggerData::eExternal);
      else if (triggersourceIsAevb)
        WARNING("Trigger source unknown on station level.");

      station.GetTriggerData().SetOffset(aStation.getAeraStationTriggerPos());
      if (station.HasGPSData())
        WARNING("Warning overwrites station GPS information");
      else
        station.MakeGPSData();

      StationGPSData& gps = station.GetGPSData();

      if (station.HasStationHeader()) {
        const string msg ="Warning overwrites station header" ;
        WARNING(msg);
      } else
        station.MakeStationHeader();
      if (aStation.getAeraStationHWType() == 1)
        station.GetStationHeader().SetHardwareType(StationHeader::eNL);
      else if (aStation.getAeraStationHWType() == 2)
        station.GetStationHeader().SetHardwareType(StationHeader::eFR);
      else if (aStation.getAeraStationHWType() == 3)
        station.GetStationHeader().SetHardwareType(StationHeader::eDE);
      else {
        ostringstream msg;
        msg << " Unknown Hardware type ::   getAeraEvbHardwareType() = "
            << aStation.getAeraStationHWType() << "\n"
               " Event ID is << " << id.str() << " File is " << fRadioFileIO->getAeraRadioFileIOFileId() << "\n"
               " Skip to next event.";
        ERROR(msg);
        break;  
      }
      station.GetStationHeader().SetHardwareVersion(aStation.getAeraStationHWVersion());

      const double samplingfreq =
        double(aStation.getAeraStationSamplingFreq()) * utl::megahertz;
      ts_s = aStation.getAeraStationSeconds();

      utl::TimeStamp stationts;
      try {
        stationts.SetGPSTime(ts_s, aStation.getAeraStationNanoseconds());
        gps.SetSecond(ts_s); // ? Why was ts_gps_s
        gps.SetCorrectedNanosecond(aStation.getAeraStationNanoseconds()); // corrected from what ?
      } catch (utl::OutOfBoundException& e) {
        WARNING("Event skipped! TimeStamp was not filled correctly.");
        return eSkipEvent;
      }
      double pretrigtime = 0;

      if (aStation.getAeraStationHWType() == 1) {
        if ((aStation.getAeraStationHWVersion() < 7 &&
             aStation.getAeraStationHWVersion() > 0) ||
             (aEvent.getAeraEventRunId() > 200000 &&
              aEvent.getAeraEventRunId() < 200300)) {  // New NL data
          const unsigned int s = aStation.getAeraStationMessagePreTriggerWindow();
          const unsigned int t = aStation.getAeraStationMessageCoincidenceWindow();
          pretrigtime = (s + t) / samplingfreq;
        } else if (aStation.getAeraStationHWVersion() >= 7) {
          const unsigned short coinc = aStation.getAeraStationMessageV2PPSControl(6);
          union {
            unsigned char uc[2];
            unsigned short pre;
          };
          for (unsigned int j = 0; j < 2; ++j)
            uc[j] = aStation.getAeraStationMessageV2PPSWindows(j);
          pretrigtime = (pre + coinc) / samplingfreq;
        }
      } else
        pretrigtime = double(aStation.getAeraStationTriggerPos()) / samplingfreq;
      utl::TimeInterval pretrig(pretrigtime);
      try {
        station.SetRawTraceStartTime(stationts-pretrig);
      } catch (utl::OutOfBoundException&) {
        WARNING("Event skipped! TimeStamp was not filled correctly.");
        return eSkipEvent;
      }

      // read temperature from additional station info, available for NL stations from LS version 3 (last 4 chars of additional info)
      if (aStation.getAeraStationHWType() == 1 &&
          aStation.getAeraStationVersion() >= 3) {
        union {
          unsigned char uc[4];
          float addTemp;
        };
        for (int k = 36; k < 40; ++k)
          uc[k - 36] = aStation.getAeraStationMessageV2PPSGPS(k);
        station.SetHWTemperature(addTemp);
      } else {
        const float AddTempInt = aStation.getAeraStationGerTemperatureInt();
        const float AddTempExt = aStation.getAeraStationGerTemperatureExt();
        station.SetHWTemperatureInt(AddTempInt + 273.15);
        station.SetHWTemperatureExt(AddTempExt + 273.15);
      }

      // Need additional check for new NL HW type! e.g. sd200272   -> 676 ok, other events: (nl) /4?
      const int numberofsamples = aStation.getAeraStationTracelength();

      unsigned int thresh = 0;  // UINT16 in RadioFileAERA
      ostringstream info;
      for (int ch_id = 1; ch_id <= detstation.GetNChannels(); ++ch_id) {
        info.str("");
        revt::Channel& chan = station.GetChannel(ch_id);
        // If Channel is not present in data, it will be set as inactive;
        if ((aStation.getAeraStationChannelMask() & (1 << (ch_id - 1))) == 0) {
          chan.SetNotActive();
          continue;
        }
        chan.SetActive();
        revt::ChannelADCTimeSeries& thistrace = chan.GetChannelADCTimeSeries();
        if (aStation.getAeraStationHWType() == 3 ||
            aStation.getAeraStationHWType() == 1) {

          thistrace.SetBinning(1. / samplingfreq);

          if (aStation.getAeraStationTracelength() == 0) {
            info.str("");
            info << " No data in channel: " << ch_id << ". "
                    "Channel will be marked as not active.";
            WARNING(info);
            chan.SetNotActive();
            continue;
          }

          // Prevent stations with multiplicity greater than 1 to keep filling traces
          if (thistrace.GetSize() != 0) {
            info.str("");
            info << "Channel " << ch_id
                 << "already exsists, skipping.";
            WARNING(info);
            continue;
          }
          for (int ii = 0; ii < numberofsamples; ++ii)
            thistrace.PushBack(aStation.getAeraStationADC(ch_id - 1)->GetADCValues(ii));

          // Get scintillator high voltage from data
          unsigned short scintHV = 0;
          const rdet::Channel& detChannel = detstation.GetChannel(chan.GetId());
          if (detChannel.GetChannelType() == "ScintillatorBottom" || detChannel.GetChannelType() == "ScintillatorTop") {
            if (ch_id == 1)
              scintHV = aStation.getAeraStationMessageV2PPSCH1(8);
            if (ch_id == 2)
              scintHV = aStation.getAeraStationMessageV2PPSCH2(8);
            if (ch_id == 3)
              scintHV = aStation.getAeraStationMessageV2PPSCH3(8);
            if (ch_id == 4)
              scintHV = aStation.getAeraStationMessageV2PPSCH4(8);
            // Convert internal HV setting to HV on the PMT (in Volts).
            // The internal voltage setting is driven from a 8 bit DAC (n=0...255) connected to
            // an amplifier which gives 0.3V + (n/256) * 1.25V.
            // The Phototube internally amplifies this voltage by a factor of 1000.
            chan.SetScintHighVoltage((0.3 + scintHV/256.0*1.25)*1000.0);
          }

        } else {
          info.str("");
          info << "Electronic readout is not implemented, Electronic type is "
               << aStation.getAeraStationHWType()
               << ". Channel is Set has inactive.";
          chan.SetNotActive();
          WARNING(info);
        }
        chan.SetNyquistZone(1);

        if (aStation.getAeraStationHWType() == 1) {
          if ((aStation.getAeraStationHWVersion() < 7 &&
               aStation.getAeraStationHWVersion() > 0) ||
               (aEvent.getAeraEventRunId() > 200000 &&
                aEvent.getAeraEventRunId() < 200300)) {  // New NL data
            if (ch_id == 1)
              thresh = aStation.getAeraStationMessageSignalThresholdCH0();
            if (ch_id == 2)
              thresh = aStation.getAeraStationMessageSignalThresholdCH1();
            if (ch_id == 3)
              thresh = aStation.getAeraStationMessageSignalThresholdCH2();
            if (ch_id == 4)
              thresh = aStation.getAeraStationMessageSignalThresholdCH3();
            // 0xFFFF is the Error code returned by the library in case no threshold is found
            if (thresh != 0xFFFF)
              chan.SetSignalThreshold(thresh);
            if (ch_id == 1)
              thresh = aStation.getAeraStationMessageNoiseThresholdCH0();
            if (ch_id == 2)
              thresh = aStation.getAeraStationMessageNoiseThresholdCH1();
            if (ch_id == 3)
              thresh = aStation.getAeraStationMessageNoiseThresholdCH2();
            if (ch_id == 4)
              thresh = aStation.getAeraStationMessageNoiseThresholdCH3();
            if (thresh != 0xFFFF)
              chan.SetNoiseThreshold(thresh);
          } else if (aStation.getAeraStationHWVersion() >= 7) {
            if (ch_id == 1)
              thresh = aStation.getAeraStationMessageV2Threshold1CH1();
            if (ch_id == 2)
              thresh = aStation.getAeraStationMessageV2Threshold1CH2();
            if (ch_id == 3)
              thresh = aStation.getAeraStationMessageV2Threshold1CH3();
            if (ch_id == 4)
              thresh = aStation.getAeraStationMessageV2Threshold1CH4();
            // 0xFFFF is the Error code returned by the library in case no threshold is found
            if (thresh != 0xFFFF)
              chan.SetSignalThreshold(thresh);
            if (ch_id == 1)
              thresh = aStation.getAeraStationMessageV2Threshold2CH1();
            if (ch_id == 2)
              thresh = aStation.getAeraStationMessageV2Threshold2CH2();
            if (ch_id == 3)
              thresh = aStation.getAeraStationMessageV2Threshold2CH3();
            if (ch_id == 4)
              thresh = aStation.getAeraStationMessageV2Threshold2CH4();
            if (thresh != 0xFFFF)
              chan.SetNoiseThreshold(thresh);
          }
        } else {
          chan.SetSignalThreshold(thresh);
          chan.SetNoiseThreshold(thresh);
        }
      } //for (channel) ...
    } catch (utl::NonExistentComponentException& e) {
      ERROR(e.what());
    }
  }  //for (station) ...
  ++fCurrentEvent;
  return eSuccess;
}


Status
RadioFileAERAroot::FileStatus()
{
  if (!fHasFileOpen)
    return eFail;
  else
    return eSuccess;
}


Status
RadioFileAERAroot::FindEvent(const unsigned int /*id*/)
{
  WARNING("RadioFileAERAroot::FindEvent not implemented!");
  return eEOF;
}


Status
RadioFileAERAroot::GotoPosition(const unsigned int /*position*/)
{
  WARNING("RadioFileAERAroot::GotoPosition not implemented!");
  return eEOF;
}


int
RadioFileAERAroot::GetNEvents()
{
  WARNING("RadioFileAERAroot::GetNEvents not implemented!");
  return 0;
}