ParticleInjectorNEU/ParticleInjector.h

Go to the documentation of this file.

#ifndef _ParticleInjectorNEU_ParticleInjector_h_
#define _ParticleInjectorNEU_ParticleInjector_h_

#include <string>
#include <vector>

#include <fwk/VModule.h>

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


namespace evt {
  class Event;
}

namespace sevt {
  class Station;
}

namespace utl {
  class Branch;
  class RandomEngine;
  class VRandomSampler;
}


namespace ParticleInjectorNEU {

  class ParticleInjector : public fwk::VModule {

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

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

    static const double fgFarAway2;

  private:
    enum PositionFlag {
      eNone,
      eFixed,
      eDisk,
      eSphere,
      ePDF
    };

    struct RandomPart {
      int fSecondaryId = 0;
      double fPx = 0;
      double fPy = 0;
      double fPz = 0;
    };

    void ParticleInjectorConfiguration();
    utl::VRandomSampler* LoadRandomSampler(const utl::Branch& branch);

    void InjectParticles(sevt::Station& station);

    double GenerateAzimuth();
    double GenerateZenith();
    double GenerateEnergy(const utl::Particle::Type particle, const int i);
    double GenerateTime();

    void GeneratePosition(double& x, double& y, double& z);

    // switches
    PositionFlag fPositionFlag = eNone;
    bool fUseSingleTank = false;

    bool fCreateEvent = false;
    unsigned int fSingleTankID = 0;

    double fX = 0;
    double fY = 0;
    double fZ = 0;

    std::vector<double> fDiscreteAzimuth;
    std::vector<double> fDiscreteZenith;
    std::vector<double> fDiscreteParticleTime;

    std::vector<double> fFixedEnergy;

    std::string fContinuousZenithString;
    std::string fContinuousAzimuthString;
    std::string fContinuousTimeString;

    utl::VRandomSampler* fXDistribution = nullptr;
    utl::VRandomSampler* fYDistribution = nullptr;
    utl::VRandomSampler* fZDistribution = nullptr;

    utl::VRandomSampler* fZenithDistribution = nullptr;
    utl::VRandomSampler* fAzimuthDistribution = nullptr;

    std::vector<utl::Particle::Type> fParticles;

    utl::TimeStamp fEventTime;

    utl::RandomEngine::RandomEngineType& fRandomEngine;

    double fRadius = 5*utl::meter;
    double fHeight = 1.5*utl::meter;
    utl::VRandomSampler* fDefaultEnergyDistribution = nullptr;
    utl::VRandomSampler* fMuonEnergyDistribution = nullptr;
    utl::VRandomSampler* fElectronEnergyDistribution = nullptr;
    utl::VRandomSampler* fGammaEnergyDistribution = nullptr;

    std::string fPropagate = "no";

    // tree and structure for the particles backgound
    // file from Xavier transformed in a TTree file

    TChain* fRandomTree = nullptr;
    RandomPart fRandomParticle;
    bool fRandomEntries = false;
    unsigned int fNumberOfEntries = 0;
    unsigned int fMinMomentum = 0;

    REGISTER_MODULE("ParticleInjectorNEU", ParticleInjector);

  };

}


#endif