Lvl1MuCTPIInput.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
#ifndef TRIGT1INTERFACES_LVL1MUCTPIINPUT_H
/*
  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
*/
#define TRIGT1INTERFACES_LVL1MUCTPIINPUT_H
 
// System include(s):
#include <iosfwd>
#include <vector>
#include <utility>
#include <memory>
#include <array>
 
// Local include(s):
#include "TrigT1Interfaces/Lvl1MuSectorLogicData.h"
#include "TrigT1Interfaces/Lvl1MuBarrelSectorLogicData.h"
#include "TrigT1Interfaces/Lvl1MuEndcapSectorLogicData.h"
#include "TrigT1Interfaces/Lvl1MuForwardSectorLogicData.h"
 
namespace LVL1MUONIF {

   class Lvl1MuCTPIInput final {
 
   public:
      Lvl1MuCTPIInput();
      Lvl1MuCTPIInput( const Lvl1MuCTPIInput& );
      ~Lvl1MuCTPIInput() = default;
 
      Lvl1MuCTPIInput& operator=( const Lvl1MuCTPIInput& right );
 
   protected:
      // data from each sector logic is identifed by
      //  System Address     :  Barrel=0, Endcap=1, Forward=2
      //  Sub-system Address :  A_side(Z>0) =1, C_side(Z<0) =0
      //  Sector Address     :  Barrel=0-31, Endcap=0-47, Forward=0-23
      enum MuonSystem { Barrel = 0, Endcap = 1, Forward = 2 };
      enum MuonSubSystem { A_side = 1, C_side = 0};
      enum { NumberOfMuonSystem = 3 };
      enum { NumberOfMuonSubSystem = 2 };
      enum { NumberOfBarrelSector = 32 };
      enum { NumberOfEndcapSector = 48 };
      enum { NumberOfForwardSector = 24 }; 
 
   public:
      static size_t idBarrelSystem() { return Barrel; }
      static size_t numberOfBarrelSector() { return NumberOfBarrelSector; }
      static size_t idEndcapSystem() { return Endcap; }
      static size_t numberOfEndcapSector() { return NumberOfEndcapSector; }
      static size_t idForwardSystem() { return Forward; }
      static size_t numberOfForwardSector() { return NumberOfForwardSector; }
      static size_t idSideA() { return A_side; }
      static size_t idSideC() { return C_side; }
 
      const Lvl1MuSectorLogicData& getSectorLogicData( size_t systemAddress,
                                                       size_t subSystemAddress,
                                                       size_t sectorAddress,
                               int    bcid=0        ) const;
 
      void setSectorLogicData( const Lvl1MuSectorLogicData& data,
                               size_t systemAddress,
                               size_t subSystemAddress,
                               size_t sectorAddress,
                   int    bcid=0        );
 
      void setSectorLogicData( const unsigned int & sectorWord,
                               size_t systemAddress,
                               size_t subSystemAddress,
                               size_t sectorAddress,
                   int    bcid=0        );

      void merge( const Lvl1MuCTPIInput& another );
 
      void clear( size_t systemAddress );
      void clearAll();

      bool isEmpty( size_t systemAddress,
            int    bcid=0         ) const;

      bool isEmptyAll(int bcid=0) const;

      bool hasOutOfTimeCandidates(size_t systemAddress)  const
      {
    if ( systemAddress <  NumberOfMuonSystem) {
      return m_isFilledOutOfTimeCandidates[systemAddress];
    } 
    return false;
      }
 
     // for testing purposes only
     // void duplicateToOtherBC(int bcidOffset);
 
     friend std::ostream& operator<<( std::ostream&, const Lvl1MuCTPIInput& );

      //bool storeInWordFormat( std::ofstream& fOut, bool ascii = true );

      //bool retrieveInWordFormat( std::ifstream& fIn, bool ascii = true );
 
   private:
     //bool storeInWordFormat( std::ofstream& fOut,
     //                          bool ascii,
     //                         size_t systemAddress,
     //                         size_t subSystemAddress,
     //                         size_t sectorAddress );
 
      size_t reserve( size_t systemAddress ,
              int    bcid=0         );
     
      size_t getSystemIndex(size_t systemAddress,
              size_t subSystemAddress,
              size_t sectorAddress ) const
      {
    if (systemAddress==0) {
      return NumberOfBarrelSector*subSystemAddress+sectorAddress;
    } else if (systemAddress==1) {
      return NumberOfEndcapSector*subSystemAddress+sectorAddress;
    } else {
      return NumberOfForwardSector*subSystemAddress+sectorAddress;
    }
      }
 
     size_t getBcidIndex(size_t systemAddress,
                         int    bcid=0) const
     {
       for( size_t ip=0; ip<m_data[systemAddress].size(); ip++){
         int bc=((m_data[systemAddress]).at(ip)).first;
         if (bc == bcid) return ip;
       }
       return -1;
     };
 
     std::array<bool, NumberOfMuonSystem> m_isFilledOutOfTimeCandidates;
 
     
     typedef std::vector<std::shared_ptr <Lvl1MuSectorLogicData> > Lvl1MuVect;
     typedef std::pair<int, Lvl1MuVect>  Lvl1MuVectWithBC; 
     std::vector<Lvl1MuVectWithBC> m_data[ NumberOfMuonSystem ];
 
   }; // class Lvl1MuCTPIInput
 
} // namespace LVL1MUONIF
 
#include "AthenaKernel/CLASS_DEF.h"
CLASS_DEF( LVL1MUONIF::Lvl1MuCTPIInput, 6102, 0 )
 
#endif // TRIGT1INTERFACES_LVL1MUCTPIINPUT_H