GFTrack.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file GFTrack.h

/* Copyright 2008-2010, Technische Universitaet Muenchen,
   Authors: Christian Hoeppner & Sebastian Neubert

   This file is part of GENFIT.

   GENFIT is free software: you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published
   by the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   GENFIT is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public License
   along with GENFIT.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef GFTRACK_H 
#define GFTRACK_H

#include"assert.h"
#include<map>

#include "GFAbsTrackRep.h"
#include "GFAbsRecoHit.h"

#include "TClonesArray.h"
#include "TObjArray.h"

#include "GFTrackCand.h"
#include "GFBookkeeping.h"


class TVirtualGeoTrack;

class GFTrack : public TObject {   
private:
  
  
  TObjArray* fTrackReps; //->

  std::vector<GFAbsRecoHit*> fHits; 
  
  std::vector<GFBookkeeping*> fBookkeeping;

  std::vector<int> fRepAtHit;

  GFTrackCand fCand; // list of hits
    
  static const int fDefNumTrackReps = 10; 
  unsigned int fCardinal_rep; // THE selected rep, default=0;

  unsigned int fNextHitToFit;

  bool fSmooth;
  bool fSmoothFast;
  
public:
  
  GFTrack(); 

  GFTrack(const GFTrack&); 

  GFTrack& operator=(const GFTrack&);

  GFTrack(GFAbsTrackRep*, bool smooth = false); 
  
  virtual ~GFTrack();

  // -----------------------
  // Accessors
  // -----------------------

  void reset();  // deletes the RecoHits!

  int getFailedHits(int repId=-1){
    int theRep;
    if(repId==-1) theRep=fCardinal_rep;
    else theRep = repId;
    return fBookkeeping.at(theRep)->getNumFailed();
  }

  std::vector<GFAbsRecoHit*> getHits() {return fHits;}

  std::map<GFAbsRecoHit*, unsigned int> getHitMap();

  const GFTrackCand& getCand() const {return fCand;}

  GFAbsRecoHit* getHit(int id) const {
    return fHits.at(id);
  }

  unsigned int getNumHits() const {
    return fHits.size();
  }

  void mergeHits(GFTrack* trk); 


  void sortHits();

  void releaseHits(){fHits.clear();} 

  void releaseTrackReps(){ fTrackReps->SetOwner(kFALSE); fTrackReps->Clear();} 

  unsigned int getNextHitToFit() const {return fNextHitToFit;}

  void setNextHitToFit(unsigned int i) {fNextHitToFit=i;}

  GFAbsTrackRep* getTrackRep(int id) const {
    return reinterpret_cast<GFAbsTrackRep*>(fTrackReps->At(id));
  }

  unsigned int getNumReps() const {
    return fTrackReps->GetEntriesFast();
  }

  GFAbsTrackRep* getCardinalRep() const {return ((GFAbsTrackRep*)fTrackReps->At(fCardinal_rep));}
  
  unsigned int getCardinalRepID() const {return fCardinal_rep;}
  
  TVector3 getMom() const {return getCardinalRep()->getMom();}

  TVector3 getMom(const GFDetPlane& pl) const {return getCardinalRep()->getMom(pl);}

  TVector3 getPos() const {return getCardinalRep()->getPos();}

  TVector3 getPos(const GFDetPlane& pl) const {return getCardinalRep()->getPos(pl);}

  void getPosMomCov(TVector3& pos,TVector3& mom,TMatrixT<double>& cov){
    getCardinalRep()->getPosMomCov(pos,mom,cov);
  }

  void getPosMomCov(const GFDetPlane& pl,TVector3& pos,TVector3& mom,TMatrixT<double>& cov){
    getCardinalRep()->getPosMomCov(pl,pos,mom,cov);
  }

  double getChiSqu() const {return getCardinalRep()->getChiSqu();}

  double getForwardChiSqu() const {return getCardinalRep()->getForwardChiSqu();}

  unsigned int getNDF() const {return getCardinalRep()->getNDF();}

  double getRedChiSqu() const {return getCardinalRep()->getRedChiSqu();}

  double getCharge() const {return getCardinalRep()->getCharge();}

  void fillGeoTrack(TVirtualGeoTrack* tr) const {fillGeoTrack(tr,fCardinal_rep);} 

  void fillGeoTrack(TVirtualGeoTrack* tr,unsigned int repid) const;
  
  // ---------------------
  // Modifiers
  // ---------------------

  void addFailedHit(unsigned int irep,unsigned int id){
    assert(irep<fBookkeeping.size());
    fBookkeeping.at(irep)->addFailedHit(id);
  }

  inline void addHit(GFAbsRecoHit* theHit) { 
    fHits.push_back(theHit);
  }
  
  void addHit(GFAbsRecoHit* theHit, 
        unsigned int detId,
        unsigned int hitId,
        double rho=0.,
        unsigned int planeId=0){
    fHits.push_back(theHit);
    fCand.addHit(detId,hitId,rho,planeId);
  }

  void addHitVector(std::vector<GFAbsRecoHit*> hits) {
    fHits = hits;
  }

  void addTrackRep(GFAbsTrackRep* theTrackRep) {
    if(fTrackReps==NULL)fTrackReps=new TObjArray(fDefNumTrackReps);
    fTrackReps->Add(theTrackRep);
    fBookkeeping.push_back( new GFBookkeeping() );
    fRepAtHit.push_back(-1);
  }

  GFBookkeeping* getBK(int index=-1) const {
    if(index==-1) return fBookkeeping.at(fCardinal_rep);
    assert((unsigned int)index<getNumReps());
    return fBookkeeping.at(index);
  }
    
  void setCandidate(const GFTrackCand& cand, bool doreset=false);
  
  void setCardinalRep(unsigned int r){if((int)r<fTrackReps->GetEntriesFast())fCardinal_rep=r;}
  

  void getResiduals(unsigned int detId, // which detector?
        unsigned int dim,   // which projection?
        unsigned int rep,   // which trackrep ?
        std::vector<double>& result);
        

  void setRepAtHit(unsigned int irep,int ihit){
    assert(irep<getNumReps());
    fRepAtHit.at(irep) = ihit;
  }

  int getRepAtHit(unsigned int irep) const {
    assert(irep<getNumReps());
    return fRepAtHit.at(irep);
  }

  void clearRepAtHit(){
    for(unsigned int i=0;i<getNumReps();++i){
      fRepAtHit.at(i)=-1;
    }
  }

  void printBookkeeping();

  void Print(const Option_t* = "") const;

  void clearBookkeeping(){
    for(unsigned int i=0;i<getNumReps();++i){
      fBookkeeping.at(i)->clearAll();
    }
  }

  void clearFailedHits(){
    for(unsigned int i=0;i<getNumReps();++i){
      fBookkeeping.at(i)->clearFailedHits();
    }
  }

  bool getHitsByPlane(std::vector<std::vector<int>*>& retVal);

  void setSmoothing(bool smooth = true, bool fast = false) { fSmooth = smooth; fSmoothFast = fast;}

  bool getSmoothing() const { return fSmooth; }

  bool getSmoothingFast() const { return fSmoothFast; }

  void blowUpCovs(double blowUpFactor);


public:
  ClassDef(GFTrack,3)
};

#endif