ShowerInventor.h

Go to the documentation of this file.

#ifndef _ShowerInventor_h_
#define _ShowerInventor_h_

#include <fwk/VModule.h>
#include <evt/Event.h>

#include <utl/VShowerFileParticleIterator.h>
#include <utl/Particle.h>

#include <utl/RandomEngine.h>
#include <utl/VRandomSampler.h>
#include <utl/AugerCoordinateSystem.h>

#include <vector>
#include <list>


namespace utl {
  class Particle;
  class Plane;
  class Branch;
}

namespace evt {
  class Event;
  class ShowerSimData;
}

class TH1;
class TH2;

namespace ShowerInventorNS {

  class ShowerInventorParticleIterator;

  class ShowerInventor : public fwk::VModule {

  public:
    ShowerInventor();
    virtual ~ShowerInventor() { }

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

    utl::Particle* GetOneParticle();

    unsigned int GetNumRequestedParticles() const
    { return fTotalNumRequestedParticles; }

    utl::CoordinateSystemPtr GetExternalCS() const
    { return fShowerLocalCS; }

  private:
    utl::VRandomSampler* GetSampler(const utl::Branch& b);

    void FillCaches();

    utl::RandomEngine::RandomEngineType* fRandomEngine;

    std::vector<double> fZeniths;
    double fAzimuth;
    double fCoreNorthing;
    double fCoreEasting;
    double fCoreAltitude;

    utl::CoordinateSystemPtr fShowerCS;
    utl::CoordinateSystemPtr fShowerLocalCS;

    utl::Particle* fCurrentParticle;

    ShowerInventorParticleIterator* fFileIterator;
    unsigned int fTotalNumRequestedParticles;

    utl::Plane* fGroundPlane;
    utl::Point* fCoreLocation;

    typedef std::vector<double> RandomCacheContainer;

    // Contains various random distributions for each
    // particle type.

    struct ParticleDistInfo {

      // Number of particles requested
      unsigned int numRequestedParticles;

      // Number of particles generated
      unsigned int numGeneratedParticles;

      // Cache pointer. Not necessarily the same as numGeneratedParticles
      // depending on details of the caching
      unsigned int cachePosition;

      // What kind of particle do these distributions correspond to
      int particleType;

      // Samplers used to produce various random distributions
      utl::VRandomSampler* radialDistro;
      utl::VRandomSampler* azimuthDistro;
      utl::VRandomSampler* timeDistro;
      utl::VRandomSampler* weightDistro;

      // Caches of random numbers for various distributions.
      // The caches are used in an attempt to increase speed a bit.
      RandomCacheContainer* radiusRandomCache;
      RandomCacheContainer* azimuthRandomCache;
      RandomCacheContainer* timeRandomCache;
      RandomCacheContainer* weightRandomCache;
    };

    std::vector<ParticleDistInfo> fParticleDistros;

    double fCurrentZenith;
    unsigned int fCurrentZenithIndex;

    ParticleDistInfo fCurrentPDI;
    unsigned int fCurrentDistIndex;

    unsigned int fRandomCacheMaxSize;

    // Stuff for diagnostic plots

    bool fDiagnosticsOn;
    std::string fDiagnosticsFileName;

    TH2* fStationPosGroundCS;

    evt::Event* fCurrentEvent;
    
    struct DiagnosticHistos {
      TH1* radialDistro;
      TH1* azimuthDistro;
      TH1* timeDistro;
      TH1* weightDistro;
      TH2* positionsShowerCS;
      TH2* positionsGroundCS;
    };

    std::map<int, DiagnosticHistos> fDiagnosticHistos;

    REGISTER_MODULE("ShowerInventorNEU", ShowerInventor);

  };

}


#endif