RdNoiseBinaryToROOTConverter.cc

Go to the documentation of this file.

#include "RdNoiseBinaryToROOTConverter.h"

#include <iostream>

#include "TTree.h"
#include "TFile.h"


using namespace RdNoiseConverter;


bool
RdNoiseBinaryToROOTConverter::IsNoiseTrace(const EventN& noiseEvent, const double meanCh0, const double meanCh1)
{
  int counterCh0 = 0;
  int counterCh1 = 0;

  const int noiseFilter = 10;

  for (auto const& bin: noiseEvent.traceCh0) {
    if (abs(bin) - meanCh0 > noiseFilter)
      counterCh0++;
  }

  for (auto const& bin: noiseEvent.traceCh1) {
    if (abs(bin) - meanCh1 > noiseFilter)
      counterCh1++;
  }
  const bool noisy = (std::max(counterCh0, counterCh1) > 30 ? true : false);
  return noisy;
}


void
RdNoiseBinaryToROOTConverter::ReadFromBinaryFile(const std::string fileName, const int maxTraces)
{
  RdNoiseBinaryToROOTConverter bin2root;
  int counter = 0;
  EventN noiseEvent;
  FILE* inpfile = fopen(fileName.c_str(),"r");

  TFile* outfile = new TFile("myNoise.root", "RECREATE", "File for all noise traces");

  while(true) {
    // dont change, we skip headers and do validity check
    int seconds = 0;

    int status = fread(&seconds, sizeof(int), 1, inpfile);

    if (status != 1) {
      if (counter == 0)
        std::cout << "File corrupt, no traces to write!" << std::endl;
      else {
        fclose(inpfile);
        outfile->Write();
        outfile->Close();
        std::cout << "End of file reached, noise file written." << std::endl;
      }
      return;
    }

    fseek(inpfile, sizeof(int)*51, SEEK_CUR);
    // until here

    int sumch0 = 0;
    int sumch1 = 0;

    int ns = { };
    int ew = { };
    int ADCRaw [6] = { };

    for (int i=0; i<2048; i++) {
      fseek(inpfile,sizeof(int), SEEK_CUR);

      fread(&ADCRaw[0], sizeof(int), 6, inpfile);

      ns = (ADCRaw[5] >> 1) & 0xfff;
      ew = (ADCRaw[5] >> 17) & 0xfff;

      noiseEvent.traceCh0[i] = ( ns > 2047 ) ? ns - 4096: ns;
      noiseEvent.traceCh1[i] = ( ew > 2047 ) ? ew - 4096: ew;

      sumch0 += noiseEvent.traceCh0[i];
      sumch1 += noiseEvent.traceCh1[i];
    }

    const double meanch0 = sumch0 / 2048;
    const double meanch1 = sumch1 / 2048;

    if (bin2root.IsNoiseTrace(noiseEvent, meanch0, meanch1)) {
      continue;
    }

    const int currGPSUnixOffset = 18; // I know, hardcoded but as these files are a time thing and offset calculation is extensive
    noiseEvent.evtno = counter;
    noiseEvent.sec = seconds + currGPSUnixOffset;
    // following not implemented in Daves noise file but already implementing structure
    noiseEvent.nanosec = 0;
    noiseEvent.stationId = 0;

    std::string treeName = "Noisetree_" + std::to_string(counter);
    TTree* tree = new TTree(treeName.c_str(),"The tree of noise");
    tree->Branch("traceCh0", &noiseEvent.traceCh0, "traceCh0[2048]/I");
    tree->Branch("traceCh1", &noiseEvent.traceCh1, "traceCh1[2048]/I");
    tree->Branch("stationId", &noiseEvent.stationId, "stationId/I");
    tree->Branch("sec", &noiseEvent.sec, "sec/I");
    tree->Branch("nanosec", &noiseEvent.nanosec, "nanosec/I");
    tree->Branch("evtno", &noiseEvent.evtno, "evtno/I");
    // Fill the tree with the buffer
    tree->Fill();
    tree->ResetBranchAddresses();

    counter++;
    if (counter == maxTraces)
      break;
  }

  fclose(inpfile);
  outfile->Write();
  outfile->Close();
  std::cout << "Given maximum number of traces reached, noise file written." << std::endl;
  return;

}


int main(int argc, char* argv[])
{
  RdNoiseBinaryToROOTConverter bin2root;

  const std::string fileName = argv[1];
  const int maxTraces = std::atoi(argv[2]);

  bin2root.ReadFromBinaryFile(fileName, maxTraces);

  return 0;
}