d1/dca/TileMuonFitter_8h_source.html

/*

  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration

*/


#ifndef TILECOSMICALGS_TILEMUONFITTER_H

#define TILECOSMICALGS_TILEMUONFITTER_H


/********************************************************************

 *

 * NAME:     TileMuonFitter

 * PACKAGE:  offline/TileCalorimeter/TileCosmicAlgs

 *

 * AUTHOR :  J. Maneira

 * CREATED:  10-Jul-2006

 * REVISED:  February-2008  (w/ L. Andrade)

 * REVISED:  November-2008  (w/ L. Andrade)

 * REVISED:  February-2009  (w/ M. Soares)

 *

 * PURPOSE:  Create Cell vectors from CaloCellContainer, fit a straight muon

 *           track through a selected subset, calculate horizontal

 *           plane crossing time.

 *           (see .cxx and mainpage.h for more details)

 *

 *  Input: TileCell (one by one or from CaloCellContainer)

 *  Output: ComissioningEvent/ComTime object

 *  Output: TileEvent/TileCosmicMuon object

 *

 ********************************************************************/


// Tile includes

#include "TileCosmicAlgs/TileMuonTrackDistance.h"

#include "TileEvent/TileContainer.h"


// Calo includes

#include "CaloIdentifier/CaloCell_ID.h"

#include "CaloEvent/CaloCellContainer.h"


// Athena includes

#include "AthenaBaseComps/AthAlgorithm.h"

#include "StoreGate/ReadHandleKey.h"

#include "StoreGate/WriteHandleKey.h"

#include "CommissionEvent/ComTime.h"


// Gaudi includes

#include "GaudiKernel/ToolHandle.h"


// forward declarations

class HWIdentifier;

class IdentifierHash;

class TileID;

class TileHWID;

class TileDetDescrManager;


// C++ STL includes

#include <string>

#include <algorithm>


//using namespace ROOT::Minuit2;


// Auxiliar class to save info about each cell

// used in Hough Transform computation

class CellInfo {

  public:


    float x, y, z;     // position

    float dist;        // RoI

    float e, ev;       // energy and energy density

    bool use;         // cell is enabled

    bool is_out;      // cell is not in current track

    int track_index; // each cell can belong to only one track

};


class TileMuonFitter: public AthAlgorithm {

  public:


    TileMuonFitter(const std::string& name, ISvcLocator* pSvcLocator);

    virtual ~TileMuonFitter();


    virtual StatusCode initialize();

    virtual StatusCode execute();

    virtual StatusCode finalize();


    void buildCells();


    void setEventDefaults();


    bool eventSelection();


    int fitTrack();


    int houghTrack();


    void calculateTime();

    void calculateTimeAtYequal0();

    void calculateTimeAtZequal0();


    void buildTileCosmicMuon(int fitok);

    void buildTileCosmicMuonAtYequal0(int fitok);

    void buildTileCosmicMuonAtZequal0(int fitok);


    void buildComTime(int fitok);

    void buildComTimeAtYequal0(int fitok);

    void buildComTimeAtZequal0(int fitok);


  private:


    void trackIntersection(std::vector<double> & ltop, std::vector<double> & lbot, int index);

    void trackSegmentIntersection(std::vector<double> & segPath, std::vector<int> & segPartition

                                  , std::vector<int> & segModule, std::vector<int> & segSampling, int index);


    void energyInTrack(std::vector<double> & etop, std::vector<double> & ebot

                      , std::vector<IdentifierHash> & cells, int index);


    bool checkLBz(double x1);

    bool checkEBz(double x1);

    bool checkEBAz(double x1);

    bool checkEBCz(double x1);

    bool checkLBr(double x1, uint8_t s1);

    bool checkEBr(double x1, uint8_t s1);

    bool checkLBr(double x1);

    bool checkEBr(double x1);

    int whichEBr(double x1);

    int whichLBr(double x1);

    int whichModule(CLHEP::Hep3Vector tempvec);


    // Hough Transform auxiliar routines ---------------------------------------


    std::vector<CellInfo> m_cellInfo;


    void cart2hough(float x1, float y1, float x2, float y2, double &raio, double &angu);

    void hough2cart(double r, double a, double offset, double &aa, double &bb);

    float dist2line(CellInfo &ci, float *pos, float *w);

    void points2dir(CellInfo &ci1, CellInfo &ci2, float *w);

    unsigned int CntCells(unsigned int index1, unsigned int index2, double &skew);

    bool guessTrack(unsigned int &index1, unsigned int &index2);

    unsigned int buildCellInfoVector();

    float selectCells(float *p, float *w);

    bool isHaloMuon(double azy);

    void doHough(double &rxy, double &axy, double &rzy, double &azy);

    void addTrack(double aa, double bb, double cc, double dd);


  protected:


    // Tile objects

    const TileID* m_tileID;

    const TileHWID* m_tileHWID;

    const TileDetDescrManager* m_tileMgr;

    const CaloCellContainer *m_caloCells;


    ROOT::Minuit2::TileMuonTrackDistance* m_theTrack;


    double m_eThreshold;

    double m_deltaTimeCut;

    bool m_doWeighted;

    bool m_doDensity;

    std::string m_beamType;

    bool m_doHoughTransform;

    std::vector<double> m_tileDD_radiusLB;

    std::vector<double> m_tileDD_radiusEB;

    std::vector<double> m_tileDD_zEBA;

    std::vector<double> m_tileDD_zEBC;

    std::vector<double> m_tileDD_zLB;


    int m_nCells;

    int m_minimumCells;

    std::vector<CLHEP::Hep3Vector> m_cellPosition;

    std::vector<double> m_cellEnergy;

    std::vector<double> m_cellWeight;

    std::vector<double> m_cellTime;

    std::vector<double> m_cellDeltaTime;

    std::vector<IdentifierHash> m_cellHash;


    std::vector<std::vector<double> > m_linePar;

    std::vector<double> m_fitMinimum;

    std::vector<double> m_zeroCrossingTime;


    double m_meanX;

    double m_meanY;

    double m_meanZ;

    double m_weightedMeanX;

    double m_weightedMeanY;

    double m_weightedMeanZ;


    int m_maxBottomIndex;

    int m_maxTopIndex;

    bool m_reg1to2;


    static const CaloCell_ID::SUBCALO m_caloIndex;


    SG::ReadHandleKey<CaloCellContainer> m_cellContainerKey{this, "CaloCellContainer", "AllCalo",

                                                            "Input CaloCellContainer name" };


    SG::WriteHandleKey<TileCosmicMuonContainer> m_cosmicMuonContainerKey{this,

                                                                         "TileCosmicMuonKey",

                                                                         "TileCosmicMuonMF",

                                                                         "Output TileCosmicMuonContainer name"};


    SG::WriteHandleKey<ComTime> m_comTimeKey{this, "ComTimeKey", "ComTimeTileMuon", "Output ComTime name"};


};


#endif