RdChannelAmplitudeTemperatureDependenceCorrector.cc

Go to the documentation of this file.

#include "RdChannelAmplitudeTemperatureDependenceCorrector.h"

#include <fwk/CentralConfig.h>

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

#include <evt/Event.h>
#include <revt/REvent.h>
#include <revt/Channel.h>
#include <revt/ChannelRecData.h>
#include <revt/ChannelRRecDataQuantities.h>
#include <revt/Station.h>

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


using namespace revt;
using namespace fwk;
using namespace std;
using namespace utl;


/* RS: for the module to gather CRS temperatures, you should have RMonitoringSQLConfig.xml
   configured to AERA.sqlite and RSQLConfig.xml to AERA_4_A.sqlite
*/

namespace RdChannelAmplitudeTemperatureDependenceCorrector {

  VModule::ResultFlag
  RdChannelAmplitudeTemperatureDependenceCorrector::Init()
  {
    // Read in the configurations of the xml file
    Branch topBranch =
      CentralConfig::GetInstance()->GetTopBranch("RdChannelAmplitudeTemperatureDependenceCorrector");
    topBranch.GetChild("InfoLevel").GetData(fInfoLevel);
    topBranch.GetChild("RejectIfCorrectionFailed").GetData(fRejectIfCorrectionFailed);

    return eSuccess;
  }


  VModule::ResultFlag
  RdChannelAmplitudeTemperatureDependenceCorrector::Run(evt::Event& event)
  {
    // Check if there are events at all
    if (!event.HasREvent()) {
      WARNING("No radio event found!");
      return eContinueLoop;
    }

    ostringstream info;
    REvent& rEvent = event.GetREvent();

    const det::Detector& detector = det::Detector::GetInstance();
    const rdet::RDetector& rDetector = detector.GetRDetector();

    const double crsTemperature = rDetector.GetTemperature("CRS");  // in Kelvin 
    const bool hasCrsTemp = isnan(crsTemperature);
    INFODebug("CRS temperature: " + to_string(crsTemperature) + "deg kelvin");

    // loop through stations and for every station through every channel
    for (auto& station : rEvent.StationsRange()) {
      info.str("");
      info << "Current station id " << station.GetId();
      INFODebug(info);

      // reject station if there is no CRS temperature available
      if (fRejectIfCorrectionFailed && hasCrsTemp) {
        WARNING("No CRS temperature available. Station will be rejected.\n");
        station.SetRejectedReason(eNoTemperatureCorrection);
        continue;
      }

      for (auto& channel : station.ChannelsRange()) {
        if (!channel.IsActive())
          continue;

        auto& timeSeries = channel.GetChannelTimeSeries();  //-> Get the Amplitude A
        const auto& detChannel = rDetector.GetStation(station).GetChannel(channel);

        // check for ADC type to establish if it is a DE or NL station. Reject for unknown type
        const auto& adcType = GetAdcType(detChannel.GetADCType());
        if (adcType == eUndefined) {
          WARNING("unknown filteramplifier. Station will be rejected, temp correction can't be applied.");
          station.SetRejectedReason(eNoTemperatureCorrection);
          continue;
        }

        /* reject station if antenna type isn't SmallBlackSpider or Butterfly,
           because there are no known correction factors for other types */
        const string AntennaType = detChannel.GetAntennaTypeName();
        if ((AntennaType.substr(0, string("SmallBlackSpider").length()) != "SmallBlackSpider") &&
            (AntennaType.substr(0, string("Butterfly").length()) != "Butterfly")) {
          info.str("");
          info << "unknown antenna type: " << AntennaType
               << " Station will be rejected, temp correction can't be applied.";
          WARNING(info);

          station.SetRejectedReason(eNoTemperatureCorrection);
          continue;
        }

        info.str("");
        info << "Antenna type: " << AntennaType << ", ADC type: " << adcType;
        INFODebug(info);

        // get station temp depending on adc type
        double stationTemp = std::nan("1");
        if (adcType == eDE_Phase1 || adcType == eDE_Phase2) {
          // stored in the DB in C, converted into Kelvin by Offline
          stationTemp = station.GetHWTemperatureExt();
        } else {
          //stored in C and not transformed during reading by Offline
          stationTemp = station.GetHWTemperature() + 273.15;
        }

        if (fRejectIfCorrectionFailed && isnan(stationTemp)) {
          WARNING("No station temperature data available. Station will be rejected");
          station.SetRejectedReason(eNoTemperatureCorrection);
          continue;
        }

        // check if sensor values are reasonable (-50C to 100C), otherwise reject station 
        if(fRejectIfCorrectionFailed && (stationTemp < 223.15 || stationTemp > 373.15)) {
          WARNING("Incorrect sensor temperature. Station will be rejected");
          station.SetRejectedReason(eNoTemperatureCorrection);
          continue;
        }

        ostringstream info;
        info << "Temperatures used for correction of LNA amplitudes: T = " << crsTemperature
             << "Temperatures for correction of FilterAmplifier amplitudes: T = " << stationTemp
             << ", Tref= " << fReferenceTemperatur;
        INFODebug(info);

        // FA amplitude correction. Filter is inside station electronics box hence use station temp
        const double FAfactor = GetFilterAmplifierAmplitudeCorrectionFactor(adcType);
        const double filterAmplifierAmplitudeCorrectionFactor =
          pow(10, FAfactor * 1e-3 * (fReferenceTemperatur - stationTemp) * 0.05);

        // LNA Amplitude correction. LNA is outside, hence CRS temp
        const double LNAfactor = GetLNAAmplitudeCorrectionFactor(detChannel.GetAntennaTypeName());
        const double LNAAmplitudeCorrectionFactor =
          pow(10, LNAfactor * 1e-3 * (fReferenceTemperatur - crsTemperature) * 0.05);

        // save corrections factors in channel parameter storage
        if (!channel.HasRecData()) {
          channel.MakeRecData();
        }

        channel.GetRecData().SetParameter(eAmplitudeLNATemperatureCorrectionFactor,
                                          LNAAmplitudeCorrectionFactor);
        channel.GetRecData().SetParameter(eAmplitudeFilterAmpTemperatureCorrectionFactor,
                                          filterAmplifierAmplitudeCorrectionFactor);

        // perform correction
        for (auto& el : timeSeries) {
          el *=  LNAAmplitudeCorrectionFactor * filterAmplifierAmplitudeCorrectionFactor;
        }
      }
    }

    return eSuccess;
  }


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


  RdChannelAmplitudeTemperatureDependenceCorrector::AdcType
  RdChannelAmplitudeTemperatureDependenceCorrector::GetAdcType(const std::string adcString)
  {
    if (adcString.substr(0, 4) == "AERA") {
      if (adcString.substr(4, 2) == "DE") {
        // KIT Filteramplifier Phase 1
        return eDE_Phase1;
      } else {
        // Dutch Filteramplifier phase 1
        return eNL_Phase1;
      }
    }

    // KIT Filteramplifier Phase 2
    if (adcString.substr(0, 6) == "ADC_DE") {
      return eDE_Phase2;
    }

    // Dutch Filteramplifier Phase 2
    if (adcString.substr(0, 6) == "ADC_NL") {
      return eNL_Phase2;
    }

    return eUndefined;
  }


  double
  RdChannelAmplitudeTemperatureDependenceCorrector::GetLNAAmplitudeCorrectionFactor(
    const string AntennaType)
  {
    if (AntennaType.substr(0, string("SmallBlackSpider").length()) == "SmallBlackSpider") {
      // LNA phase 1
      return -15;
    }

    if (AntennaType.substr(0, string("Butterfly").length()) == "Butterfly") {
      // Butterfly LNA, -26mdB/K
      return -26;
    }

    WARNING("unknown antenna type, no correction");
    return 0;
  }


  double
  RdChannelAmplitudeTemperatureDependenceCorrector::GetFilterAmplifierAmplitudeCorrectionFactor(
    const AdcType adcType)
  {
    switch(adcType)
    {
      case eDE_Phase1:
        return -25;
      case eDE_Phase2:
        return -8;
      case eNL_Phase1:
        return -25;
      case eNL_Phase2:
        // probably 0
        return 0;
      default:
        WARNING("unknown filteramplifier, no correction.");
        return 0;
    }
  }

}