release-05-02-19/doxygen/ReferenceStateOnPlane_8h_source.html

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

#define genfit_ReferenceStateOnPlane_h


#include "StateOnPlane.h"


namespace genfit {


class ReferenceStateOnPlane : public StateOnPlane {


 public:


  ReferenceStateOnPlane();

  ReferenceStateOnPlane(const TVectorD& state,

      const SharedPlanePtr& plane,

      const AbsTrackRep* rep);

  ReferenceStateOnPlane(const TVectorD& state,

      const SharedPlanePtr& plane,

      const AbsTrackRep* rep,

      const TVectorD& auxInfo);

  ReferenceStateOnPlane(const StateOnPlane& state);


  StateOnPlane& operator=(ReferenceStateOnPlane other);

  void swap(ReferenceStateOnPlane& other); // nothrow


  virtual ~ReferenceStateOnPlane() {}


  void setForwardSegmentLength(double len) {forwardSegmentLength_ = len;}

  void setBackwardSegmentLength(double len) {backwardSegmentLength_ = len;}

  void setForwardTransportMatrix(const TMatrixD& mat) {forwardTransportMatrix_.ResizeTo(mat); forwardTransportMatrix_=mat;}

  void setBackwardTransportMatrix(const TMatrixD& mat) {backwardTransportMatrix_.ResizeTo(mat); backwardTransportMatrix_=mat;}

  void setTransportMatrix(const TMatrixD& mat, int direction) {if (direction >= 0) setForwardTransportMatrix(mat); else setBackwardTransportMatrix(mat);}

  void setForwardNoiseMatrix(const TMatrixDSym& mat) {forwardNoiseMatrix_.ResizeTo(mat); forwardNoiseMatrix_=mat;}

  void setBackwardNoiseMatrix(const TMatrixDSym& mat) {backwardNoiseMatrix_.ResizeTo(mat); backwardNoiseMatrix_=mat;}

  void setNoiseMatrix(const TMatrixDSym& mat, int direction) {if (direction >= 0) setForwardNoiseMatrix(mat); else setBackwardNoiseMatrix(mat);}

  void setForwardDeltaState(const TVectorD& mat) {forwardDeltaState_.ResizeTo(mat); forwardDeltaState_=mat;}

  void setBackwardDeltaState(const TVectorD& mat) {backwardDeltaState_.ResizeTo(mat); backwardDeltaState_=mat;}

  void setDeltaState(const TVectorD& mat, int direction) {if (direction >= 0) setForwardDeltaState(mat); else setBackwardDeltaState(mat);}


  double getForwardSegmentLength() const {return forwardSegmentLength_;}

  double getBackwardSegmentLength() const {return backwardSegmentLength_;}

  const TMatrixD& getForwardTransportMatrix() const {return forwardTransportMatrix_;}

  const TMatrixD& getBackwardTransportMatrix() const {return backwardTransportMatrix_;}

  const TMatrixD& getTransportMatrix(int direction) const {if (direction >= 0) return forwardTransportMatrix_; return backwardTransportMatrix_;}

  const TMatrixDSym& getForwardNoiseMatrix() const {return forwardNoiseMatrix_;}

  const TMatrixDSym& getBackwardNoiseMatrix() const {return backwardNoiseMatrix_;}

  const TMatrixDSym& getNoiseMatrix(int direction) const {if (direction >= 0) return forwardNoiseMatrix_; return backwardNoiseMatrix_;}

  const TVectorD& getForwardDeltaState() const {return forwardDeltaState_;}

  const TVectorD& getBackwardDeltaState() const {return backwardDeltaState_;}

  const TVectorD& getDeltaState(int direction) const {if (direction >= 0) return forwardDeltaState_; return backwardDeltaState_;}


  void resetForward();

  void resetBackward();


  virtual void Print(Option_t* option = "") const override;


 protected:


  double forwardSegmentLength_;

  double backwardSegmentLength_;

  TMatrixD forwardTransportMatrix_;

  TMatrixD backwardTransportMatrix_;

  TMatrixDSym forwardNoiseMatrix_;

  TMatrixDSym backwardNoiseMatrix_;

  TVectorD forwardDeltaState_;

  TVectorD backwardDeltaState_;

 public:


  ClassDefOverride(ReferenceStateOnPlane,1)


};


} /* End of namespace genfit */

#endif // genfit_ReferenceStateOnPlane_h