ECLCellIdMapping.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2018 - Belle II Collaboration                             *
 *                                                                        *
 * ECL dataobject ECLCellIdMapping to provide quick access of             *
 * cellid storearray position.                                            *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Torben Ferber (torben.ferber@desy.de) (TF)               *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
 
#include <framework/logging/Logger.h>
 
#include <TObject.h>
 
namespace Belle2 {
  class ECLCellIdMapping : public TObject {
  public:
 
    static constexpr int c_nECLCellIds = 8736;
 
    ECLCellIdMapping() :
      m_CellIdToStoreArrPosition(c_nECLCellIds + 1),
      m_CellIdToPhi(c_nECLCellIds + 1),
      m_CellIdToTheta(c_nECLCellIds + 1),
      m_CellIdToPhiId(c_nECLCellIds + 1),
      m_CellIdToThetaId(c_nECLCellIds + 1),
      m_CellIdToNeighbours5(c_nECLCellIds + 1),
      m_CellIdToNeighbours7(c_nECLCellIds + 1)
    {
      for (unsigned idx = 0; idx < c_nECLCellIds + 1; idx++) {
        m_CellIdToStoreArrPosition[idx] = -1;
      }
    }
 
    void setCellIdToStoreArray(const int& cellid, const int& idx)
    {
      if (cellid > 0 and cellid < c_nECLCellIds + 1) {
        m_CellIdToStoreArrPosition[cellid] = idx;
      } else {
        B2ERROR("Cell Id " << cellid << " does not exist.");
      }
    }
 
    void setCellIdToNeighbour5(const int& cellid, const std::vector<short int>& neighbours)
    {
      if (cellid > 0 and cellid < c_nECLCellIds + 1) {
        m_CellIdToNeighbours5[cellid] = neighbours;
      } else {
        B2ERROR("Cell Id " << cellid << " does not exist.");
      }
    }
 
    void setCellIdToNeighbour7(const int& cellid, const std::vector<short int>& neighbours)
    {
      if (cellid > 0 and cellid < c_nECLCellIds + 1) {
        m_CellIdToNeighbours7[cellid] = neighbours;
      } else {
        B2ERROR("Cell Id " << cellid << " does not exist.");
      }
    }
 
    void setCellIdToPhi(const int& cellid, const double& phi)
    {
      if (cellid > 0 and cellid < c_nECLCellIds + 1) {
        m_CellIdToPhi[cellid] = phi;
      } else {
        B2ERROR("Cell Id " << cellid << " does not exist.");
      }
    }
 
    void setCellIdToTheta(const int& cellid, const double& theta)
    {
      if (cellid > 0 and cellid < c_nECLCellIds + 1) {
        m_CellIdToTheta[cellid] = theta;
      } else {
        B2ERROR("Cell Id " << cellid << " does not exist.");
      }
    }
 
    void setCellIdToPhiId(const int& cellid, const int& phiid)
    {
      if (cellid > 0 and cellid < c_nECLCellIds + 1) {
        m_CellIdToPhiId[cellid] = phiid;
      } else {
        B2ERROR("Cell Id " << cellid << " does not exist.");
      }
    }
 
    void setCellIdToThetaId(const int& cellid, const int& thetaid)
    {
      if (cellid > 0 and cellid < c_nECLCellIds + 1) {
        m_CellIdToThetaId[cellid] = thetaid;
      } else {
        B2ERROR("Cell Id " << cellid << " does not exist.");
      }
    }
 
    void reset()
    {
      memset(&m_CellIdToStoreArrPosition[0], -1, m_CellIdToStoreArrPosition.size() * sizeof m_CellIdToStoreArrPosition[0]);
    }
 
    int getCellIdToStoreArray(const int& cellid)
    {
      if (cellid > 0 and cellid < c_nECLCellIds + 1) {
        return m_CellIdToStoreArrPosition[cellid];
      } else {
        B2FATAL("Cell Id " << cellid << " does not exist.");
        return -1;
      }
    }
 
    std::vector<short int>& getCellIdToNeighbour5(const int& cellid)
    {
      if (cellid > 0 and cellid < c_nECLCellIds + 1) {
        return m_CellIdToNeighbours5[cellid];
      } else {
        B2FATAL("Cell Id " << cellid << " does not exist.");
      }
    }
 
    std::vector<short int>& getCellIdToNeighbour7(const int& cellid)
    {
      if (cellid > 0 and cellid < c_nECLCellIds + 1) {
        return m_CellIdToNeighbours7[cellid];
      } else {
        B2FATAL("Cell Id " << cellid << " does not exist.");
      }
    }
 
    double getCellIdToPhi(const int& cellid)
    {
      if (cellid > 0 and cellid < c_nECLCellIds + 1) {
        return m_CellIdToPhi[cellid];
      } else {
        B2FATAL("Cell Id " << cellid << " does not exist.");
        return -1;
      }
    }
 
    double getCellIdToTheta(const int& cellid)
    {
      if (cellid > 0 and cellid < c_nECLCellIds + 1) {
        return m_CellIdToTheta[cellid];
      } else {
        B2FATAL("Cell Id " << cellid << " does not exist.");
        return -1;
      }
    }
 
 
    int getCellIdToPhiId(const int& cellid)
    {
      if (cellid > 0 and cellid < c_nECLCellIds + 1) {
        return m_CellIdToPhiId[cellid];
      } else {
        B2FATAL("Cell Id " << cellid << " does not exist.");
        return -1;
      }
    }
 
    int getCellIdToThetaId(const int& cellid)
    {
      if (cellid > 0 and cellid < c_nECLCellIds + 1) {
        return m_CellIdToThetaId[cellid];
      } else {
        B2FATAL("Cell Id " << cellid << " does not exist.");
        return -1;
      }
    }
 
 
  private:
 
    std::vector<int> m_CellIdToStoreArrPosition;
 
    std::vector<double> m_CellIdToPhi;
 
    std::vector<double> m_CellIdToTheta;
 
    std::vector<int> m_CellIdToPhiId;
 
    std::vector<int> m_CellIdToThetaId;
 
    std::vector<std::vector<short int>> m_CellIdToNeighbours5;
 
    std::vector<std::vector<short int>> m_CellIdToNeighbours7;
 
    ClassDef(ECLCellIdMapping, 1); 
  };
 
} // end namespace Belle2