/**
 * @file SolidRunAction.hh
 * @author: (modified by) Ibrahin Pinera
 * @date 2016 SoLid - University of Antwerp
 */


#ifndef SolidRunAction_h
#define SolidRunAction_h 1

#include "G4UserRunAction.hh"
#include "SolidEventAction.hh"
#include "globals.hh"
#include <vector>


class TTree;
class TFile;
class TBranch;

class SolidRunMessenger;

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....

class G4Run;

/** @class SolidRunAction
 *  Run Action class
 *  @author Sakari Ihantola <sakari.ihantola@physics.ox.ac.uk>
 *  @author Ibrahin Pinera (modified)
 */

/// Run action
class SolidRunAction : public G4UserRunAction
{
public:
    /** Standard constructor
     *  @param outp_     root output file
     */
    SolidRunAction(TFile*);                     ///< Standard constructor

    /* Default destructor
     */
    virtual ~SolidRunAction();                  ///< Default destructor
    
public:
    void BeginOfRunAction(const G4Run*);        ///< "Begin of run" action
    void EndOfRunAction(const G4Run*);          ///< "End of run" action
    
    void UpdateTracking(void);                  ///< Fill tracking tree
    void UpdateStatistics(RunTally);            ///< Fill trees
    void SaveFile(G4int);                       ///< Write treees into the output root file
    void SetSeed(G4long seed) { fSeed = seed; }  ///< Set randon number seed
    G4long GetSeed() { return fSeed; }           ///< Get random number seed
    
    inline void SetStoreT2 (const G4bool val) {m_storeT2 = val;}
    inline void SetStoreT6 (const G4bool val) {m_storeT6 = val;}
    inline void SetStoreT7 (const G4bool val) {m_storeT7 = val;}
    inline void SetStoreT8 (const G4bool val) {m_storeT8 = val;}
    inline void SetStoreT9 (const G4bool val) {m_storeT9 = val;}
    inline void SetStoreT9cut (const G4int val) {m_storeT9cut = val;}
    inline void SetStoreNevt (const G4int val) {m_storeNevt = val;}
  
    G4bool IsT2Stored() { return m_storeT2; }
    G4bool IsT6Stored() { return m_storeT6; }
    G4bool IsT7Stored() { return m_storeT7; }
    G4bool IsT8Stored() { return m_storeT8; }
    G4bool IsT9Stored() { return m_storeT9; }
    G4int GetT9cut()    { return m_storeT9cut; }
    G4int GetNevt()     { return m_storeNevt; }
 
    G4double DepositedSoFar;
    G4int NeutronStepCount, PositronStepCount, nGeneratedTrackID, istherm,
        checkTrackID, particleStepCount;
    G4int CubeNumber;
    G4double thePreEne;
    G4bool NeutronEnteringCube;
    G4bool checkEnteredDetector;
    G4double triggerTime;
    int InitVol;
    int InitCube;
    G4int pvtCollID;

    // T1 tree variables
    std::vector<int> primary_pdgid;
    std::vector<double> primary_energy;
    std::vector<double> primary_posx;
    std::vector<double> primary_posy;
    std::vector<double> primary_posz;
    std::vector<double> primary_momx;
    std::vector<double> primary_momy;
    std::vector<double> primary_momz;
    std::vector<int> primary_vol;
    std::vector<int> primary_cube;
    std::vector<int> primary_cubex;
    std::vector<int> primary_cubey;
    std::vector<int> primary_cubez;

  
    // T2 tree variables
    double CapEneLi;             ///< Lithium capture energy
    double CapEnePVT;            ///< PVT capture energy
    double ModTime;              ///< Moderation time
    double ThermalTime;          ///< Thermal time
    double CaptureTime;          ///< Capture time
    double ThermalRadius;        ///< Thermal radius
    double ModDistance;          ///< Module distance
    double CaptureDistance;      ///< Capture distance
    int NScatter;                ///< Number of scatterings
    int CaptureVol;                  ///< Neutron cap volume
    int CaptureCube;                  ///< Neutron cap volume
    double NeutronDeltaR;                ///< deltaR (ibd -> capture)

    double InitPosX;                      ///< x coordinate of ibd vertex
    double InitPosY;                      ///< y coordinate of ibd vertex
    double InitPosZ;                      ///< z coordinate of ibd vertex
    double PositronEndX;                  ///< x coordinate of positron track end
    double PositronEndY;                  ///< y coordinate of positron track end
    double PositronEndZ;                  ///< z coordinate of positron track end
    double PositronDistance;              ///< Distance of positron track
    double AnnihilationTime;              ///< Annihilation time
    int    AnnihilationCube;              ///< Annihilation cube
    int    AnnihilationVol;               ///< Annihilation volume
    double PositronDeltaR;                ///< deltaR (ibd -> annih)

    double ibdDeltaT;                ///< deltaT (e+ annih -> n cap)
    double ibdDeltaR;                ///< deltaR (e+ annih -> n cap)

    // T5 tree variables
    std::vector<int> cubenumber;           ///< Cube ID number
    std::vector<int> cubeXPosition;        ///< Cube x position
    std::vector<int> cubeYPosition;        ///< Cube y position
    std::vector<int> cubeZPosition;        ///< Cube z position
    std::vector<int> pdg;                  ///< PDG code of hit
    std::vector<int> partID;               ///< trackID code of hit
    std::vector<int> mothID;               ///< parent trackID code of hit  
    std::vector<double> edepTot;           ///< Total energy deposit
    std::vector<double> edepPvt;           ///< Energy deposit in PVT
    std::vector<double> edepLi;            ///< Energy deposit in Li6
    std::vector<double> timeOfDemise;      ///< Time
    std::vector<double> distanceTravelled; ///< Distance

    // T6 tree variables
    std::vector<int>    partPDG;            ///< particle ID
    std::vector<int>    partTrackID;       ///< Track ID
    std::vector<int>    partParentID;      ///< Parent Track ID
    std::vector<double> partEnergy;        ///< Energy
    std::vector<double> partDeposited;     ///< Energy depositions
    std::vector<double> partX;             ///< posX
    std::vector<double> partY;             ///< posY
    std::vector<double> partZ;             ///< posZ
    std::vector<double> partTime;          ///< elapsed time
    std::vector<int>    partCubeID;        ///< Cubes ID
    std::vector<int>    partCubeX;         ///< Cubes X
    std::vector<int>    partCubeY;         ///< Cubes Y
    std::vector<int>    partCubeZ;         ///< Cubes Z
    std::vector<int>    partVolID;         ///< volume ID

    // T7 tree variables
    std::vector<int>    enteringPartID;    ///< particle ID
    std::vector<int>    enteringTrackID;   ///< Track ID
    std::vector<int>    enteringParentID;  ///< Parent Track ID
    std::vector<double> enteringEnergy;    ///< Energy
    std::vector<double> enteringX;         ///< posX
    std::vector<double> enteringY;         ///< posY
    std::vector<double> enteringZ;         ///< posZ
    std::vector<double> enteringXmom;      ///< momX
    std::vector<double> enteringYmom;      ///< momY
    std::vector<double> enteringZmom;      ///< momZ
    std::vector<double> enteringTime;      ///< elapsed time
    std::vector<int>    enteringPreVolID;  ///< volume ID from where is coming
    std::vector<int>    enteringPostVolID; ///< volume ID where it enters

    // T8 tree variables
    std::vector<int> nGenerationTrackID;   ///< track id for generated neutron
    std::vector<int> nGenerationParentID;   ///< parent id for generated neutron
    std::vector<double> nGenerationEnergy; ///< energy of generated neutrons
    std::vector<double> nGenerationPosX;   ///< position x for generated neutron
    std::vector<double> nGenerationPosY;   ///< position y for generated neutron
    std::vector<double> nGenerationPosZ;   ///< position z for generated neutron
    std::vector<double> nGenerationTime;   ///< elapsed time for generated neutron
    std::vector<int> nGenerationCube;      ///< cube id for generated neutron
    std::vector<int> nGenerationVol;       ///< volume id for generated neutron
    std::vector<std::string> nGenerationProcess;       ///< creator process name for generated neutron


   // T9 tree variable
   std::vector<int> summaryPartPDG;  ///< partPDG
   std::vector<int> summaryAllPDG;  ///<  (temp vector of partID for finding parentPDG)
   std::vector<int> summaryAllPartID;  ///< partID (temp vector for finding parentPDG) 
   std::vector<int> summaryPartID;   ///< part track ID 
   std::vector<int> summaryParentID; ///< mother trackID
  std::vector<int> summaryParentPDG; ///< mother PDG
  
   std::vector<unsigned int> summaryNsteps;  ///< Number of total steps 
   std::vector<unsigned int> summaryNcubes;  ///< Number of hit cubes 
   std::vector<unsigned int> summaryNCompton; ///< number of compton
   std::vector<unsigned int> summaryNBrem;  ///< number of Bremsthralung 
   std::vector<unsigned int> summaryNIonisation; ///< number of Ionisation processes 
  //   std::vector<std::string> summaryCreatorProcess; ///< creator process
  //  std::vector<std::string> summaryLastProcess; ///< last process
   std::vector<unsigned int> summaryCreatorProcessID; ///< creator process
   std::vector<unsigned int> summaryLastProcessID; ///< last process
  
   std::vector<double> summaryInitialEkin; ///< initial kinetic energy of the particle
   std::vector<int> summaryFirstVol; ///< ID of the first volume or cubeID
   std::vector<int> summaryLastVol; ///< ID of the last volume or cube ID
   std::vector<bool> summaryGoodEntry; ///< true if the particle touched at least one of the VolID < 90 
   std::vector<int> listCubes;  ///< list of cubes tmp
   std::vector<double> summaryPosX; /// position x of the particle LastStep
   std::vector<double> summaryPosY; /// position y of the particle LastStep
   std::vector<double> summaryPosZ; /// position z of the particle LastStep
  
private:
    RunTally Stats;
    G4long fSeed;           ///< Random number seed

    TFile *outp;           ///< Output root file

    TTree *T0;             ///< Tree for simulation setup information
    TTree *T1;             ///< Tree for IBD conditions
    TTree *T2;             ///< Tree for neutron information
    TTree *T5;             ///< Tree for cube-level information from sensitive detectors
    TTree *T6;             ///< Tree for particles tracking info
    TTree *T7;             ///< Tree for particles entering the detector volume
    TTree *T8;             ///< Tree for spallation neutrons generation by muons
    TTree *T9;             ///< Tree with MC truth information

    G4bool m_storeT2;
    G4bool m_storeT6;
    G4bool m_storeT7;
    G4bool m_storeT8;
    G4bool m_storeT9;

    G4int m_storeT9cut;
    G4int m_storeNevt;
  
    SolidRunMessenger* m_raMess;

    TBranch *RunBranch;
    time_t start;          ///< Start time of simulation. It will be used to calculate run time at the end of run.
    
    float conv_CapPos[3];
    float conv_ThermPos[3];
    float conv_InitPos[3];
    float conv_InitVec[3];

};

#endif