CachedXShowerRegenerator.h

Go to the documentation of this file.

#ifndef _CachedXShowerRegeneratorAG_CachedXShowerRegenerator_h_
#define _CachedXShowerRegeneratorAG_CachedXShowerRegenerator_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 "StationXPositionMatrix.h"
#include "LogXGaussSmearing.h"

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

namespace CachedXShowerRegeneratorAG {

  class LogXGaussSmearing;

  class ShowerData {
  public:

    ShowerData(const StationPositionMatrix& matrix):
      fStationMatrix(matrix),
      fNHorizontalParticles(0),
      fMinR2(0) {}

    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;
    double fMinR2;
    utl::ShadowPtr<LogXGaussSmearing> fLogXGauss;
    WeightCounterMap fWeightCounterMap;

  };


  class CachedXShowerRegenerator : public fwk::VModule {
  public:
    CachedXShowerRegenerator();

    VModule::ResultFlag Init();
    VModule::ResultFlag Run(evt::Event& event);
    VModule::ResultFlag Finish();

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

    void InitNewShower(evt::Event& event);

    void OutputStats(evt::Event& event);

    boost::tuple<unsigned int, double> 
    ParticleNumberAndWeight(const double&, const int&);
      
    // Parameters taken from xml file

    unsigned int fMaxParticles;

    double fInnerRadiusCut;
    double fOuterRadiusCut;

    double fElectronEnergyCut;
    double fMuonEnergyCut;
    double fPhotonEnergyCut;
    double fHadronEnergyCut;
    double fMesonEnergyCut;

    double fDeltaROverR;
    double fDeltaPhi;
    double fHorizontalParticleCut;
    bool fUseStationPositionMatrix;
    double fPhiGranularity;
    double fRGranularity;
    double fLogXGaussSmearingWidth;

    bool   fUseInjectionStop;
    double fInjectionStop;
    utl::TabulatedFunction* fMuToVem;
    utl::TabulatedFunction* fEToVem;

    bool   fUseWeightLimiting;

    double fWeightThreshold;
    double fAccumulatedWeightLimit;
    double fMuonWeightScale;


    utl::RandomEngine::RandomEngineType* fRandomEngine;

    double fTimeSlotSize;
    unsigned int fNOutOfRangeWeight;
    double fWeightLimit;

    bool fSimulateAmiga;
    double fAmigaRadius;

    utl::ShadowPtr<ShowerData> fShowerData;

    int unityWeightCtr;  // TEMP
    int largeWeightCtr;  // TEMP

    REGISTER_MODULE("CachedXShowerRegeneratorAG", CachedXShowerRegenerator);
  };

} 

#endif


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