GeneralBrokenLineInterfaceHelpers.h

#ifndef GENERALBROKENLINEINTERFACEHELPERS_H
#define GENERALBROKENLINEINTERFACEHELPERS_H

#include "SimpleHelixTrackModel.h"

#include <marlin/Processor.h>
#include <marlin/Global.h>

#include <lcio.h>
#include <string>

// GBL:
#include "GblTrajectory.h"
#include "MilleBinary.h"

// LCIO:
#include <EVENT/Track.h>
#include "EVENT/TrackerHit.h"

#include "TFile.h"
#include "TTree.h"
#include "TMath.h"

namespace marlintpc {

class gblHelperHit {
        public:
                gblHelperHit(const EVENT::TrackerHit&, const simpleHelix&, const bool, const bool, const int, const double);
                gblHelperHit(const double);

                TMatrixD getLocalToMeasurementProjection() const {
                        return _l2M;
                }

                TVectorD getResiduals() const {
                        return _res;
                }

                TMatrixDSym getPrecision() const {
                        return _prec;
                }

                double getS() const {
                        return _s;
                }

                double getPhi() const {
                        return _seedPhi;
                }

                double getEScaled() const {
                        return _eScaled;
                }

                bool isMeasurement() const {
                        return _isMeas;
                }

                bool isValid() const {
                        return _isValid;
                }

                // access global derivatives for Millepede-II
                unsigned int getNumGlobals() const;
                std::vector<int> getGlobalLabels() const;
                const TMatrixD& getGlobalDerivatives() const;

        private:
                const bool _isMeas; 
                double _hitPhi; 
                bool _isValid; 
                double _seedPhi; 
                double _seedLambda; 
                double _xyPred; 
                double _zPred; 
                double _s; 
                double _eScaled; 
                TMatrixD _l2M; 
                TMatrixD _getL2M();
                TVectorD _res; 
                TVectorD _getRes();
                TMatrixDSym _prec; 
                TMatrixDSym _getPrec(FloatVec);
                double _calcLocalPhi(const EVENT::TrackerHit&, const bool, const double);
                double _calcEScaled(const EVENT::TrackerHit&);
                // global derivatives for Millepede-II
                unsigned int _numGlobals; 
                std::vector<int> _globalLab; 
                TMatrixD _globalDer; 
};

class trackerAlcaCalculator {
        public:
                trackerAlcaCalculator();
                unsigned int getNumGlobals() const;
                std::vector<int> getGlobalLabels() const;
                const TMatrixD& getGlobalDerivatives() const;
                void calcModuleAlignment(const EVENT::TrackerHit& aHit, const TVectorD& tdir);
                void calcTrackDistortions(const EVENT::TrackerHit& aHit);
                void calcHitCharge(const EVENT::TrackerHit& aHit);
                void calcDr(const EVENT::TrackerHit& aHit, double phi);

        private:
                unsigned int _numDer; 
                std::vector<int> _globalLab; 
                TMatrixD _globalDer; 
};

class trackerAlcaSelector {
        public:
                trackerAlcaSelector(const EVENT::Track&, const int);
                const bool isSelected() const;

        private:
                bool _selectionFlag; 
};

} // namespace marlintpc
#endif // GENERALBROKENLINEINTERFACEHELPERS_H