RdZHAireSSimPreparator.h

Go to the documentation of this file.

#ifndef _RdZHAireSSimPreparator_RdZHAireSSimPreparator_h_
#define _RdZHAireSSimPreparator_RdZHAireSSimPreparator_h_

#include <fwk/VModule.h>
#include <utl/CoordinateSystem.h>
#include <utl/TimeStamp.h>
#include <utl/GeometryUtilities.h>
#include <utl/Math.h>
#include <string>
#include <vector>
#include <fstream>


namespace utl {
  class RandomEngine;
}

namespace evt {
  class Event;
  class ShowerRecData;
  class Header;
}

namespace revt {
  class Header;
}

struct Set {
  int fNumberOfCards;
  std::string fPrimary;
};


namespace RdZHAireSSimPreparator {

  enum EPrimary {
    eProton,
    eIron
  };


  class RdZHAireSSimPreparator : public fwk::VModule {

  public:
    RdZHAireSSimPreparator() { }
    virtual ~RdZHAireSSimPreparator() { }
    fwk::VModule::ResultFlag Init() override;
    fwk::VModule::ResultFlag Run(evt::Event& event) override;
    fwk::VModule::ResultFlag Finish() override;

    static
    double
    AugerAzimuthToZHAireS(const double augerAzimuth, double kMagneticFieldDeclination)
    {
      //const double kMagneticFieldDeclination = fMagDeclination*degree;
      return utl::NormalizeAngleMinusPiPi(augerAzimuth - 90*utl::deg + kMagneticFieldDeclination);
    }

    static
    void
    Rotatez(const double theta, const double vi[], double vf[])
    {
      const double costet = cos(theta);
      const double sintet = sin(theta);
      vf[0] = vi[0]*costet - vi[1]*sintet;
      vf[1] = vi[0]*sintet + vi[1]*costet;
      vf[2] = vi[2];
    }

  private:
    std::string GetEventNumber(const std::string& eventid);  // extract the SD event Number from the AUGER ID
    std::string AddZero(const int runID, const int numberofdigit);  // Return runNumber as 000042

    //int fgsRunNumber;  // static because the module might be called N-Time
    int fStartRunNumber = 0;
    float fMaxDistance = 0;
    std::string fPrim;  // could not implement .xsd correctly to include this
    std::string fWorkingDir;
    double fBIntensity = 0;
    double fMagInclination = 0;
    double fMagDeclination = 0;

    // from reas
    std::string fEventHeader;

    utl::RandomEngine* fRandomEngine = nullptr;

    bool fNewZhaires = false;
    
    bool fGenerateCardsWithoutEvent = false;
    utl::TimeStamp fTimeGeneratedEvent;
    double fZenithLowGeneratedEvent = 0;
    double fZenithHighGeneratedEvent = 0;
    double fAzimuthLowGeneratedEvent = 0;
    double fAzimuthHighGeneratedEvent = 0;
    double fEnergyLowGeneratedEvent = 0;
    double fEnergyHighGeneratedEvent = 0;
    double fEnergySlopeGeneratedEvent = 0;

    // from reas
    bool fUseCoreDist = false;
    bool fModelMagField = false;
    double fMagFieldDec = 0;
    double fMagFieldX = 0;
    double fMagFieldY = 0;

    double fThinEnergy = 0;
    double fThinWFactor = 0;

    std::string fUseGeometry;
    std::string fUseEnergy;

    // copied from Modules/FdSimulation/ProfileSimulatorOG/ProfileSimulator.cc
    double PowerLaw(const double min, const double max, const double index) const;

    // Randomly choose SD station with full crown around it and draw
    // core around this station with GenerateCoreAroundStation()
    void GenerateCoreAroundRandomSDStation(utl::Point& theCore);

    // draw core in inner hexagon around this station (core for which this station is closest)
    void GenerateCoreAroundStation(const utl::Point& center, const std::vector<utl::Point>& crownStations, utl::Point& core);

    void CreateFiles(const utl::Vector& axis,
                     const float energy,
                     const utl::Point& core,
                     const utl::TimeStamp time,
                     const std::string& eventId,
                     const int rEventId,
                     const int runId,
                     const std::string& runNumber,
                     const std::string& primaryType);

    // TEST LOG
    std::ofstream fLogfile;

    std::vector<Set> fSimulationSets;

    REGISTER_MODULE("RdZHAireSSimPreparator", RdZHAireSSimPreparator);

  };

}


#endif