VirtualChannelCalibrator.cc

Go to the documentation of this file.

#include "VirtualChannelCalibrator.h"

#include <fwk/CentralConfig.h>
#include <fwk/RunController.h>

#include <utl/config.h>
#include <utl/Reader.h>
#include <utl/ErrorLogger.h>
#include <utl/AugerUnits.h>

#include <evt/Event.h>

#include <fevt/FEvent.h>
#include <fevt/Eye.h>
#include <fevt/Header.h>
#include <fevt/EyeHeader.h>
#include <fevt/EyeTriggerData.h>
#include <fevt/Telescope.h>
#include <fevt/Channel.h>
#include <fevt/ChannelRecData.h>
#include <fevt/Pixel.h>
#include <fevt/PixelRecData.h>
#include <fevt/PixelTriggerData.h>
#include <fevt/TelescopeTriggerData.h>
#include <fevt/SLTData.h>

#include <det/Detector.h>

#include <fdet/Eye.h>
#include <fdet/Telescope.h>
#include <fdet/Camera.h>
#include <fdet/Channel.h>
#include <fdet/Pixel.h>
#include <fdet/FDetector.h>

#include <utl/Trace.h>
#include <utl/TraceAlgorithm.h>

#include <AugerEvent.h>
#include <EyeEvent.hh>
#include <EyeEventHeader.hh>
#include <EyeT3Data.hh>
#include <FadcData.hh>
#include <FdNumbering.hh>
#include <FDEventLibVersion.hh>

#include <sstream>
#include <cmath>
#include <iomanip>

using namespace VirtualChannelCalibratorKG;
using namespace fevt;
using namespace fdet;
using namespace utl;
using namespace fwk;
using namespace std;


VModule::ResultFlag
VirtualChannelCalibrator::Init()
{
  Branch topB = CentralConfig::GetInstance()->GetTopBranch("VirtualChannelCalibrator");

  if (!topB) {
    ERROR("Could not find branch VirtualChannelCalibrator");
    return eFailure;
  }
  topB.GetChild("verbosity").GetData(fVerbosity);
  return eSuccess;
}

struct CameraData {

  //  map<unsigned int> channelSignal;
  
};


VModule::ResultFlag
VirtualChannelCalibrator::Run(evt::Event& event)
{
  if (!event.HasFEvent()) {
    WARNING("No FD Event");
    return eContinueLoop;
  }

  bool saturatedEvent = false;
  
  const fevt::FEvent& fdEvent = event.GetFEvent();
  const fdet::FDetector& detFD = det::Detector::GetInstance().GetFDetector();
  
  for (fevt::FEvent::ConstEyeIterator eyeIter = fdEvent.EyesBegin();
       eyeIter != fdEvent.EyesEnd(); ++eyeIter) {

    //const fdet::Eye& detEye = detFD.GetEye(*eyeIter);
      const fevt::Eye& eyeEvent = *eyeIter;
      
      for (fevt::Eye::ConstTelescopeIterator telescopeIter = eyeEvent.TelescopesBegin();
           telescopeIter != eyeEvent.TelescopesEnd(); ++telescopeIter) {
        
        const fdet::Telescope& detTel = detFD.GetTelescope(*telescopeIter);
        const fevt::Telescope& telEvent = *telescopeIter;

        const fdet::Camera& detCamera = detTel.GetCamera();
        const unsigned int fadcDynamicRange = (unsigned int) detCamera.GetADCDynamicRange();
        //const int adcOverFlow = (1 << fadcDynamicRange) - 1;
        
        map<unsigned int, TraceD> saturatedPixelList;
        
        for (fevt::Telescope::ConstChannelIterator chanIter = telEvent.ChannelsBegin();
             chanIter != telEvent.ChannelsEnd(); ++chanIter) {
          
          const fdet::Channel& detChannel = detFD.GetChannel(*chanIter);
          //const fevt::Channel& chEvent = *chanIter;
          
          //const unsigned int thisChannelId = chanIter->GetId();
          if (!chanIter->HasRecData())
            continue;
          
          const ChannelRecData& recData = chanIter->GetRecData();
          
          if (recData.ChannelIsSaturated()) {
            saturatedEvent = true;            
          }

          if (detChannel.IsVirtual()) {
          }
          
          
          //const TraceI& virtualTrace = recData.GetFADCTrace(FdConstants::eTotal);
        
          // correct trace according to Eq. (1) in GAP-2006-104

          /*
          for (unsigned int pos = startBin; pos <= endBin; ++pos) {
            const int adcValue = rawFADCTrace[pos];
          }
          */
                
        
          //const double channelGain = detChannel.GetElectronicsGain();
          const unsigned int virtualChannelId = detChannel.GetVirtualChannelId();
          //const double virtualChannelGain = detTel.GetChannel(virtualChannelId).GetElectronicsGain();

        } // channel iterator

        
          /*
            if (thisChannelId == virtualChannelId) { // virtual channel for de-saturation        
              if (recData.ChannelIsSaturated()) {
                const unsigned int t1 = recData.GetFirstSatBin();
                const unsigned int t2 = recData.GetLastSatBin();
                if ((startBin <= t1 && t1 <= endBin) ||
                    (startBin <= t2 && t2 <= endBin)) {
                  WARNING("trace recovery failed because virtual channel"
                          " is saturated!");
                  pixel.SetLowGainSaturation();
                  return;
                }          
              }
              vChannelRecData = &recData;
            }
            
          } else if (thisChannelId != channelId) { 
            
            const unsigned int thisVirtualChannelId =
              detTel.GetChannel(thisChannelId).GetVirtualChannelId();
            
            if (thisVirtualChannelId == virtualChannelId) { // other pixels in same virtual channel
              if (recData.ChannelIsSaturated()) {
                const unsigned int t1 = recData.GetFirstSatBin();
                const unsigned int t2 = recData.GetLastSatBin();
                if ((startBin <= t1 && t1 <= endBin) ||
                    (startBin <= t2 && t2 <= endBin)) {
                  WARNING("more than one saturated channels in same time range!!");
                  return;
                }
              }
              otherChannels.push_back(&recData);
              electronicGains.push_back(thisDetChannel.GetElectronicsGain());
            }
          }
          */

        /*
        if (!vChannelRecData) {
          ERROR("Missing virtual channel data!!");
          pixel.SetLowGainSaturation();
          return;
        }
  
        const TraceI& virtualTrace = vChannelRecData->GetFADCTrace(FdConstants::eTotal);
        
        // correct trace according to Eq. (1) in GAP-2006-104
        
        for (unsigned int pos = startBin; pos <= endBin; ++pos) {
          const int adcValue = rawFADCTrace[pos];
          if (adcValue >= adcOverFlow) {
            double otherChannelADCSum = 0.;
            for (unsigned int i = 0; i < otherChannels.size(); ++i) {
              const TraceI& thisTrace = otherChannels[i]->GetFADCTrace(FdConstants::eTotal);
              const double adcValue = thisTrace[pos] - otherChannels[i]->GetBaseLine();
              otherChannelADCSum += adcValue/electronicGains[i];
            }
            const double vADCBaseLineSub = virtualTrace[pos] - vChannelRecData->GetBaseLine();
            const double recoveredSignal =
              (vADCBaseLineSub/virtualChannelGain - otherChannelADCSum) * channelGain;
            rawFADCTrace[pos] = int(recoveredSignal + 0.5);
            channelRecData.AddDeSaturatedBin(pos);
          }
        }
        pixel.SetSaturationRecovered()

          */
      } // telescope iter
  } // eye iter
  
  return eSuccess;
}


VModule::ResultFlag
VirtualChannelCalibrator::Finish()
{
  return eSuccess;
}




// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// compile-command: "make -C ..  VirtualChannelCalibratorKG/VirtualChannelCalibrator.o -k"
// End: