GblFitterInfo.h

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

/* Copyright 2008-2010, Technische Universitaet Muenchen,
 *   Authors: Christian Hoeppner & Sebastian Neubert & Johannes Rauch
 * 
 *   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 genfit_GblFitterInfo_h
#define genfit_GblFitterInfo_h

#include "AbsFitterInfo.h"
#include "MeasuredStateOnPlane.h"
#include "MeasurementOnPlane.h"
#include "StateOnPlane.h"
#include "TrackPoint.h"
#include "ThinScatterer.h"
#include "StateOnPlane.h"
#include "Track.h"
#include "ICalibrationParametersDerivatives.h"
#include "GblPoint.h"
#include "GblTrajectory.h"
#include "GblFitter.h"
#include "TMatrixD.h"
#include "TMatrixDSym.h"
#include "AbsHMatrix.h"

#include <vector>
#include <memory>


namespace genfit {
  
  
  class GblFitterInfo : public AbsFitterInfo {
    
  public:
    
    GblFitterInfo();
    
    GblFitterInfo(const TrackPoint* trackPoint, const AbsTrackRep* rep);
    
    GblFitterInfo(const TrackPoint* trackPoint, const AbsTrackRep* rep, StateOnPlane& referenceState);
    
    void reset(unsigned int measurementDim = 2, unsigned int repDim = 5);
        
    void setReferenceState(StateOnPlane& referenceState);
    void setJacobian(TMatrixD jacobian);
    
    TMatrixDSym getCovariance(double variance, TVector3 trackDirection, SharedPlanePtr measurementPlane) const;
    
    gbl::GblPoint constructGblPoint();
  
    void updateFitResults(gbl::GblTrajectory& traj);
    
    const MeasuredStateOnPlane& getFittedState(bool afterKink = true) const override;

    MeasurementOnPlane getResidual(unsigned int = 0, bool = false, bool onlyMeasurementErrors = true) const override;
    
    MeasurementOnPlane getKink() const;
    
    TVectorD getKinks() const;
    
    MeasurementOnPlane getMeasurement() const;
    
    void updateMeasurementAndPlane(const StateOnPlane & sop);

    StateOnPlane getReferenceState() const {return StateOnPlane(refPrediction_, sharedPlane_, rep_);}
    
    void recalculateJacobian(GblFitterInfo* prevFitterInfo);
    
    virtual ~GblFitterInfo() {;}
    virtual GblFitterInfo* clone() const override;
    bool hasMeasurements() const override {return trackPoint_->hasRawMeasurements();}
    bool hasReferenceState() const override {return (refPrediction_(0) != 0.);}
    bool hasForwardPrediction() const override {return hasReferenceState();}
    bool hasBackwardPrediction() const override {return hasReferenceState();}
    bool hasForwardUpdate() const override {return hasForwardPrediction();}
    bool hasBackwardUpdate() const override {return hasBackwardPrediction();}
    bool hasUpdate(int direction) const override {if (direction < 0) return hasBackwardPrediction(); return hasForwardPrediction();}
    bool hasPredictionsAndUpdates() const {return (hasForwardPrediction() && hasBackwardPrediction() && hasForwardUpdate() && hasBackwardUpdate());}

    void deleteForwardInfo() override {;}
    void deleteBackwardInfo() override {;}
    void deletePredictions() {
      deleteBackwardInfo();
      deleteForwardInfo();
    }
    void deleteReferenceInfo() override {;} // Empty because we really do not want to delete reference without a new one
    void deleteMeasurementInfo() override {;} // We do not keep the measurements
    virtual void Print(const Option_t* = "") const override;
    virtual bool checkConsistency(const genfit::PruneFlags* = nullptr) const override;
       
  private:
    TMatrixD jacobian_;
    TVectorD measResiduals_;
    TVectorD measResidualErrors_;
    TVectorD kinkResiduals_;
    TVectorD kinkResidualErrors_;
    TVectorD measDownWeights_;
    TVectorD kinkDownWeights_;
    TVectorD bwdStateCorrection_;
    TVectorD fwdStateCorrection_;
    TMatrixDSym bwdCov_;
    TMatrixDSym fwdCov_;
    TVectorD fwdPrediction_;
    TVectorD bwdPrediction_;
    TVectorD refPrediction_;
    
    TVectorD measurement_;
    TMatrixDSym measCov_;
    TMatrixD hMatrix_;

    mutable std::unique_ptr<MeasuredStateOnPlane> fittedStateBwd_; 
    mutable std::unique_ptr<MeasuredStateOnPlane> fittedStateFwd_; 
    
  public:
    
    ClassDefOverride(GblFitterInfo, 1)
    
  };
  
} /* End of namespace genfit */
#endif // genfit_GblFitterInfo_h