EDEPTrajectory.h

#ifndef EDEPTRAJECTORY_H
#define EDEPTRAJECTORY_H
 
#include <iostream>
 
#include "EDEPHit.h"
#include "EDEPTrajectoryPoint.h"
 
#include <TGeoManager.h>
 

class EDEPTrajectory {
  
  public:
    // Constructors
    EDEPTrajectory() : p0_(0,0,0,0), parent_trajectory_(nullptr),
                       id_(-1), parent_id_(-99), pdg_code_(0) {};
    
    EDEPTrajectory(const TG4Trajectory& trajectory) : p0_(trajectory.GetInitialMomentum()),
                                               parent_trajectory_(nullptr) ,
                                               id_(trajectory.GetTrackId()), 
                                               parent_id_(trajectory.GetParentId()), 
                                               pdg_code_(trajectory.GetPDGCode()) {};
    
    EDEPTrajectory(const TG4Trajectory& trajectory, const std::map<int, std::map<component, std::vector<EDEPHit>>>& hit_map, const TG4PrimaryVertexContainer& primaries, TGeoManager* geo);
 
    EDEPTrajectory(const EDEPTrajectory& trj);
    EDEPTrajectory(EDEPTrajectory&& trj);
    ~EDEPTrajectory() {};
    
    // Operators
    bool operator==(const EDEPTrajectory& trj);
    
    EDEPTrajectory& operator=(const EDEPTrajectory& trj);
    
    EDEPTrajectory& operator=(EDEPTrajectory&& trj);
    
    // Getters

    EDEPTrajectory* Get()       {return this;};
    
    const EDEPTrajectory* Get() const {return this;};

    EDEPTrajectory* GetParent() const {return parent_trajectory_;};
    
    int GetId()       const {return id_;};
    
    int GetDepth()    const {return depth_;};
    
    int GetInteractionNumber()    const {return interaction_number_;};

    std::string GetReaction()    const {return reaction_;};
    
    int GetParentId() const {return parent_id_;};
    
    int GetPDGCode()  const {return pdg_code_;};
 
 
    std::vector<EDEPTrajectoryPoint>& GetFirstPointsInDetector(component component_name);
    std::vector<EDEPTrajectoryPoint>& GetLastPointsInDetector(component component_name);
    
    TLorentzVector GetInitialMomentum()  const {return p0_;};

    std::vector<EDEPTrajectory>& GetChildrenTrajectories()       {return children_trajectories_;};
    
    const std::vector<EDEPTrajectory>& GetChildrenTrajectories() const {return children_trajectories_;};

    const EDEPHitsMap& GetHitMap() const {return hit_map_;};
    
    const EDEPTrajectoryPoints& GetTrajectoryPoints() const {return  trajectory_points_;};
    
    std::vector<EDEPTrajectoryPoint> GetTrajectoryPointsVect() const;

    std::vector<EDEPTrajectoryPoint> GetTrajectoryPointsInComponentVect(component component_name) const;
 
    // Setters
    
    void SetId(int id) {id_ = id;};
    
    void SetDepth(int depth) {depth_ = depth;};
    
    void SetParentId(int parent_id) {parent_id_ = parent_id;};
    
    void SetParent(EDEPTrajectory* parent_trajectory) {parent_trajectory_ = parent_trajectory;};
    
    // Other

    void AddChild(const EDEPTrajectory& trajectory) {
      children_trajectories_.push_back(trajectory); 
      children_trajectories_.back().SetParent(this);
    };
    bool RemoveChildWithId(int child_id);
 
    void ComputeDepth();
 
    // Utilities
    bool HasHits() const {return !hit_map_.empty();}
    bool HasHitWithId(int id) const;
    bool HasHitInDetector(component component_name) const;
    std::vector<EDEPHit> GetHitsInDetector(component component_name) const;
    double GetPrimaryDepositedEnergy(component component_name);
    double GetDepositedEnergy(component component_name);
    double GetTotalDepositedEnergy();
    double GetRecursivePrimaryDepositedEnergy(component component_name);
    double GetRecursiveDepositedEnergy(component component_name);
    double GetTotalRecursiveDepositedEnergy();
    bool HasHitBeforeTime(double start_time) const;
    bool HasHitAfterTime(double stop_time) const;
    bool IsTrajectorySaturated() const;
 
    bool HasHitInTime(double start_time, double stop_time) const;
    bool HasHitWithIdInDetector( int id, component component_name) const;
 
    bool HasHitNearPoint(TVector3 point, double distance) const;
    bool HasHitNear4DPoint(TLorentzVector point, double distance, double time) const;
    std::vector<EDEPHit>::iterator GetHitNear4DPoint(TLorentzVector point, double distance, double time);
    
    std::string Print(std::string& full_out, int depth = 100, int current_depth = 0) const;
    
    bool IsEntering(component component_name) const;
    bool IsExiting(component component_name) const;
    component GetStartDetector() const;
    bool StartsInDetector(component component_name) const;
 
    template<typename Funct> bool HasHitWhere(Funct&& f) const {
      for(const auto& hits:hit_map_) {
        for(const auto& hit:hits.second) {
          if (f(hit)) {
            return true;
          }
        }
      }
      return false;
    }
 
    template<typename Funct> std::vector<EDEPHit>::iterator GetHitWhere(Funct&& f) {
      for(auto& hits:hit_map_) {
        for(auto it =  hits.second.begin();
                 it != hits.second.end(); ++it) {
          if (f(*it)) {
            return it;
          }
        }
      }
      return hit_map_.rbegin()->second.end();
    }
 
    bool Match(std::string volume, std::initializer_list<std::string> names) const;
 
    void CheckInNext(bool* in, bool* next, TG4TrajectoryPoint it, TG4TrajectoryPoint next_it);
 
    friend class EDEPTree;
 
  private:
    TLorentzVector p0_;                                  
    EDEPHitsMap hit_map_;                                
    EDEPTrajectoryPoints trajectory_points_;             
    std::vector<EDEPTrajectory> children_trajectories_;  
    std::map<component, bool> exiting_map_;              
    std::map<component, bool> entering_map_;             
    EDEPTrajectoryPoints last_points_;                   
    EDEPTrajectoryPoints first_points_;                  
    EDEPTrajectory* parent_trajectory_;                  
    int id_;                                             
    int parent_id_;                                      
    int pdg_code_;                                       
    int depth_;                                          
    int interaction_number_ = -1;                        
    std::string reaction_ = "";                          
 
};
 
 
 
 
 
#endif