Commit cb0533a0 authored by Niels Van Eldik's avatar Niels Van Eldik Committed by Graeme Stewart
Browse files

new PRDs (MuonTrigCoinData-01-00-01)

parent 7363bb66
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
///////////////////////////////////////////////////////////////////
// CoinDataCollection.h
// Header file for class TrigCoinDataCollection
///////////////////////////////////////////////////////////////////
// (c) ATLAS Detector software
///////////////////////////////////////////////////////////////////
#ifndef MUONTRIGCOINDATA_MUONCOINDATACOLLECTION_H
#define MUONTRIGCOINDATA_MUONCOINDATACOLLECTION_H
// Base classes
#include "Identifier/Identifier.h"
#include "Identifier/IdentifierHash.h"
#include "DataModel/DataVector.h"
#include "CLIDSvc/CLASS_DEF.h"
namespace Muon{
template< class CoinDataT >
class MuonCoinDataCollection : public DataVector< CoinDataT > {
///////////////////////////////////////////////////////////////////
// Public methods:
///////////////////////////////////////////////////////////////////
public:
// Constructor with parameters:
// Hashed offline identifier of the DE
MuonCoinDataCollection(const IdentifierHash idHash);
/** Default Constructor (for persistency)*/
MuonCoinDataCollection();
/** Destructor:*/
virtual ~MuonCoinDataCollection();
///////////////////////////////////////////////////////////////////
// Const methods:
///////////////////////////////////////////////////////////////////
// typedef needed for IdentifiableContainer base class
typedef Identifier ID;
// identifier of this detector element:
virtual Identifier identify() const;
virtual IdentifierHash identifyHash() const;
virtual void setIdentifier(Identifier id);
// plottable
virtual std::string type() const;
// typedef needed for IdentifiableContainer base class
// typedef TrigCoinData DIGIT;
///////////////////////////////////////////////////////////////////
// Private methods:
///////////////////////////////////////////////////////////////////
private:
MuonCoinDataCollection(const MuonCoinDataCollection&);
MuonCoinDataCollection &operator=(const MuonCoinDataCollection&);
///////////////////////////////////////////////////////////////////
// Private data:
///////////////////////////////////////////////////////////////////
private:
const IdentifierHash m_idHash;
Identifier m_id; // identifier of the DE
};
// member functions that use Collection T
#include "MuonTrigCoinData/MuonCoinDataCollection.icc"
///////////////////////////////////////////////////////////////////
// Inline methods:
///////////////////////////////////////////////////////////////////
}
#endif // MUONTRIGCOINDATA_MUONCOINDATACOLLECTION_H
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
///////////////////////////////////////////////////////////////////
// MuonCoinDataCollection.icc
// Implementation file for class MuonCoinDataCollection
///////////////////////////////////////////////////////////////////
// (c) ATLAS Detector software
///////////////////////////////////////////////////////////////////
template< class CoinDataT >
// Constructor with parameters:
MuonCoinDataCollection< CoinDataT >::MuonCoinDataCollection(const IdentifierHash idHash) :
m_idHash(idHash),
m_id()
{}
template< class CoinDataT >
// Default Constructor :
MuonCoinDataCollection< CoinDataT >::MuonCoinDataCollection() :
m_idHash(),
m_id()
{}
// Destructor:
template< class CoinDataT >
MuonCoinDataCollection< CoinDataT >::~MuonCoinDataCollection()
{ }
template< class CoinDataT >
Identifier MuonCoinDataCollection< CoinDataT >::identify() const
{
return m_id;
}
template< class CoinDataT >
IdentifierHash MuonCoinDataCollection< CoinDataT >::identifyHash() const
{
return m_idHash;
}
template< class CoinDataT >
void MuonCoinDataCollection< CoinDataT >::setIdentifier(Identifier id)
{
m_id = id;
}
template< class CoinDataT >
std::string MuonCoinDataCollection< CoinDataT >::type() const
{
return "MuonCoinDataCollection";
}
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
///////////////////////////////////////////////////////////////////
// MuonCoinDataContainer.h
// Header file for class MuonCoinDataContainer
///////////////////////////////////////////////////////////////////
// (c) ATLAS Detector software
///////////////////////////////////////////////////////////////////
// Container for RIO collections for Muons
///////////////////////////////////////////////////////////////////
// Version 1.0 106/07/2004 Ketevi A. Assamagan - adapted
// from Veronique Boisvert
///////////////////////////////////////////////////////////////////
#ifndef MUONTRIGCOINDATA_MUONCOINDATACONTAINER_H
#define MUONTRIGCOINDATA_MUONCOINDATACONTAINER_H
// Base classes
#include "CLIDSvc/CLASS_DEF.h"
#include "EventContainers/IdentifiableContainer.h"
//Needed Classes
#include "MuonTrigCoinData/TgcCoinData.h"
#include "MuonTrigCoinData/MuonCoinDataCollection.h"
namespace Muon{
template<class CollectionT>
class MuonCoinDataContainer : public IdentifiableContainer<CollectionT> {
///////////////////////////////////////////////////////////////////
// Public methods:
///////////////////////////////////////////////////////////////////
public:
//default for POOL
MuonCoinDataContainer();
// Constructor with parameters:
MuonCoinDataContainer(unsigned int max);
// Destructor:
virtual ~MuonCoinDataContainer();
/** return class ID */
static const CLID& classID()
{
// static CLID id = CLID_T ;
// return id;
return ClassID_traits< MuonCoinDataContainer <CollectionT> > ::ID();
}
/** return class ID */
virtual const CLID& clID() const
{
return classID();
}
///////////////////////////////////////////////////////////////////
// Const methods:
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
// Non-const methods:
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
// Private methods:
///////////////////////////////////////////////////////////////////
private:
MuonCoinDataContainer(const MuonCoinDataContainer&);
MuonCoinDataContainer &operator=(const MuonCoinDataContainer&);
///////////////////////////////////////////////////////////////////
// Private data:
///////////////////////////////////////////////////////////////////
private:
};
///////////////////////////////////////////////////////////////////
// Inline methods:
///////////////////////////////////////////////////////////////////
typedef MuonCoinDataCollection< TgcCoinData > TgcCoinDataCollection;
// member functions that use Collection T
#include "MuonTrigCoinData/MuonCoinDataContainer.icc"
}
#endif // MUONTRIGCOINDATA_MUONCOINDATACONTAINER_H
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
///////////////////////////////////////////////////////////////////
// MuonCoinDataContainer.icc
// Implementation file for class MuonCoinDataContainer
///////////////////////////////////////////////////////////////////
// (c) ATLAS Detector software
///////////////////////////////////////////////////////////////////
template< class CollectionT>
MuonCoinDataContainer< CollectionT>::MuonCoinDataContainer() :
IdentifiableContainer<CollectionT>()
{
}
template< class CollectionT>
// Constructor with parameters:
MuonCoinDataContainer< CollectionT>::MuonCoinDataContainer(unsigned int max) :
IdentifiableContainer<CollectionT>(max)
{}
template< class CollectionT>
// Destructor
MuonCoinDataContainer< CollectionT>::~MuonCoinDataContainer()
{
}
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONCOINDATADICT_H
#define MUONCOINDATADICT_H
#include "MuonTrigCoinData/TgcCoinData.h"
#include "MuonTrigCoinData/MuonCoinDataContainer.h"
#include "MuonTrigCoinData/TgcCoinDataContainer.h"
namespace tmpMuonTrigCoinData
{
struct tmp
{
DataVector<Muon::TgcCoinData> tmpDV1;
Muon::TgcCoinDataContainer tmpCont1;
DataVector<Muon::MuonCoinDataCollection<Muon::TgcCoinData> > dummy1;
std::vector<Muon::MuonCoinDataCollection<Muon::TgcCoinData>* > dummy2;
};
}
#endif
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
///////////////////////////////////////////////////////////////////
// RpcCoinData.h
// Header file for class RpcCoinData
///////////////////////////////////////////////////////////////////
// (c) ATLAS Detector software
///////////////////////////////////////////////////////////////////
#ifndef MUONTRIGCOINDATA_RPCCOINDATA_H
#define MUONTRIGCOINDATA_RPCCOINDATA_H
#include "MuonPrepRawData/RpcPrepData.h"
#include "GeoPrimitives/GeoPrimitives.h"
#include "EventPrimitives/EventPrimitives.h"
class RpcCoinDataContainerCnv;
namespace Muon
{
class RpcCoinData : public RpcPrepData
{
///////////////////////////////////////////////////////////////////
// Public methods:
///////////////////////////////////////////////////////////////////
public:
friend class ::RpcCoinDataContainerCnv;
/** Public, Copy, operator=, constructor*/
RpcCoinData();
RpcCoinData(const RpcCoinData &);
RpcCoinData &operator=(const RpcCoinData &);
/** @brief Dumps information about the RpcCoinData*/
virtual MsgStream& dump( MsgStream& stream) const;
/** @brief Dumps information about the PRD*/
virtual std::ostream& dump( std::ostream& stream) const;
/// Constructor:
RpcCoinData( const Identifier& stripId,
const IdentifierHash &idDE,
const Amg::Vector2D& locpos,
const std::vector<Identifier>& stripList,
const Amg::MatrixX* locErrMat,
const MuonGM::RpcReadoutElement* detEl,
const float time,
const unsigned short ambiguityFlag,
const unsigned short ijk,
const unsigned short threshold,
const unsigned short overlap,
const unsigned short parent_cmId,
const unsigned short parent_padId,
const unsigned short parent_sectorId,
const bool lowPtCm);
/// Destructor:
virtual ~RpcCoinData();
/** return ijk of the trigger hit (can be 6, 7 or 0) */
inline unsigned short ijk() const;
/** return highest threshold for the trigger pattern this hit is contributing */
inline unsigned short threshold() const;
/** return the overlap flag */
inline unsigned short overlap() const;
/** parent ID (online-style) of CM, PAD and Sector */
inline unsigned short parentCmId() const;
inline unsigned short parentPadId() const;
inline unsigned short parentSectorId() const;
/** Aside or Cside */
bool isAside() const;
/** Low Pt, High Pt or Low Pt input to High Pt CM */
bool isLowPtCoin() const;
bool isHighPtCoin() const;
bool isLowPtInputToHighPtCm() const;
private:
unsigned short m_ijk;
unsigned short m_threshold;
unsigned short m_overlap;
unsigned short m_parentCmId;
unsigned short m_parentPadId;
unsigned short m_parentSectorId;
bool m_lowPtCm;
};
////////////////////////////////////////////////
// inline methods:
////////////////////////////////////////////////
/** return ijk of the trigger hit (can be 6, 7 or 0) */
inline unsigned short RpcCoinData::ijk() const {return m_ijk;}
/** return highest threshold for the trigger pattern this hit is contributing */
inline unsigned short RpcCoinData::threshold() const {return m_threshold;}
/** return the overlap flag */
inline unsigned short RpcCoinData::overlap() const {return m_overlap;}
/** parent ID (online-style) of CM, PAD and Sector */
inline unsigned short RpcCoinData::parentCmId() const {return m_parentCmId;}
inline unsigned short RpcCoinData::parentPadId() const {return m_parentPadId;}
inline unsigned short RpcCoinData::parentSectorId() const {return m_parentSectorId;}
}
#endif // MUONTRIGCOINDATA_RPCCOINDATA_H
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONTRIGCOINDATA_RPCCOINDATACOLLECTION_H
#define MUONTRIGCOINDATA_RPCCOINDATACOLLECTION_H
#include "MuonTrigCoinData/RpcCoinData.h"
#include "MuonTrigCoinData/MuonCoinDataCollection.h"
#include "CLIDSvc/CLASS_DEF.h"
namespace Muon {
typedef MuonCoinDataCollection< RpcCoinData > RpcCoinDataCollection;
}
/**Overload of << operator for MsgStream for debug output*/
MsgStream& operator << ( MsgStream& sl, const Muon::RpcCoinDataCollection & coll);
/**Overload of << operator for std::ostream for debug output*/
std::ostream& operator << ( std::ostream& sl, const Muon::RpcCoinDataCollection& coll);
CLASS_DEF(Muon::RpcCoinDataCollection, 1216812642, 1 )
#endif
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONTRIGCOINDATA_RPCCOINDATACONTAINER_H
#define MUONTRIGCOINDATA_RPCCOINDATACONTAINER_H
#include "MuonTrigCoinData/MuonCoinDataContainer.h"
#include "MuonTrigCoinData/RpcCoinDataCollection.h"
#include "CLIDSvc/CLASS_DEF.h"
namespace Muon {
typedef MuonCoinDataContainer< RpcCoinDataCollection > RpcCoinDataContainer;
}
CLASS_DEF( Muon::RpcCoinDataContainer , 1190485326 , 1 )
#endif
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
///////////////////////////////////////////////////////////////////
// TgcCoinData.h
// Header file for class TgcCoinData
///////////////////////////////////////////////////////////////////
// (c) ATLAS Detector software
///////////////////////////////////////////////////////////////////
#ifndef MUONTRIGCOINDATA_TGCCOINDATA_H
#define MUONTRIGCOINDATA_TGCCOINDATA_H
#include "Identifier/Identifier.h"
#include "Identifier/IdentifierHash.h"
#include "GeoPrimitives/GeoPrimitives.h"
#include "EventPrimitives/EventPrimitives.h"
#include "MuonReadoutGeometry/TgcReadoutElement.h"
#include "TrkSurfaces/Surface.h"
#include "DataModel/tools/IdentContIndex.h"
#include <inttypes.h>
#include "GaudiKernel/MsgStream.h"
#include <iostream>
class TgcCoinDataContainerCnv;
namespace Muon
{
class TgcCoinData {
///////////////////////////////////////////////////////////////////
// Public methods:
///////////////////////////////////////////////////////////////////
public:
friend class ::TgcCoinDataContainerCnv;
typedef enum {
TYPE_TRACKLET,
TYPE_HIPT,
TYPE_SL,
TYPE_UNKNOWN,
TYPE_TRACKLET_EIFI
} CoinDataType;
/** Public, Copy, operator=, constructor*/
TgcCoinData();
TgcCoinData(const TgcCoinData &);
TgcCoinData &operator=(const TgcCoinData &);
/** Overload of << operator for MsgStream for debug output*/
friend MsgStream& operator << (MsgStream& sl, const TgcCoinData& coin);
/** Overload of << operator for std::ostream for debug output*/
friend std::ostream& operator << (std::ostream& sl, const TgcCoinData& coin);
/// Constructor:
//for HIPT and TRACKLET
TgcCoinData( const Identifier& channelIdIn,
const Identifier& channelIdOut,
const IdentifierHash &collectionIdHash,
const MuonGM::TgcReadoutElement* detElIn,
const MuonGM::TgcReadoutElement* detElOut,
const CoinDataType type,
const bool isAside,
const int phi,
const bool isForward,
const bool isStrip,
const int trackletId,
const Amg::Vector2D *posIn,
const Amg::Vector2D *posOut,
const double widthIn,
const double widthOut,
const int delta,
const int sub);
//for TYPE_TRACKLET_EIFI
TgcCoinData( const Identifier& channelIdIn,
const IdentifierHash &collectionIdHash,
const MuonGM::TgcReadoutElement* detElIn,
const CoinDataType type,
const bool isAside,
const int phi,
const bool isForward,
const bool isStrip,
const Amg::Vector2D *posIn,
const double widthIn,
const int sub);
//for SL
TgcCoinData( const Identifier& channelIdOut,
const IdentifierHash &collectionIdHash,