GeometryBase.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
#ifndef ALICEO2_EMCAL_GEOMETRYBASE_H
#define ALICEO2_EMCAL_GEOMETRYBASE_H
 
#include <string>
 
namespace o2::emcal
{
enum EMCALSMType {
  NOT_EXISTENT = -1,
  EMCAL_STANDARD = 0,
  EMCAL_HALF = 1,
  EMCAL_THIRD = 2,
  DCAL_STANDARD = 3,
  DCAL_EXT = 4
}; // possible SM Type
 
enum AcceptanceType_t { EMCAL_ACCEPTANCE = 1,
                        DCAL_ACCEPTANCE = 2,
                        NON_ACCEPTANCE = 0 };
 
const std::string DEFAULT_GEOMETRY = "EMCAL_COMPLETE12SMV1_DCAL_8SM";
 
class GeometryNotInitializedException final : public std::exception
{
 public:
  GeometryNotInitializedException() = default;
 
  ~GeometryNotInitializedException() noexcept final = default;
 
  [[nodiscard]] const char* what() const noexcept override { return "Geometry not initialized"; }
};
 
class InvalidModuleException final : public std::exception
{
 public:
  InvalidModuleException(int nModule, int nMax) : mModule(nModule),
                                                  mMax(nMax),
                                                  mMessage("Invalid Module [ " + std::to_string(mModule) + "|" + std::to_string(mMax) + "]")
  {
  }
 
  ~InvalidModuleException() noexcept final = default;
 
  [[nodiscard]] int GetModuleID() const noexcept { return mModule; }
 
  [[nodiscard]] int GetMaxNumberOfModules() const noexcept { return mMax; }
 
  [[nodiscard]] const char* what() const noexcept final { return mMessage.c_str(); }
 
 private:
  int mModule;          
  int mMax;             
  std::string mMessage; 
};
 
class InvalidPositionException final : public std::exception
{
 public:
  InvalidPositionException(double eta, double phi) : mEta(eta),
                                                     mPhi(phi),
                                                     mMessage("Position phi (" + std::to_string(mPhi) + "), eta(" + std::to_string(mEta) + ") not im EMCAL")
  {
  }
 
  ~InvalidPositionException() noexcept final = default;
 
  [[nodiscard]] double getEta() const noexcept { return mEta; }
 
  [[nodiscard]] double getPhi() const noexcept { return mPhi; }
 
  [[nodiscard]] const char* what() const noexcept final { return mMessage.data(); }
 
 private:
  double mEta = 0.;     
  double mPhi = 0.;     
  std::string mMessage; 
};
 
class InvalidCellIDException final : public std::exception
{
 public:
  InvalidCellIDException(int cellID) : mCellID(cellID),
                                       mMessage("Cell ID " + std::to_string(mCellID) + " outside limits.")
  {
  }
 
  ~InvalidCellIDException() noexcept final = default;
 
  [[nodiscard]] int getCellID() const noexcept { return mCellID; }
 
  [[nodiscard]] const char* what() const noexcept final { return mMessage.data(); }
 
 private:
  int mCellID;          
  std::string mMessage; 
};
 
class InvalidSupermoduleTypeException final : public std::exception
{
 public:
  InvalidSupermoduleTypeException() = default;
 
  ~InvalidSupermoduleTypeException() noexcept final = default;
 
  [[nodiscard]] const char* what() const noexcept final { return "Uknown SuperModule Type !!"; }
};
 
class SupermoduleIndexException final : public std::exception
{
 public:
  SupermoduleIndexException(int supermodule, int maxSupermodules) : mSupermoduleIndex(supermodule),
                                                                    mMaxSupermodules(maxSupermodules)
  {
    mMessage = "Invalid supermodule ID " + std::to_string(mSupermoduleIndex) + ", max " + std::to_string(mMaxSupermodules);
  }
 
  ~SupermoduleIndexException() noexcept final = default;
 
  [[nodiscard]] int getSupermodule() const noexcept { return mSupermoduleIndex; }
 
  [[nodiscard]] int getMaxSupermodule() const noexcept { return mMaxSupermodules; }
 
  [[nodiscard]] const char* what() const noexcept final { return mMessage.data(); }
 
 private:
  int mSupermoduleIndex; 
  int mMaxSupermodules;  
  std::string mMessage;  
};
 
class RowColException final : public std::exception
{
 public:
  RowColException(int row, int col) : mRow(row), mCol(col)
  {
    mMessage = "Invalid position: row " + std::to_string(mRow) + ", col " + std::to_string(mCol);
  }
 
  ~RowColException() noexcept final = default;
 
  [[nodiscard]] int getRow() const noexcept { return mRow; }
 
  [[nodiscard]] int getCol() const noexcept { return mCol; }
 
  [[nodiscard]] const char* what() const noexcept final { return mMessage.data(); }
 
 private:
  int mRow, mCol;
  std::string mMessage;
};
 
} // namespace o2
 
#endif