TileMuonFitter.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 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() override;
    virtual StatusCode execute() override;
    virtual StatusCode finalize() override;
    virtual bool isClonable() const override final { return true; }

    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