CachedShowerRegeneratorOG/CachedShowerRegenerator.h

Go to the documentation of this file.

#ifndef _CachedShowerRegeneratorOG_CachedShowerRegenerator_h_
#define _CachedShowerRegeneratorOG_CachedShowerRegenerator_h_

#include <map>

#include <fwk/VModule.h>
#include <utl/Particle.h>
#include <utl/RandomEngine.h>
#include <utl/ShadowPtr.h>
#include <utl/ShowerParticleIterator.h>
#include <utl/Accumulator.h>
#include <utl/TimeDistribution.h>
#include <utl/AugerUnits.h>
#include <boost/tuple/tuple.hpp>
#include "StationPositionMatrix.h"
#include "LogGaussSmearing.h"


namespace utl {
  class ShowerParticleIterator;
  class TimeInterval;
  class TabulatedFunction;
}


namespace CachedShowerRegeneratorOG {

  class LogGaussSmearing;


  class ShowerData {
  public:
    ShowerData(const StationPositionMatrix& matrix) :
      fStationMatrix(matrix)
    { }

    typedef std::map<int, int> StationParticleMap;
    typedef utl::Accumulator::MinMax<utl::TimeInterval> TimeStat;
    typedef std::map<int, TimeStat> TimeStatMap;
    typedef utl::Accumulator::MinMaxAverage<double> WeightStat;
    typedef std::map<int, WeightStat> WeightStatMap;
    typedef std::map<unsigned int, double> WeightCounterMap;

    utl::ShowerParticleIterator fParticleIt;
    utl::ShowerParticleIterator fParticlesEnd;
    StationParticleMap fTopParticles;
    StationParticleMap fSideParticles;
    StationParticleMap fUpwardSideParticles;
    TimeStatMap fTimeStat;
    WeightStatMap fWeightStat;
    StationPositionMatrix fStationMatrix;
    int fNHorizontalParticles = 0;
    double fMinSqrR = 0;
    utl::ShadowPtr<LogGaussSmearing> fLogGauss;
    WeightCounterMap fWeightCounterMap;
  };


  class CachedShowerRegenerator : public fwk::VModule {
  public:
    CachedShowerRegenerator() { }

    VModule::ResultFlag Init();
    VModule::ResultFlag Run(evt::Event& event);
    VModule::ResultFlag Finish() { return fwk::VModule::eSuccess; }

  private:
    bool IsParticleEnergyLow(const int type, const double energy) const;

    void InitNewShower(evt::Event& event);

    void OutputStats(evt::Event& event);

    // Parameters taken from xml file

    bool fLimitParticlesPerCycle = false;
    unsigned int fParticlesPerCycle = 0;

    bool fUseWeightedStationSimulation = false;
    unsigned int fWeightedStationSimulationParticleLimit = 0;
    double fWeightedStationSimulationThinningFactor = 0.5;

    double fInnerRadiusCut = 0;
    double fOuterRadiusCut = 1e6*utl::km;

    double fElectronEnergyCut = 0;
    double fMuonEnergyCut = 0;
    double fPhotonEnergyCut = 0;
    double fHadronEnergyCut = 0;
    double fMesonEnergyCut = 0;

    double fDeltaROverR = 0;
    double fDeltaPhi = 0;
    double fHorizontalParticleCut = 0;
    bool fUseStationPositionMatrix = true;
    double fPhiGranularity = 0;
    double fRGranularity = 0;
    double fLogGaussSmearingWidth = 0;
    bool fUseWeightDependentResamplingArea = true;

    double fMuonWeightScale = 1;

    utl::RandomEngine::RandomEngineType* fRandomEngine = nullptr;

    // If UMD need to be simulated, injectcion of particles is onle on top of an increased cylinder.
    bool fSimulateUMD = false;
    double fUMDTightRadius = 0;
    double fUMDMaxRadius = 0;

    // If MARTA RPC needs to be simulated, injectcion of particles is made on a bigger radius cylinder
    bool fSimulateMARTA = false;
    double fMARTARadius = 0;

    utl::ShadowPtr<ShowerData> fShowerData;

    REGISTER_MODULE("CachedShowerRegeneratorOG", CachedShowerRegenerator);
  };

}


#endif