PndSttCellTrackFinderData.h

Go to the documentation of this file.

/*
 * PndSttCellTrackFinderData.h
 *
 *  Created on: May 8, 2014
 *      Author: schumann
 */

#ifndef PNDSTTCELLTRACKFINDERDATA_H_
#define PNDSTTCELLTRACKFINDERDATA_H_

#include <vector>
#include <map>

#include "TVector3.h"
#include "PndSttGeometryMap.h"
#include "PndSttStrawMap.h"
#include  "FairHit.h"

class TClonesArray;
class PndSttSkewedHit;

class PndSttCellTrackFinderData {

public:

        PndSttCellTrackFinderData(TClonesArray* fTubeArray);

        virtual ~PndSttCellTrackFinderData() {
                delete fStrawMap;
                delete fGeometryMap;
                for (size_t i = 0; i < fHits.size(); ++i)
                        delete fHits.at(i);
                for (size_t i = 0; i < fHitsOrig.size(); ++i)
                        delete fHitsOrig.at(i);

        }
// only support STTHits , uses brachNAme to distinguish between normal and skewed straws

        void AddHits(TClonesArray* hits, TString branchName);

        void GenerateNeighborhoodData();

        void clear() {
                fHits.clear();
                fHitsOrig.clear();
                fMapHitToFairLink.clear();
                fMapTubeIdToHit.clear();
                fHitNeighbors.clear();
                fSeparations.clear();
                fCombinedSkewedHits.clear();
                fHitNeighborsWithoutEdges.clear();
                fSeparationsWithoutEdges.clear();
                fHitNeighborsWithoutSkewed.clear();
                fSeparationsWithoutSkewed.clear();
        }

        void PrintInfo();

        void SetAllowDoubleHits(Bool_t value){
                fAllowDoubleHits=value;
        }

        Bool_t GetAllowDoubleHits(){
                        return fAllowDoubleHits;
                }

        std::vector<FairHit*> GetHits() const {
                return fHits;
        }

        std::multimap<int, PndSttSkewedHit*> GetCombinedSkewedHits() const {
                return fCombinedSkewedHits;
        }

        PndSttStrawMap* GetStrawMap() const {
                return fStrawMap;
        }

        PndSttGeometryMap* GetGeometryMap() const {
                return fGeometryMap;
        }

        std::map<int,FairLink> GetMapHitToFairLink() const{
                return fMapHitToFairLink;
        }

        std::map<int, int> GetMapTubeIdToHit() const {
                return fMapTubeIdToHit;
        }

        std::map<int, TVector3> GetMapTubeIdToPos() const {
                return fMapTubeIdToPos;
        }

        std::map<int, std::vector<int> > GetHitNeighbors() const {
                return fHitNeighbors;
        }

        std::map<int, std::vector<int> > GetSeparations() const {
                return fSeparations;
        }

        std::map<int, std::vector<int> > GetHitNeighborsWithoutEdges() const {
                return fHitNeighborsWithoutEdges;
        }

        std::map<int, std::vector<int> > GetSeparationsWithoutEdges() const {
                return fSeparationsWithoutEdges;
        }

        std::map<int, std::vector<int> > GetHitNeighborsWithoutSkewed() const {
                return fHitNeighborsWithoutSkewed;
        }

        std::map<int, std::vector<int> > GetSeparationsWithoutSkewed() const {
                return fSeparationsWithoutSkewed;
        }

        int GetNumHits() {
                return fNumHits;
        }

        int GetNumHitsWithoutDouble() {
                return fNumHitsWithoutDouble;
        }
        void SetRunTimeBased(Bool_t val){
                        fRunTimeBased = val;
                }; // J.R. 26/04-2018
        void SetClusterTime(double val){
                fClusterTime = val;
        }; // J.R. 20/04-2018

private:

        std::map<int, FairLink> fMapHitToFairLink; // map< index of hit in fHit, FairLink of SttHit>
        std::map<int, FairLink> fMapHitToFairLinkOrig; // map< index of hit in fHitOrig, FairLink of SttHit>
        std::vector<FairHit*> fHits;            //vector with selected hits of an event
        std::vector<FairHit*> fHitsOrig;//vector with all originally hits of an event
        std::multimap<int, PndSttSkewedHit*> fCombinedSkewedHits; //<(inner) Tube-ID of combined stt hits of skewed layers, corresponding hit>

        double fClusterTime; // J.R. 17/04-2018
        Bool_t fAllowDoubleHits;
        int fNumHits;
        int fNumHitsWithoutDouble;
    Bool_t fRunTimeBased;

        PndSttStrawMap* fStrawMap;      // for getting more information about the tubes
        PndSttGeometryMap* fGeometryMap;// for initializing the neighbors of each tube
        std::map<int, TVector3> fMapTubeIdToPos;// map<straw id, position of the center of the tube>
        std::map<int, int> fMapTubeIdToHit; // map< id of straw tube, index of hit in fHit>

        std::map<int, std::vector<int> > fHitNeighbors; // map<straw id, vector<ids of hit-neighbors>>
        std::map<int, std::vector<int> > fSeparations; // map<#active neighbors, vector<straw ids>>

        std::map<int, std::vector<int> > fHitNeighborsWithoutEdges; // map<straw id, vector<ids of hit-neighbors>>
        std::map<int, std::vector<int> > fSeparationsWithoutEdges; // map<#active neighbors, vector<straw ids>>

        std::map<int, std::vector<int> > fHitNeighborsWithoutSkewed; // map<straw id, vector<ids of hit-neighbors>>
        std::map<int, std::vector<int> > fSeparationsWithoutSkewed; // map<#active neighbors, vector<straw ids>>

        /* Method grades the active cells according to the number of hit-neighbors.*/
        void SeparateNeighbors();

        /* Method searches for hit-neighbors of each cell.*/

        void FindHitNeighborsEventBased();

        void FindHitNeighborsTimeBased();

ClassDef(PndSttCellTrackFinderData,1)
        ;
};

#endif /* PNDSTTCELLTRACKFINDERDATA_H_ */