ICRC2019/TriggerFunctions.hh

Go to the documentation of this file.

//EFFICIENCY FUNCTIONS FROM NOW
double SDTriggerEfficiencyICRC2017_SD1500(const double lgE, const double zenith, TVectorD pCal) {
  //used in ICRC 2017
  //efficiency is parameterized as function of S38
  const double pA[4] = {1.18586522, -2.5940793, 3.25692833, -1.19604131};
  const double cos2th = pow(TMath::Cos(zenith), 2.);
  const double A_EFF = pA[0] + cos2th * pA[1] + cos2th * cos2th * pA[2] + cos2th * cos2th * cos2th * pA[3];
  const double B_EFF = 0.36868343 ;
  double effpars[2];
  effpars[0] = A_EFF;
  effpars[1] = B_EFF;
  const std::vector<double> parvec(effpars, effpars + 2);
  const double lgS38 = InverseSdCalibration(lgE, pCal);
  const double feff = ScaledErrorFunction(lgS38, parvec);

  return feff;
}

double SDTriggerEfficiencyICRC2017_SD750(const double lgE, const double zenith, TVectorD pCal) {
  //used in ICRC 2017
  //efficiency is parameterized as function of S35
  const double pA_750[4] = {2.38516877 , -4.85552037, 4.10415064, -0.97515248  };
  const double cos2th = pow(TMath::Cos(zenith), 2.);
  const double A_750 = pA_750[0] + cos2th * pA_750[1] + cos2th * cos2th * pA_750[2] + cos2th * cos2th * cos2th * pA_750[3];
  const double B_750 = 0.24852449 ;
  double effpars[2];
  effpars[0] = A_750;
  effpars[1] = B_750;

  const std::vector<double> parvec(effpars, effpars + 2);
  const double lgS38 = InverseSdCalibration(lgE, pCal);
  const double feff = ScaledErrorFunction(lgS38, parvec);

  return feff;
}

double SDTriggerEfficiencyICRC2019_SD750(const double lgE, const double zenith, TVectorD pCal, bool oldTrig) {
  //used in ICRC 2019
  //efficiency is parameterized as function of S35
  //From simulated QGS showers 50/50 P/Fe by Alan (GAP-2018-037)

  double A, B;

  const double sin2th = pow(TMath::Sin(zenith), 2.);

  if (oldTrig) {

    //50/50 mix of P/Fe, old triggers
    const double pA[4] = {0.5667 + 0.0372, -0.2405, 1.3124, 0.0692}; 
    const double pB[2] = {0.2546, -0.0362};
    A = pA[0] + sin2th * pA[1] + sin2th * sin2th * pA[2] + sin2th * sin2th * sin2th * pA[3];
    B = pB[0] + sin2th * pB[1];

  } else {

    //const double pA[4] = {0.3739, -0.0783, 1.0496, 0.4007}; //Proton
    //const double pA[4] = {0.4346, -0.1092, 1.0880, 0.5030}; //Iron
    const double pA[4] = {0.3999, -0.0631, 0.9291, 0.6118}; //50/50

    //const double pB[2] = {0.2043, 0.0770};  //Proton
    //const double pB[2] = {0.2115, -0.0081};  //Iron
    const double pB[2] = {0.2075, 0.0434};  //50/50
    
    A = pA[0] + sin2th * pA[1] + sin2th * sin2th * pA[2] + sin2th * sin2th * sin2th * pA[3];
    B = pB[0] + sin2th * pB[1];
  }

  const double effpars[] = {A, B};
  const std::vector<double> parvec(effpars, effpars + 2);

  const double lgS35 = InverseSdCalibration(lgE, pCal);
  const double feff = ScaledErrorFunction(lgS35, parvec);

  return feff;
}

double SD1500TriggerEfficiencyHybrids2019(const double lgE) {
  // From I. Valino; May 2019
  // calculated on hybrids
  // function is parameterized on energy only
  double A_EFF = 17.9052;
  double B_EFF = 0.379812;
  double effpars[2];
  effpars[0] = A_EFF;
  effpars[1] = B_EFF;
  const std::vector<double> parvec(effpars, effpars + 2);
  const double feff = ScaledErrorFunction(lgE, parvec);
  return feff;
}

double SD1500TriggerEfficiency_ICRC2019(const double lgE, const double zenith) {
  // From I. Valino; June 2019
  // calculated on Hybrids

  const double pA[4] = {18.6348, -3.18143, 4.38488, -1.87468};
  const double cos2th = pow(TMath::Cos(zenith), 2.);

  const double A_EFF = pA[0] + cos2th * pA[1] + cos2th * cos2th * pA[2] + cos2th * cos2th * cos2th * pA[3];
  const double B_EFF = 0.372832;

  double effpars[2];
  effpars[0] = A_EFF;
  effpars[1] = B_EFF;
  const std::vector<double> parvec(effpars, effpars + 2);

  const double feff = ScaledErrorFunction(lgE, parvec);

  return feff;

}

double TriggerEfficiency_TestExample(const double lgE) {
  double feff = 1;
  //test function. Add here any function  you want to test
  // input is logE and zenith angle
  // output is efficiency

  return feff;
}