GFTrack.h

Go to the documentation of this file.

//****************************************************************************
//*                   This file is part of PandaRoot.                        *
//*                                                                          *
//*            PandaRoot is distributed under the terms of the               *
//*              GNU General Public License (GPL) version 3,                 *
//*                 copied verbatim in the file "LICENSE".                   *
//*                                                                          *
//*  Copyright (C) 2006 - 2024 FAIR GmbH and copyright holders of PandaRoot  *
//*     The copyright holders are listed in the file "COPYRIGHTHOLDERS".     *
//*               The authors are listed in the file "AUTHORS".              *
//****************************************************************************

/* 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;

 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; }

  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 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)); }

  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(); }

  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 == nullptr)
      fTrackReps = new TObjArray(fDefNumTrackReps);
    fTrackReps->Add(theTrackRep);
    fBookkeeping.push_back(new GFBookkeeping());
    fRepAtHit.push_back(-1);
  }

  GFBookkeeping *getBK(int index = -1)
  {
    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)
  {
    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();

  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();
    }
  }

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

  void setSmoothing(bool smooth = true) { fSmooth = smooth; }

  bool getSmoothing() { return fSmooth; }

  void blowUpCovs(double blowUpFactor);

 public:
  ClassDef(GFTrack, 1)
};

#endif