MEvent/Counter.cc

Go to the documentation of this file.

#include <mevt/Counter.h>

#include <sstream>

using std::cout;
using std::endl;


namespace mevt {

  void
  Counter::MakeSimData()
  {
    if (fSimData)
      ERROR("SimData already exists - Not Replacing");
    else
      fSimData = new CounterSimData;
  }


  bool
  Counter::HasRecData()
    const
  {
    if (!fModules.GetNumberOf())
      return false;

    // return true
    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im)
      if (im->HasRecData())
        return true;

    return false;
  }


  size_t
  Counter::CountCandidateModules()
    const
  {
    size_t nCandidateModules = 0;

    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im)
      if (im->IsCandidate())
        ++nCandidateModules;

    return nCandidateModules;
  }


  size_t
  Counter::CountSilentModules()
    const
  {
    size_t nSilentModules = 0;

    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im)
      if (im->IsSilent())
        ++nSilentModules;

    return nSilentModules;
  }


  size_t
  Counter::CountRejectedModules()
    const
  {
    size_t nRejectedModules = 0;

    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im)
      if (im->IsRejected())
        ++nRejectedModules;

    return nRejectedModules;
  }


  bool
  Counter::IsCandidate()
    const
  {
    const size_t nCandidateModules = CountCandidateModules();

    return nCandidateModules >= 1;
  }


  bool
  Counter::IsSilent()
    const
  {
    const size_t nCandidateModules = CountCandidateModules();
    const size_t nSilentModules = CountSilentModules();

    return !nCandidateModules && nSilentModules > 0;
  }


  bool
  Counter::IsRejected()
    const
  {
    return !CountCandidateModules() &&
           !CountSilentModules() &&
           CountRejectedModules();
  }


  bool
  Counter::IsSaturated()
    const
  {
    // if not candidate return false
    if (!IsCandidate())
      return false;

    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im)
      if (im->IsCandidate() && im->HasRecData() && im->GetRecData().IsSaturated())
        return true;

    return false;
  }


  bool
  Counter::IsADCCalibratedLG()
    const
  {
    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im)
      if (im->HasRecData() && im->GetRecData().IsADCCalibratedLG())
        return true;

    return false;
  }


  bool
  Counter::IsADCCalibratedHG()
    const
  {
    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im)
      if (im->HasRecData() && im->GetRecData().IsADCCalibratedHG())
        return true;

    return false;
  }


  void
  Counter::SetRejected(const std::string& reason)
  {
    for (ModuleIterator im = fModules.Begin(); im != fModules.End(); ++im)
      im->SetRejected(reason);
  }


  void
  Counter::SetSilent()
  {
    for (ModuleIterator im = fModules.Begin(); im != fModules.End(); ++im)
      im->SetSilent();
  }


  double
  Counter::GetNumberOfEstimatedMuons()
    const
  {
    double estimatedMuons = 0;

    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im) {
      // muons can only be estimated for modules with data and unsaturated
      if (im->IsCandidate() && im->HasRecData()) {
        if (im->GetRecData().IsSaturated()) {
          std::ostringstream ss;
          ss << "Number of muons cannot calculated for saturated counter " << fId;
          WARNING(ss);
          return -1;
        } else {
          estimatedMuons += im->GetRecData().GetNumberOfEstimatedMuons();
        }
      }
    }

    return estimatedMuons;
  }


  double
  Counter::GetNumberOfMuonsErrorHigh()
  const
  {
    double counterVariance = 0;

    // muons can only be estimated for modules with data and unsaturated
    if (IsSaturated()) {
      std::ostringstream ss;
      ss << "Number of muons cannot calculated for saturated counter " << fId;
      WARNING(ss);
      return -1;
    }

    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im) {
      if (im->IsCandidate() && im->HasRecData()) {
        const double moduleSigma = im->GetRecData().GetNumberOfMuonsErrorHigh();
        counterVariance += (moduleSigma*moduleSigma);
      }
    }

    return sqrt(counterVariance);
  }


  double
  Counter::GetNumberOfMuonsErrorLow()
    const
  {
    double counterVariance = 0;

    // muons can only be estimated for modules with data and unsaturated
    if (IsSaturated()) {
      std::ostringstream ss;
      ss << "Number of muons cannot calculated for saturated counter " << fId;
      WARNING(ss);
      return -1;
    }

    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im) {
      if (im->IsCandidate() && im->HasRecData()) {
        const double moduleSigma = im->GetRecData().GetNumberOfMuonsErrorLow();
        counterVariance += (moduleSigma*moduleSigma);
      }
    }

    return sqrt(counterVariance);
  }


  double
  Counter::GetNumberOfMuonsLowLimit()
    const
  {
    double limit = 0;

    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im)
      if (im->IsCandidate() && im->HasRecData())
        limit += im->GetRecData().GetNumberOfMuonsLowLimit();

    return limit;
  }


  double
  Counter::GetMeanMuons()
    const
  {
    double estimatedMuons = 0;

    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im) {
      // muons can only be estimated for modules with data and unsaturated
      if (im->IsCandidate() && im->HasRecData()) {
        if (im->GetRecData().IsSaturated()) {
          std::ostringstream ss;
          ss << "Mean muons cannot calculated for saturated counter " << fId;
          WARNING(ss);
          return -1;
        } else {
          estimatedMuons += im->GetRecData().GetMeanMuons();
        }
      }
    }

    return estimatedMuons;
  }


  double
  Counter::GetMeanMuonsErrorHigh()
  const
  {
    double counterVariance = 0;

    // muons can only be estimated for modules with data and unsaturated
    if (IsSaturated()) {
      std::ostringstream ss;
      ss << "Mean muons cannot calculated for saturated counter " << fId;
      WARNING(ss);
      return -1;
    }

    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im) {
      if (im->IsCandidate() && im->HasRecData()) {
        const double moduleSigma = im->GetRecData().GetMeanMuonsErrorHigh();
        counterVariance += (moduleSigma*moduleSigma);
      }
    }

    return sqrt(counterVariance);
  }


  double
  Counter::GetMeanMuonsErrorLow()
    const
  {
    double counterVariance = 0;

    // muons can only be estimated for modules with data and unsaturated
    if (IsSaturated()) {
      std::ostringstream ss;
      ss << "Mean muons cannot calculated for saturated counter " << fId;
      WARNING(ss);
      return -1;
    }

    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im) {
      if (im->IsCandidate() && im->HasRecData()) {
        const double moduleSigma = im->GetRecData().GetMeanMuonsErrorLow();
        counterVariance += (moduleSigma*moduleSigma);
      }
    }

    return sqrt(counterVariance);
  }


  double
  Counter::GetMeanMuonsLowLimit()
    const
  {
    double limit = 0;

    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im)
      if (im->IsCandidate() && im->HasRecData())
        limit += im->GetRecData().GetMeanMuonsLowLimit();

    return limit;
  }


  double
  Counter::GetActiveArea()
    const
  {
    double counterArea = 0;

    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im)
      if (im->IsCandidate() && im->HasRecData())
        counterArea += im->GetRecData().GetActiveArea();

    return counterArea;
  }


  double
  Counter::GetActiveAreaLG()
    const
  {
    double counterArea = 0;

    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im)
      if (im->HasRecData() && im->GetRecData().IsADCCalibratedLG())
        counterArea += im->GetRecData().GetActiveArea();

    return counterArea;
  }


  double
  Counter::GetActiveAreaHG()
    const
  {
    double counterArea = 0;

    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im)
      if (im->HasRecData() && im->GetRecData().IsADCCalibratedHG())
        counterArea += im->GetRecData().GetActiveArea();

    return counterArea;
  }


  double
  Counter::GetMuonDensity()
    const
  {
    // muons can only be estimated for unsaturated modules
    if (IsSaturated()) {
      std::ostringstream ss;
      ss << "Density of muons cannot calculated for saturated counter " << fId;
      WARNING(ss);
      return -1;
    }

    const double density = GetNumberOfEstimatedMuons() / GetActiveArea();

    return density;
  }


  double
  Counter::GetMuonDensityErrorHigh()
    const
  {
    // muons can only be estimated for unsaturated modules
    if (IsSaturated()) {
      std::ostringstream ss;
      ss << "Density of muons cannot calculated for saturated counter " << fId;
      WARNING(ss);
      return -1;
    }

    const double counterSigma = GetNumberOfMuonsErrorHigh() / GetActiveArea();

    return counterSigma;
  }


  double
  Counter::GetMuonDensityErrorLow()
    const
  {
    // muons can only be estimated for unsaturated modules
    if (IsSaturated()) {
      std::ostringstream ss;
      ss << "Density of muons cannot calculated for saturated counter " << fId;
      WARNING(ss);
      return -1;
    }

    const double counterSigma = GetNumberOfMuonsErrorLow() / GetActiveArea();

    return counterSigma;
  }

  double
  Counter::GetMeanMuonDensity()
    const
  {
    std::ostringstream ss;
    // muons can only be estimated for unsaturated modules
    if (IsSaturated()) {
      ss << "Mean density of muons cannot calculated for saturated counter " << fId;
      WARNING(ss);
      return -1;
    }
    const double density = GetMeanMuons() / GetActiveArea();
    ss << "density = " << GetMeanMuons() << " / " << GetActiveArea() << " = " << density;
    DEBUGLOG( ss.str() );

    return density;
  }


  double
  Counter::GetMeanMuonDensityErrorHigh()
    const
  {
    // muons can only be estimated for unsaturated modules
    if (IsSaturated()) {
      std::ostringstream ss;
      ss << "Mean density of muons cannot calculated for saturated counter " << fId;
      WARNING(ss);
      return -1;
    }

    const double counterSigma = GetMeanMuonsErrorHigh() / GetActiveArea();

    return counterSigma;
  }


  double
  Counter::GetMeanMuonDensityErrorLow()
    const
  {
    // muons can only be estimated for unsaturated modules
    if (IsSaturated()) {
      std::ostringstream ss;
      ss << "Mean density of muons cannot calculated for saturated counter " << fId;
      WARNING(ss);
      return -1;
    }

    const double counterSigma = GetMeanMuonsErrorLow() / GetActiveArea();

    return counterSigma;
  }


  unsigned int
  Counter::GetNumberOfChannelsOn()
    const
  {
    double windowsOn = 0;

    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im) {
      // windows can only be estimated for modules with data
      if (im->IsCandidate() && im->HasRecData())
        windowsOn += im->GetRecData().GetNumberOfChannelsOn();
    }

    return windowsOn;
  }


  double
  Counter::GetLDFResidual()
    const
  {
    double ldfResidual = 0;
    unsigned int nModules = 0;

    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im)
      if (im->IsCandidate() && im->HasRecData() && !im->GetRecData().IsSaturated()) {
          ldfResidual += im->GetRecData().GetLDFResidual();
          ++nModules;
      }

    return ldfResidual / nModules;
  }


  /**********************
   *       ADC LG
   **********************/

  double
  Counter::GetNumberOfEstimatedMuonsLG()
    const
  {
    double estimatedMuons = 0;

    // muons can only be estimated for modules with data and unsaturated
    if (!IsADCCalibratedLG()) {
      std::ostringstream ss;
      ss << "Number of muons with ADC LG cannot calculated for counter with no calibrated modules " << fId;
      WARNING(ss);
      return -1;
    }

    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im)
      if (im->HasRecData() && im->GetRecData().IsADCCalibratedLG())
          estimatedMuons += im->GetRecData().GetNumberOfEstimatedMuonsADCLG();

    return estimatedMuons;
  }


  double
  Counter::GetNumberOfMuonsErrorHighLG()
    const
  {
    double counterVariance = 0;

    // muons can only be estimated for modules with data and unsaturated
    if (!IsADCCalibratedLG()) {
      std::ostringstream ss;
      ss << "Number of muons with ADC LG cannot calculated for counter with no calibrated modules " << fId;
      WARNING(ss);
      return -1;
    }

    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im)
      if (im->HasRecData() && im->GetRecData().IsADCCalibratedLG()) {
          const double moduleSigma = im->GetRecData().GetNumberOfMuonsADCErrorHighLG();
          counterVariance += (moduleSigma*moduleSigma);
      }

    return sqrt(counterVariance);
  }


  double
  Counter::GetNumberOfMuonsErrorLowLG()
    const
  {
    double counterVariance = 0;

    // muons can only be estimated for modules with data and unsaturated
    if (!IsADCCalibratedLG()) {
      std::ostringstream ss;
      ss << "Number of muons with ADC LG cannot calculated for counter with no calibrated modules " << fId;
      WARNING(ss);
      return -1;
    }

    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im)
      if (im->HasRecData() && im->GetRecData().IsADCCalibratedLG()) {
        const double moduleSigma = im->GetRecData().GetNumberOfMuonsADCErrorLowLG();
        counterVariance += (moduleSigma*moduleSigma);
      }

    return sqrt(counterVariance);
  }


  double
  Counter::GetMuonDensityLG()
    const
  {
    // muons can only be estimated for unsaturated modules
    if (!IsADCCalibratedLG()) {
      std::ostringstream ss;
      ss << "Density of muons cannot be calculated with ADC LG for counter with no calibrated modules " << fId;
      WARNING(ss);
      return -1;
    }

    const double density = GetNumberOfEstimatedMuonsLG() / GetActiveAreaLG();

    return density;
  }


  double
  Counter::GetMuonDensityErrorHighLG()
    const
  {
    // muons can only be estimated for unsaturated modules
    if (!IsADCCalibratedLG()) {
      std::ostringstream ss;
      ss << "Density of muons cannot be calculated with ADC LG for counter with no calibrated modules " << fId;
      WARNING(ss);
      return -1;
    }

    const double counterSigma = GetNumberOfMuonsErrorHighLG() / GetActiveAreaLG();

    return counterSigma;
  }


  double
  Counter::GetMuonDensityErrorLowLG()
    const
  {
    // muons can only be estimated for unsaturated modules
    if (!IsADCCalibratedLG()) {
      std::ostringstream ss;
      ss << "Density of muons cannot be calculated with ADC LG for counter with no calibrated modules " << fId;
      WARNING(ss);
      return -1;
    }

    const double counterSigma = GetNumberOfMuonsErrorLowLG() / GetActiveAreaLG();

    return counterSigma;
  }


  /**********************
   *       ADC HG
   **********************/

  double
  Counter::GetNumberOfEstimatedMuonsHG()
    const
  {
    double estimatedMuons = 0;

    // muons can only be estimated for modules with data and unsaturated
    if (!IsADCCalibratedHG()) {
      std::ostringstream ss;
      ss << "Number of muons with ADC HG cannot calculated for counter with no calibrated modules" << fId;
      WARNING(ss);
      return -1;
    }

    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im)
      if (im->HasRecData() && im->GetRecData().IsADCCalibratedHG())
          estimatedMuons += im->GetRecData().GetNumberOfEstimatedMuonsADCHG();

    return estimatedMuons;
  }


  double
  Counter::GetNumberOfMuonsErrorHighHG()
    const
  {
    double counterVariance = 0;

    // muons can only be estimated for modules with data and unsaturated
    if (!IsADCCalibratedHG()) {
      std::ostringstream ss;
      ss << "Number of muons with ADC HG cannot calculated for counter with no calibrated modules " << fId;
      WARNING(ss);
      return -1;
    }

    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im)
      if (im->HasRecData() && im->GetRecData().IsADCCalibratedHG()) {
          const double moduleSigma = im->GetRecData().GetNumberOfMuonsADCErrorHighHG();
          counterVariance += (moduleSigma*moduleSigma);
      }

    return sqrt(counterVariance);
  }


  double
  Counter::GetNumberOfMuonsErrorLowHG()
    const
  {
    double counterVariance = 0;

    // muons can only be estimated for modules with data and unsaturated
    if (!IsADCCalibratedHG()) {
      std::ostringstream ss;
      ss << "Number of muons with ADC HG cannot calculated for counter with no calibrated modules " << fId;
      WARNING(ss);
      return -1;
    }

    for (ModuleConstIterator im = fModules.Begin(); im != fModules.End(); ++im)
      if (im->HasRecData() && im->GetRecData().IsADCCalibratedHG()) {
        const double moduleSigma = im->GetRecData().GetNumberOfMuonsADCErrorLowHG();
        counterVariance += (moduleSigma*moduleSigma);
      }

    return sqrt(counterVariance);
  }


  double
  Counter::GetMuonDensityHG()
    const
  {
    if (!IsADCCalibratedHG()) {
      std::ostringstream ss;
      ss << "Density of muons cannot be calculated with ADC HG for counter with no calibrated modules " << fId;
      WARNING(ss);
      return -1;
    }

    const double density = GetNumberOfEstimatedMuonsHG() / GetActiveAreaHG();

    return density;
  }


  double
  Counter::GetMuonDensityErrorHighHG()
    const
  {
    if (!IsADCCalibratedHG()) {
      std::ostringstream ss;
      ss << "Density of muons cannot be calculated with ADC HG for counter with no calibrated modules " << fId;
      WARNING(ss);
      return -1;
    }

    const double counterSigma = GetNumberOfMuonsErrorHighHG() / GetActiveAreaHG();

    return counterSigma;
  }


  double
  Counter::GetMuonDensityErrorLowHG()
    const
  {
    if (!IsADCCalibratedHG()) {
      std::ostringstream ss;
      ss << "Density of muons cannot be calculated with ADC HG for counter with no calibrated modules " << fId;
      WARNING(ss);
      return -1;
    }

    const double counterSigma = GetNumberOfMuonsErrorLowHG() / GetActiveAreaHG();

    return counterSigma;
  }

}