Sector.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_TPC_Sector_H
#define AliceO2_TPC_Sector_H
 
#include "DataFormatsTPC/Constants.h"
#include "DataFormatsTPC/Defs.h"
//using namespace AliceO2::TPC;
 
namespace o2
{
namespace tpc
{
//   enum RocType {ISector=0, OSector=1};
 
class Sector
{
 public:
  // the number of sectors
  static constexpr int MAXSECTOR = constants::MAXSECTOR;
 
  Sector() = default;
 
  Sector(unsigned char sec) : mSector(sec % MAXSECTOR) { ; }
 
  static Sector getLeft(const Sector s);
 
  static Sector getRight(const Sector s);
 
  bool operator==(const Sector& other) const { return mSector == other.mSector; }
 
  bool operator!=(const Sector& other) const { return mSector != other.mSector; }
 
  bool operator<(const Sector& other) const { return mSector < other.mSector; }
 
  bool operator++()
  {
    mLoop = ++mSector >= MAXSECTOR;
    mSector %= MAXSECTOR;
    return mLoop;
  }
 
  operator int() const { return int(mSector); }
 
  Sector& operator=(int sector)
  {
    mSector = sector % MAXSECTOR;
    return *this;
  }
 
  unsigned char getSector() const { return mSector; }
 
  Side side() const { return (mSector < MAXSECTOR / 2) ? Side::A : Side::C; }
 
  bool looped() const { return mLoop; }
 
  double phi() const { return (mSector % SECTORSPERSIDE) * SECPHIWIDTH + SECPHIWIDTH / 2.; }
 
  template <typename T>
  static int ToSector(T x, T y, T z)
  {
    static const T invangle(static_cast<T>(180) / static_cast<T>(M_PI * 20.)); // the angle describing one sector
    // force positive angle for conversion
    auto s = (std::atan2(-y, -x) + static_cast<T>(M_PI)) * invangle;
    // detect if on C size
    if (z < static_cast<T>(0.)) {
      s += Sector::MAXSECTOR / 2;
    }
    return s;
  }
 
  template <typename T>
  static int ToShiftedSector(T x, T y, T z)
  {
    // static int ToSector(T x, T y, T z) {
    constexpr T invangle{180. / (M_PI * 20.)}; // the angle describing one sector
    constexpr T offset{M_PI + M_PI / 180. * 10.};
    // force positive angle for conversion
    auto s = static_cast<int>((std::atan2(-y, -x) + offset) * invangle) % 18;
    // detect if on C size
    if (z < static_cast<T>(0.)) {
      s += Sector::MAXSECTOR / 2;
    }
    return s;
  }
 
 private:
  unsigned char mSector{}; 
  bool mLoop{};            
};
 
inline Sector Sector::getLeft(const Sector s) { return Sector((s + 1) % 18 + (s > 17) * 18); }
 
inline Sector Sector::getRight(const Sector s) { return Sector((s + 18 - 1) % 18 + (s > 17) * 18); }
} // namespace tpc
} // namespace o2
 
#endif