GblFitter.h

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

/* Copyright 2013
 *   Authors: Sergey Yashchenko and Tadeas Bilka
 *
 *   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 GblFitter_H
#define GblFitter_H

#include "GblTrajectory.h"
#include "AbsFitter.h"
#include "AbsTrackRep.h"
#include "GblFitterInfo.h"
#include "GblFitStatus.h"
#include "GblTrackSegmentController.h"

#include <map>
#include <iostream>

#include <TMatrixD.h>
#include <assert.h>
#include <sstream>

#include <TMath.h>
#include <TVector3.h>


namespace genfit {
  
  class GblTrackSegmentController;
  
  class GblFitter : public AbsFitter {
    
  private:
    GblFitter(const GblFitter&);
    GblFitter& operator=(GblFitter const&);
    
    std::string m_gblInternalIterations;
    bool m_enableScatterers;
    bool m_enableIntermediateScatterer;
    unsigned int m_externalIterations;
    unsigned int m_recalcJacobians;
    
    // Minimum scattering sigma (will be squared and inverted...)
    double scatEpsilon;
    GblTrackSegmentController* m_segmentController;
    
  public:
    
    GblFitter() : AbsFitter(), m_gblInternalIterations(""), m_enableScatterers(true), m_enableIntermediateScatterer(true), m_externalIterations(1), m_recalcJacobians(0), scatEpsilon(1.e-8), m_segmentController(nullptr) {;}
    
    virtual ~GblFitter();    

    void setOptions(const std::string &internalIterations = "", bool enableScatterers = true, bool enableIntermediateScatterer = true, unsigned int externalIterations = 1, unsigned int recalcJacobians = 1) {
      m_externalIterations = externalIterations;
      m_gblInternalIterations = internalIterations;
      m_recalcJacobians = recalcJacobians;
      if (!enableScatterers)
        enableIntermediateScatterer = false;
      m_enableScatterers = enableScatterers;
      m_enableIntermediateScatterer = enableIntermediateScatterer;
    }

    
    void setMSOptions(bool enableScatterers = true, bool enableIntermediateScatterer = true) {
      if (!enableScatterers)
        enableIntermediateScatterer = false;
      m_enableScatterers = enableScatterers;
      m_enableIntermediateScatterer = enableIntermediateScatterer;
    }
    
    void getScattererFromMatList(double& length,
                                 double& theta, double& s, double& ds,
                                 const double p, const double mass, const double charge,
                                 const std::vector<genfit::MatStep>& steps) const;
    
    void processTrackWithRep(Track* trk, const AbsTrackRep* rep, bool resortHits = false) override;
    
    double constructGblInfo(Track* trk, const AbsTrackRep* rep);
    
    void updateGblInfo(gbl::GblTrajectory& traj, genfit::Track* trk, const genfit::AbsTrackRep* rep);
    
    std::vector<gbl::GblPoint> collectGblPoints(genfit::Track* trk, const genfit::AbsTrackRep* rep);
    
    void cleanGblInfo(Track* trk, const AbsTrackRep* rep) const;
    
    void sortHits(Track* trk, const AbsTrackRep* rep) const;
    
    void setTrackSegmentController(GblTrackSegmentController* controler);
    
    
  public:
    
    ClassDef(GblFitter, 2)
    
  };
  
}  /* End of namespace genfit */
#endif // GblFitter_H