Changed level 1 trigger and added level 2 trigger and EF chain information (ALFA_RawEv-00-00-16)

ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_Digit.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ALFA_Digit_h
+#define ALFA_Digit_h
+
+class ALFA_Digit {
+  
+ public:
+  
+  ALFA_Digit();
+  ALFA_Digit(const unsigned short station, const unsigned short plate, const unsigned short fiber);
+  
+  inline unsigned short getStation() const { return m_station; }  
+  inline unsigned short getPlate()   const { return m_plate; }
+  inline unsigned short getFiber()   const { return m_fiber; }
+  
+ private: 
+  
+  unsigned short m_station; 
+  unsigned short m_plate;
+  unsigned short m_fiber;
+};
+
+#endif

ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_DigitCollection.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ALFA_DigitCollection_h
+#define ALFA_DigitCollection_h
+
+#include "DataModel/DataVector.h"
+#include "CLIDSvc/CLASS_DEF.h"
+#include "ALFA_RawEv/ALFA_Digit.h"
+
+#include "HitManagement/AthenaHitsVector.h"
+
+#ifndef __CINT__
+  #include "CLIDSvc/CLASS_DEF.h"
+#endif
+
+
+class ALFA_DigitCollection: public DataVector<ALFA_Digit> {
+  
+ public:
+  
+  ALFA_DigitCollection() {}
+};
+
+
+//typedef AthenaHitsVector<ALFA_Digit> ALFA_DigitCollection;
+
+//typedef AthenaHitsVector<ALFA_Digit>::iterator ALFA_DigitIterator;
+//typedef AthenaHitsVector<ALFA_Digit>::const_iterator ALFA_DigitConstIterator;
+
+
+typedef ALFA_DigitCollection::iterator       ALFA_DigitIterator;
+typedef ALFA_DigitCollection::const_iterator ALFA_DigitConstIterator;
+
+
+#ifndef __CINT__
+CLASS_DEF(ALFA_DigitCollection, 1307251830, 1)
+#endif
+  
+#endif

ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_ODDigit.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ALFA_ODDigit_h
+#define ALFA_ODDigit_h
+
+class ALFA_ODDigit {
+  
+ public:
+  
+  ALFA_ODDigit();
+  ALFA_ODDigit(const unsigned short station, const unsigned short side, const unsigned short plate, const unsigned short fiber);
+  
+  inline unsigned short getStation() const { return m_station; }
+  inline unsigned short getSide()    const { return m_side; }    
+  inline unsigned short getPlate()   const { return m_plate; }
+  inline unsigned short getFiber()   const { return m_fiber; }
+  
+ private: 
+  
+  unsigned short m_station;
+  unsigned short m_side;   
+  unsigned short m_plate;
+  unsigned short m_fiber;
+};
+
+#endif

ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_ODDigitCollection.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ALFA_ODDigitCollection_h
+#define ALFA_ODDigitCollection_h
+
+#include "DataModel/DataVector.h"
+#include "CLIDSvc/CLASS_DEF.h"
+#include "ALFA_RawEv/ALFA_ODDigit.h"
+
+#include "HitManagement/AthenaHitsVector.h"
+
+#ifndef __CINT__
+  #include "CLIDSvc/CLASS_DEF.h"
+#endif
+
+
+class ALFA_ODDigitCollection: public DataVector<ALFA_ODDigit> {
+  
+ public:
+  
+  ALFA_ODDigitCollection() {}
+};
+
+
+typedef ALFA_ODDigitCollection::iterator       ALFA_ODDigitIterator;
+typedef ALFA_ODDigitCollection::const_iterator ALFA_ODDigitConstIterator;
+
+// CLID
+#ifndef __CINT__
+CLASS_DEF( ALFA_ODDigitCollection , 1269800463 , 1 )
+#endif
+  
+#endif

ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawData.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ALFA_RAWDATA_H
+#define ALFA_RAWDATA_H
+
+#include<stdint.h>
+#include<vector>
+#include <iostream>
+
+
+/** ALFA RDO's 
+    @author Sara Diglio, Sept 2009
+    from MuonRDO/ALFA_RawData.h
+*/
+
+class MsgStream;
+
+class ALFA_RawData
+{
+ public:
+  
+  // Default constructor
+  ALFA_RawData();
+  
+  // Full constructor 
+  ALFA_RawData(uint16_t PMF_number);  
+ 
+  ~ALFA_RawData(); 
+ 
+  // set data members
+
+  void SetWordId_PMF(uint16_t Word_number);
+  void SetPMFId_PMF(uint16_t PMF_number);
+  void SetMBId_PMF(uint16_t MB_number);
+  void SetEventCount_PMF(uint32_t Event_number);
+  void SetMarocChan_PMF(std::vector<uint16_t> MarocChan);
+  void PushBack_PMF(uint16_t fiber_hit);
+  void Set_error_bit17(bool bit);
+
+  void SetZero_PMF();
+  
+
+  // Add a data word to the vector
+  void addData(uint32_t dataWord); // from MUON to test
+    
+  // Methods to retrieve the decoded word content
+
+  uint16_t GetWordId_PMF() {return WordId;};
+  uint16_t GetPMFId_PMF() {return PMFId;};
+  uint16_t GetMBId_PMF() {return MBId;};
+  uint32_t GetEventCount_PMF() {return EventCount;};
+  std::vector<uint16_t> GetMarocHit() {return MarocChan;};
+  uint32_t Get_Chan(uint16_t Numchan) {return MarocChan[Numchan];}; // used in SaraPkg
+  uint32_t GetSize() {return MarocChan.size();};
+  uint16_t Get_bit26_27() {return m_bit26_27;};
+  uint16_t Get_bit24_27()   {return m_bit24_27;};	
+  bool Get_bit16() {return m_bit16;};
+  bool Get_bit18() {return m_bit18;};
+  bool Get_error_bit17() {return m_error_bit17;};
+
+  // Vector containing all 16 bits data words (undecoded) 
+  std::vector<uint16_t> HitChan() const {return MarocChan;}
+
+  // Vector containing all 32 bits data words (undecoded) : from the Muon BSC-> to test the structure
+  std::vector<uint32_t>* dataWords() const {return p_dataWords;}
+
+ private:
+    
+  // Data info TSM: 
+  uint16_t WordId;
+  uint16_t PMFId;  
+  uint16_t MBId; 
+  uint32_t EventCount;
+  std::vector<uint16_t> MarocChan; // sostituisce il p_hit di prima
+  bool     m_bit16;
+  bool     m_bit18;
+  bool     m_error_bit17;
+  uint16_t     m_bit26_27;
+  uint16_t     m_bit24_27;	
+
+  // All the datawords (no headers and footers) coming from this channel 
+  // to be decoded on demand using ALFA_ReadOut methods
+  std::vector<uint32_t>* p_dataWords;
+
+};
+#endif // ALFA_RAWDATA_H
+
+

ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawDataCollection.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef  ALFA_RAWDATACOLLECTION_H
+#define  ALFA_RAWDATACOLLECTION_H
+
+#include "DataModel/DataVector.h"
+#include "SGTools/CLASS_DEF.h"
+#include "CLIDSvc/CLASS_DEF.h"
+#include "ALFA_RawEv/ALFA_RawData.h"
+
+#include<stdint.h>
+
+/** RDOs : Chamber Service Module, collection of RawData
+    @author sara diglio Sept 2009*/
+
+
+class ALFA_RawDataCollection : public DataVector<ALFA_RawData>
+{
+
+ private:
+ 
+  //Motherboard id
+  uint16_t MBId_POT;
+  //Mrod id
+  uint16_t MrodId_POT;
+  //Event counter
+  uint32_t EventCount_POT;
+  //Hit store for one PMF
+  std::vector<ALFA_RawData> POT_DATA;
+
+  //pattern id
+  std::vector<bool> patternId;
+  //scaler id
+  uint16_t scalerId;
+  //ADC1 id Chan0
+  uint16_t ADC1Id;
+  //ADC1 id Chan1
+  uint16_t ADC2Id;
+  //syncronization error of PMF 24 (trigger info)
+  bool TrigSyncErrId;
+
+ public:
+  //typedef 
+  typedef ALFA_RawData DIGIT; 
+  
+  
+  /** Default constructor*/
+  ALFA_RawDataCollection();
+
+
+  /** Full constructor*/
+  ALFA_RawDataCollection(uint16_t MB_number);
+
+  /** Full constructor*/
+  ALFA_RawDataCollection(uint16_t Mrod_number, uint16_t MB_number);
+
+  virtual ~ALFA_RawDataCollection() { };
+
+  // set data members
+
+  void SetMBId_POT(uint16_t MB_number);
+  void SetMrodId_POT(uint16_t Mrod_number);
+  void SetEventCount_POT(uint32_t Event_number);
+  void PushBack_POT(ALFA_RawData PMF_HIT);
+  
+  void Set_pattern_POT(std::vector<bool> pattern_number);
+  void Set_scaler_POT(uint16_t scaler_number);
+  void Set_ADC1_POT(uint16_t ADC1_number);
+  void Set_ADC2_POT(uint16_t ADC2_number);
+  void SetTrigSyncErr(bool bit);  
+
+  void SetZero_POT();
+  
+ 
+
+  // Methods to access the decoded information
+ 
+
+  uint16_t GetMBId_POT(){return MBId_POT;};
+  uint16_t GetMrodId_POT(){return MrodId_POT;};
+  uint32_t GetEventCount_POT() {return EventCount_POT;};
+  std::vector<bool> Get_pattern_POT() {return patternId;};
+  uint16_t Get_scaler_POT() {return scalerId;};
+  uint16_t Get_ADC1_POT() {return ADC1Id;};
+  uint16_t Get_ADC2_POT() {return ADC2Id;};
+  bool GetTrigSyncErr() {return TrigSyncErrId;};
+
+  std::vector<ALFA_RawData> Get_POT_DATA() {return POT_DATA;};
+  ALFA_RawData Get_POT_PMF_DATA(uint32_t Numpmf) {return POT_DATA[Numpmf];};
+
+
+};
+
+CLASS_DEF( ALFA_RawDataCollection , 1127672441 , 1 )
+
+
+#endif   //  ALFA_RAWDATACOLLECTION_H
+

ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawDataCollection_charge.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef  ALFA_RAWDATACOLLECTION_CHARGE_H
+#define  ALFA_RAWDATACOLLECTION_CHARGE_H
+
+#include "DataModel/DataVector.h"
+#include "SGTools/CLASS_DEF.h"
+#include "CLIDSvc/CLASS_DEF.h"
+#include "ALFA_RawEv/ALFA_RawData_charge.h"
+
+#include<stdint.h>
+
+/** RDOs : Chamber Service Module, collection of RawData
+    @author sara diglio Sept 2009*/
+
+
+class ALFA_RawDataCollection_charge : public DataVector<ALFA_RawData_charge>
+{
+
+ private:
+ 
+  //Motherboard id
+  uint16_t MBId_POT;
+  //Mrod id
+  uint16_t MrodId_POT;
+  //Event counter
+  uint32_t EventCount_POT;
+  //Hit store for one PMF
+  std::vector<ALFA_RawData_charge> POT_DATA;
+  //Time Stamp
+  uint32_t TimeStamp_POT;
+  //Bunch Crossing ID
+  uint32_t BCId_POT;
+
+ public:
+  //typedef 
+  typedef ALFA_RawData_charge DIGIT; 
+  
+  
+  /** Default constructor*/
+  ALFA_RawDataCollection_charge();
+
+
+  /** Full constructor*/
+  ALFA_RawDataCollection_charge(uint16_t MB_number);
+
+  /** Full constructor*/
+  ALFA_RawDataCollection_charge(uint16_t Mrod_number, uint16_t MB_number);
+
+  virtual ~ALFA_RawDataCollection_charge() { };
+
+  // set data members
+
+  void SetMBId_POT(uint16_t MB_number) ;
+  void SetMrodId_POT(uint16_t Mrod_number) ;
+  void SetEventCount_POT(uint32_t Event_number);
+  void PushBack_POT(ALFA_RawData_charge PMF_HIT);
+  
+  void SetTimeStamp_POT(uint32_t TimeStamp);
+  void SetBCId_POT(uint32_t BCId);
+  
+  void SetZero_POT();
+  
+  // Methods to access the decoded information
+ 
+  uint16_t GetMBId_POT(){return MBId_POT;};
+  uint16_t GetMrodId_POT(){return MrodId_POT;};
+  uint32_t GetEventCount_POT() {return EventCount_POT;};
+ 
+  uint32_t GetTimeStamp_POT() {return TimeStamp_POT;};	
+  uint32_t GetBCId_POT() {return BCId_POT;};	
+
+  std::vector<ALFA_RawData_charge> Get_POT_DATA() {return POT_DATA;};
+  ALFA_RawData_charge Get_POT_PMF_DATA(uint32_t Numpmf) {return POT_DATA[Numpmf];};
+
+
+};
+
+CLASS_DEF( ALFA_RawDataCollection_charge , 1210134863 , 1 )
+
+
+#endif   //  ALFA_RAWDATACOLLECTION_CHARGE_H
+

ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawDataContainer.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ALFA_RAWDATACONTAINER_H
+#define ALFA_RAWDATACONTAINER_H
+
+#include <vector>
+#include <string>
+#include "ALFA_RawEv/ALFA_RawDataCollection.h"
+#include "SGTools/CLASS_DEF.h"
+#include "CLIDSvc/CLASS_DEF.h"
+#include "DataModel/DataVector.h"
+//#include "EventContainers/IdentifiableContainer.h" 
+
+/** This container provides acces to the PMF RDOs
+    @author Sara Diglio, Sept 2009
+*/
+
+
+//class ALFA_RawDataContainer : public IdentifiableContainer<ALFA_RawDataCollection> {
+class ALFA_RawDataContainer : public DataVector<ALFA_RawDataCollection> {
+
+ private:
+
+  // Raw data word and word header
+ 
+  uint32_t m_wordMarker;
+ 
+  // I added runNum, runType, DetEventType
+  // modification based on page19 MROD data format document and on ALFA dumped data file
+  uint32_t m_dataWord;
+
+  // Data members
+  uint16_t m_subdetId;   // Sub-detector Id 
+  uint16_t m_mrodId;     // MROD Id
+  uint32_t m_lvl1Id;     // Lvl1 Id
+  uint16_t m_ecrId;      // ECR Id
+  uint16_t m_bcId;       // Bunch crossing Id
+  uint32_t m_runNum;     // Run sequence number
+  uint16_t m_runType;       // Run Type
+  uint16_t m_triggerTypeId; // Trigger type Id
+  uint32_t m_DetEventType;     // Detector Event Type
+
+  // Data words in the ROD header
+  
+  // Full Event marker
+  static const uint32_t FullEVmarker = 0xaa1234aa;
+  // ROB marker
+  static const uint32_t ROBmarker = 0xdd1234dd;
+  // ROD marker
+  static const uint32_t RODmarker = 0xee1234ee;
+
+  static const uint32_t RODheadersize = 0x00000009; 
+  static const uint32_t RODversion  = 0x03010000;      
+
+  //Time Stamp
+  uint32_t TimeStamp;
+  //Time Stamp ns
+  uint32_t TimeStampns;
+  //Bunch Crossing ID
+  uint32_t BCId;
+  //LumiBlock ID
+  uint32_t LumiBlock;
+  //Lvl1 trigger pattern (fired items in lvl1 trigger)
+  std::vector<bool> lvl1Pattern;
+  //Lvl2 trigger pattern (fired items in lvl2 trigger)
+  std::vector<bool> lvl2Pattern;
+  //EF pattern (fired items in EF)
+  std::vector<bool> efPattern;
+
+ public:  
+
+  ALFA_RawDataContainer() ; 
+  ~ALFA_RawDataContainer() ; 
+
+  typedef ALFA_RawDataCollection::size_type size_type ; 
+ 
+  size_type digit_size() const ; 
+
+  bool is_FullEVmarker() {return m_wordMarker == FullEVmarker;};
+  bool is_ROBmarker() {return m_wordMarker == ROBmarker;};  	
+  bool is_RODmarker() {return m_wordMarker == RODmarker;};  	
+  
+
+  // Retrieve decoded results
+  uint16_t subdetId()   {return m_subdetId;}
+  uint16_t mrodId()     {return m_mrodId;}
+  uint32_t runNum()     {return m_runNum;}
+  uint16_t runType()    {return m_runType;}
+  uint32_t lvl1Id()     {return m_lvl1Id;}
+  uint16_t ecrId()      {return m_ecrId;}
+  uint16_t bcId()       {return m_bcId;}
+  uint16_t trigtypeId() {return m_triggerTypeId;}
+  uint32_t DetEventType()     {return m_DetEventType;}
+  
+
+  void SetLvl1Pattern(std::vector<bool> tmplvl1_pattern);
+  void SetLvl2Pattern(std::vector<bool> tmplvl2_pattern);
+  void SetEFPattern(std::vector<bool> tmpef_pattern);
+  void SetTimeStamp(uint32_t tmpTimeStamp);
+  void SetTimeStampns(uint32_t tmpTimeStampns);
+  void SetLumiBlock(uint32_t tmpLumiBlock);
+  void SetBCId(uint32_t tmpBCId);
+
+  std::vector<bool> GetLvl1Pattern_POT() const {return lvl1Pattern;};
+  std::vector<bool> GetLvl2Pattern_POT() const {return lvl2Pattern;};
+  std::vector<bool> GetEFPattern_POT() const {return efPattern;};
+  uint32_t GetTimeStamp() const {return TimeStamp;};	
+  uint32_t GetTimeStampns() const {return TimeStampns;};	
+  uint32_t GetLumiBlock() const {return LumiBlock;};
+  uint32_t GetBCId() const {return BCId;};	
+
+ private:
+  
+  // Private functions
+  void setZero();
+    
+};
+
+CLASS_DEF( ALFA_RawDataContainer , 1083669809 , 0 ) // da rimettere a posto prima di sottomettere in SVN
+
+
+#endif     // ALFA_RAWDATACONTAINER_H

ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawDataContainer_charge.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ALFA_RAWDATACONTAINER_CHARGE_H
+#define ALFA_RAWDATACONTAINER_CHARGE_H
+
+#include <vector>
+#include <string>
+#include "ALFA_RawEv/ALFA_RawDataCollection_charge.h"
+#include "SGTools/CLASS_DEF.h"
+#include "CLIDSvc/CLASS_DEF.h"
+#include "DataModel/DataVector.h"
+//#include "EventContainers/IdentifiableContainer.h" 
+
+/** This container provides acces to the PMF RDOs
+    @author Sara Diglio, Sept 2009
+*/
+
+
+//class ALFA_RawDataContainer_charge : public IdentifiableContainer<ALFA_RawDataCollection_charge> {
+class ALFA_RawDataContainer_charge : public DataVector<ALFA_RawDataCollection_charge> {
+
+ private:
+  // Raw data word and word header
+  uint32_t m_wordMarker;
+
+  // I added runNum, runType, DetEventType
+  // modification based on page19 MROD data format document and on ALFA dumped data file
+  uint32_t m_dataWord;
+
+  // Data members
+  uint16_t m_subdetId;   // Sub-detector Id 
+  uint16_t m_mrodId;     // MROD Id
+  uint32_t m_lvl1Id;     // Lvl1 Id
+  uint16_t m_ecrId;      // ECR Id
+  uint16_t m_bcId;       // Bunch crossing Id
+  uint32_t m_runNum;     // Run sequence number
+  uint16_t m_runType;       // Run Type
+  uint16_t m_triggerTypeId; // Trigger type Id
+  uint32_t m_DetEventType;     // Detector Event Type
+
+  // Data words in the ROD header
+  
+  // Full Event marker
+  static const uint32_t FullEVmarker = 0xaa1234aa;
+  // ROB marker
+  static const uint32_t ROBmarker = 0xdd1234dd;
+  // ROD marker
+  static const uint32_t RODmarker = 0xee1234ee;
+
+  static const uint32_t RODheadersize = 0x00000009; 
+  static const uint32_t RODversion  = 0x03010000;      
+
+ public:  
+
+  ALFA_RawDataContainer_charge() ; 
+  ~ALFA_RawDataContainer_charge() ; 
+
+  typedef ALFA_RawDataCollection_charge::size_type size_type ; 
+ 
+  size_type digit_size() const ; 
+
+  bool is_FullEVmarker() {return m_wordMarker == FullEVmarker;};
+  bool is_ROBmarker() {return m_wordMarker == ROBmarker;};  	
+  bool is_RODmarker() {return m_wordMarker == RODmarker;};  	
+
+  // Retrieve decoded results
+  uint16_t subdetId()   {return m_subdetId;}
+  uint16_t mrodId()     {return m_mrodId;}
+  uint32_t runNum()     {return m_runNum;}
+  uint16_t runType()    {return m_runType;}
+  uint32_t lvl1Id()     {return m_lvl1Id;}
+  uint16_t ecrId()      {return m_ecrId;}
+  uint16_t bcId()       {return m_bcId;}
+  uint16_t trigtypeId() {return m_triggerTypeId;}
+  uint32_t DetEventType()     {return m_DetEventType;}
+  
+ private:
+  
+  // Private functions
+  void setZero();
+    
+};
+
+CLASS_DEF( ALFA_RawDataContainer_charge , 1146048907, 0 ) 
+
+
+#endif     // ALFA_RAWDATACONTAINER_CHARGE_H

ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawData_charge.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ALFA_RAWDATA_CHARGE_H
+#define ALFA_RAWDATA_CHARGE_H
+
+#include<stdint.h>
+#include<vector>
+#include <iostream>
+
+
+/** ALFA RDO's 
+    @author Sara Diglio, Sept 2009
+    from MuonRDO/ALFA_RawData.h
+*/
+
+class MsgStream;
+
+class ALFA_RawData_charge
+{
+ public:
+  
+  // Default constructor
+  ALFA_RawData_charge();
+  
+  // Full constructor 
+  ALFA_RawData_charge(uint16_t PMF_number);  
+    
+  ~ALFA_RawData_charge();
+
+  // set data members
+
+  void SetPMFId_PMF(uint16_t PMF_number);
+  void SetChannelNum_PMF(uint16_t Channel_number);
+  void SetMBId_PMF(uint16_t MB_number);
+  void SetFiberFirmware_PMF(uint16_t FiberFirmware_number);
+  void SetEventCount_PMF(uint32_t Event_number);
+  void SetChargeChan_PMF(uint16_t ChargeChan_number);
+
+  void SetChargeChanVect_PMF(std::vector<uint16_t> ChargeChan);
+  void PushBack_PMF(uint16_t ChargeChan_number);
+
+  void SetZero_PMF();
+
+  // Add a data word to the vector
+  void addData(uint32_t dataWord); 
+  
+  // Methods to retrieve the decoded word content
+
+  uint16_t GetPMFId_PMF() {return PMFId;};
+  uint16_t GetChannelNum_PMF() {return ChannelNumId;};
+  uint16_t GetMBId_PMF() {return MBId;};
+  uint16_t GetFiberFirmware_PMF() {return FiberFirmwareId;};
+  uint32_t GetEventCount_PMF() {return EventCount;};
+  uint16_t GetChargeHit() {return ChargeChanId;};
+
+  // std::vector<uint16_t> GetMarocHit() {return MarocChan;};
+  // uint32_t Get_Chan(uint16_t Numchan) {return MarocChan[Numchan];}; // used in SaraPkg
+
+  bool Get_bit12() {return m_bit12;};
+
+  // Vector containing all 16 bits data words (undecoded)
+  std::vector<uint16_t> ChargeChanVect_number() const {return ChargeChan;}
+
+  // Vector containing all 32 bits data words (undecoded) : from the Muon BSC-> to test the structure
+  std::vector<uint32_t>* dataWords() const {return p_dataWords;}
+
+ private:
+
+  // Data info TSM: 
+  uint16_t ChannelNumId;
+  uint16_t PMFId;  
+  uint16_t MBId; 
+  uint16_t  FiberFirmwareId; 
+  uint32_t EventCount;
+  uint16_t ChargeChanId; 
+  bool     m_bit12;
+  std::vector<uint16_t> ChargeChan; 
+ 
+  // All the datawords (no headers and footers) coming from this channel 
+  // to be decoded on demand using ALFA_ReadOut methods
+  std::vector<uint32_t>* p_dataWords;
+
+};
+#endif // ALFA_RAWDATA_CHARGE_H
+
+

ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawEvDict.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ALFA_RawEvDict_h
+#define ALFA_RawEvDict_h
+
+#include "ALFA_RawEv/ALFA_DigitCollection.h"
+#include "ALFA_RawEv/ALFA_ODDigitCollection.h"
+
+// collection
+#include "ALFA_RawEv/ALFA_RawDataCollection.h"
+// container
+#include "ALFA_RawEv/ALFA_RawDataContainer.h"
+
+#endif
+ 

ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/selection.xml

+ 
+<lcgdict>
+  <class name="ALFA_DigitCollection" id="0F21F6BB-6719-41D3-8219-3ABF523826CD"/>
+  <class name="std::vector<ALFA_Digit*>" />
+  <class name="DataVector<ALFA_Digit>" />
+  <class name="ALFA_Digit" />
+  <class name="ALFA_ODDigitCollection" id="72E4BD80-E8B1-4C24-AA0F-E5C6D1B741AD"/>
+  <class name="std::vector<ALFA_ODDigit*>" />
+  <class name="DataVector<ALFA_ODDigit>" />
+  <class name="ALFA_ODDigit" />  
+  
+  <class name="ALFA_RawDataContainer" id="D2E1A2A4-43C0-4B72-8264-AB91ED079564"/>
+  <class name="std::vector<ALFA_RawDataCollection*>" />
+  <class name="DataVector<ALFA_RawDataCollection>" />
+
+  <class name="ALFA_RawDataCollection" />
+  <class name="std::vector<ALFA_RawData*>" />
+  <class name="DataVector<ALFA_RawData>" />
+    
+  <class name="ALFA_RawData" />
+</lcgdict>
+

ForwardDetectors/ALFA/ALFA_RawEv/cmt/install.history

+(i__main__
+LogFile
+p0
+(dp1
+S'_installed_files'
+p2
+(dp3
+S'../../../MyTestDir/ForwardDetectors/ALFA/ALFA_RawEv/i686-slc5-gcc43-opt/libALFA_RawEvDict.so'
+p4
+S'../../../../../InstallArea/i686-slc5-gcc43-opt/lib/libALFA_RawEvDict.so'
+p5
+sS'../../../ForwardDetectors/ALFA/ALFA_RawEv/i686-slc5-gcc43-dbg/libALFA_RawEv.so'
+p6
+S'../../../../InstallArea/i686-slc5-gcc43-dbg/lib/libALFA_RawEv.so'
+p7
+sS'../../../16.0.3/MyTestDir/ForwardDetectors/ALFA/ALFA_RawEv/i686-slc5-gcc43-dbg/libALFA_RawEvDict.so'
+p8
+S'../../../../../../InstallArea/i686-slc5-gcc43-dbg/lib/libALFA_RawEvDict.so'
+p9
+sS'../../../MyTestDir/ForwardDetectors/ALFA/ALFA_RawEv/i686-slc5-gcc43-dbg/libALFA_RawEvDict.so'
+p10
+S'../../../../../InstallArea/i686-slc5-gcc43-dbg/lib/libALFA_RawEvDict.so'
+p11
+sS'../../../MyTestDir/ForwardDetectors/ALFA/ALFA_RawEv/i686-slc5-gcc43-opt/libALFA_RawEv.so'
+p12
+S'../../../../../InstallArea/i686-slc5-gcc43-opt/lib/libALFA_RawEv.so'
+p13
+sS'../../../../MyTestDir3/ForwardDetectors/ALFA/ALFA_RawEv/i686-slc5-gcc43-dbg/libALFA_RawEv.so'
+p14
+S'../../../../../MyTestDir/InstallArea/i686-slc5-gcc43-dbg/lib/libALFA_RawEv.so'
+p15
+sS'../../../testarea/16.0.3/MyTestDir/ForwardDetectors/ALFA/ALFA_RawEv/i686-slc5-gcc43-dbg/libALFA_RawEvDict.so'
+p16
+S'../../../../../../../InstallArea/i686-slc5-gcc43-dbg/lib/libALFA_RawEvDict.so'
+p17
+sS'../../../16.0.3/MyTestDir/ForwardDetectors/ALFA/ALFA_RawEv/i686-slc5-gcc43-dbg/libALFA_RawEv.so'
+p18
+S'../../../../../../InstallArea/i686-slc5-gcc43-dbg/lib/libALFA_RawEv.so'
+p19
+sS'../../../testarea/16.0.3/MyTestDir/ForwardDetectors/ALFA/ALFA_RawEv/i686-slc5-gcc43-dbg/libALFA_RawEv.so'
+p20
+S'../../../../../../../InstallArea/i686-slc5-gcc43-dbg/lib/libALFA_RawEv.so'
+p21
+sS'../../../../MyTestDir3/ForwardDetectors/ALFA/ALFA_RawEv/i686-slc5-gcc43-dbg/libALFA_RawEvDict.so'
+p22
+S'../../../../../MyTestDir/InstallArea/i686-slc5-gcc43-dbg/lib/libALFA_RawEvDict.so'
+p23
+sS'../../../MyTestDir/ForwardDetectors/ALFA/ALFA_RawEv/i686-slc5-gcc43-dbg/libALFA_RawEv.so'
+p24
+S'../../../../../InstallArea/i686-slc5-gcc43-dbg/lib/libALFA_RawEv.so'
+p25
+sS'../../../ForwardDetectors/ALFA/ALFA_RawEv/i686-slc5-gcc43-dbg/libALFA_RawEvDict.so'
+p26
+S'../../../../InstallArea/i686-slc5-gcc43-dbg/lib/libALFA_RawEvDict.so'
+p27
+ssb.
\ No newline at end of file

ForwardDetectors/ALFA/ALFA_RawEv/cmt/requirements

+package ALFA_RawEv
+
+author Tomas Sykora <tomas.sykora@cern.ch>, Sara Diglio <Sara.Diglio@cern.ch>
+
+
+use AtlasPolicy           AtlasPolicy-01-*
+use CLIDSvc               CLIDSvc-*                  Control
+use DataModel             DataModel-*                Control
+
+use HitManagement	  HitManagement-00-*	     Simulation
+
+use SGTools               SGTools-*                  Control
+use AtlasReflex   AtlasReflex-00-*   External -no_auto_imports
+
+library  ALFA_RawEv ../src/*.cxx
+
+apply_pattern installed_library
+
+apply_pattern lcgdict dict=ALFA_RawEv selectionfile=selection.xml headerfiles="../ALFA_RawEv/ALFA_RawEvDict.h"
+
+
+private
+
+
+use GaudiInterface        GaudiInterface-*           External 
+use EventContainers       EventContainers-*          Event
+use StoreGate             StoreGate-*                Control
+
+end_private

ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_Digit.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+ 
+#include "ALFA_RawEv/ALFA_Digit.h"
+#include <iostream>
+
+ALFA_Digit::ALFA_Digit():
+  m_station(0), 
+  m_plate(0),
+  m_fiber(0)
+{}
+
+ALFA_Digit::ALFA_Digit(const unsigned short station, const unsigned short plate, const unsigned short fiber): m_station(station), m_plate(plate), m_fiber(fiber) {}

ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_DigitCollection.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+#include <stdio.h>
+#include <typeinfo>
+
+#include "ALFA_RawEv/ALFA_DigitCollection.h"

ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_ODDigit.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+ 
+#include "ALFA_RawEv/ALFA_ODDigit.h"
+#include <iostream>
+
+ALFA_ODDigit::ALFA_ODDigit():
+  m_station(0),
+  m_side(0),
+  m_plate(0),
+  m_fiber(0)
+{}
+
+ALFA_ODDigit::ALFA_ODDigit(const unsigned short station, const unsigned short side, const unsigned short plate, const unsigned short fiber): m_station(station), m_side(side), m_plate(plate), m_fiber(fiber) {}

ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_ODDigitCollection.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+#include <stdio.h>
+#include <typeinfo>
+
+#include "ALFA_RawEv/ALFA_ODDigitCollection.h"

ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_RawData.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "ALFA_RawEv/ALFA_RawData.h"
+#include "GaudiKernel/MsgStream.h"
+
+ALFA_RawData::ALFA_RawData():
+  WordId(0),
+  PMFId(0),  
+  MBId(0), 
+  EventCount(0),
+  MarocChan(),
+  m_bit16(0),
+  m_bit18(0),
+  m_error_bit17(0),
+  m_bit26_27(0),
+  m_bit24_27(0)
+{
+  p_dataWords = new std::vector<uint32_t>();
+}
+
+ALFA_RawData::ALFA_RawData(uint16_t PMFId):
+  WordId(0),
+  PMFId(PMFId),  
+  MBId(0), 
+  EventCount(0),
+  MarocChan(),
+  m_bit16(0),
+  m_bit18(0),
+  m_error_bit17(0),
+  m_bit26_27(0),
+  m_bit24_27(0)
+{
+  p_dataWords = new std::vector<uint32_t>();
+}
+
+////////////////////////
+// destructor
+////////////////////////
+ALFA_RawData::~ALFA_RawData()
+{
+  if (p_dataWords) delete p_dataWords;
+}
+
+
+void ALFA_RawData::SetWordId_PMF(uint16_t Word_number)
+{
+  WordId=Word_number;
+}
+
+void ALFA_RawData::SetPMFId_PMF(uint16_t PMF_number)
+{
+  PMFId=PMF_number;
+}
+
+void ALFA_RawData::SetMBId_PMF(uint16_t MB_number)
+{
+  MBId=MB_number;
+}
+
+void ALFA_RawData::SetEventCount_PMF(uint32_t Event_number)
+{
+  EventCount=Event_number;
+}
+
+
+void ALFA_RawData::SetMarocChan_PMF(std::vector<uint16_t> HitChan)
+{
+  MarocChan=HitChan;
+
+
+}
+
+void ALFA_RawData::PushBack_PMF(uint16_t fiber_hit){
+  MarocChan.push_back(fiber_hit);
+}
+
+void ALFA_RawData::addData(uint32_t dataWord) 
+{
+  p_dataWords->push_back(dataWord);
+}
+
+void ALFA_RawData::Set_error_bit17(bool bit)
+{
+  m_error_bit17=bit;
+}
+
+
+void ALFA_RawData::SetZero_PMF() 
+{
+  WordId=0;
+  PMFId=0; 
+  MBId=0;
+  EventCount=0; 
+  m_bit26_27=0;
+  m_bit24_27=0;
+  m_bit16=false;
+  m_bit18=false;
+  m_error_bit17=false;
+  MarocChan.clear();
+  p_dataWords->clear();
+}
+
+

ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_RawDataCollection.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "ALFA_RawEv/ALFA_RawDataCollection.h"
+//#include "GaudiKernel/MsgStream.h"
+
+// Default constructor
+ALFA_RawDataCollection::ALFA_RawDataCollection() :
+  DataVector<ALFA_RawData>(),
+  MBId_POT(0),
+  MrodId_POT(0),
+  EventCount_POT(0),
+  POT_DATA(),
+  patternId(),
+  scalerId(0),
+  ADC1Id(0),
+  ADC2Id(0),
+  TrigSyncErrId(0)
+{ }
+
+// Full constructor
+ALFA_RawDataCollection::ALFA_RawDataCollection(uint16_t MB_number) :
+  DataVector<ALFA_RawData>(),
+  MBId_POT(MB_number),
+  MrodId_POT(0),
+  EventCount_POT(0),
+  POT_DATA(),
+  patternId(),
+  scalerId(0),
+  ADC1Id(0),
+  ADC2Id(0),
+  TrigSyncErrId(0)
+{ }
+
+// Full constructor
+ALFA_RawDataCollection::ALFA_RawDataCollection( uint16_t Mrod_number, uint16_t MB_number) :
+  DataVector<ALFA_RawData>(),
+  MBId_POT(MB_number),
+  MrodId_POT(Mrod_number),
+  EventCount_POT(0),
+  POT_DATA(),
+  patternId(),
+  scalerId(0),
+  ADC1Id(0),
+  ADC2Id(0),
+  TrigSyncErrId(0)
+{ }
+
+
+
+void ALFA_RawDataCollection::SetMBId_POT(uint16_t MB_number)
+{
+  MBId_POT=MB_number;
+}  
+  
+  
+void ALFA_RawDataCollection::SetMrodId_POT(uint16_t Mrod_number)
+{
+  MrodId_POT=Mrod_number;
+}  
+
+
+void ALFA_RawDataCollection::SetEventCount_POT(uint32_t Event_number)
+{
+  EventCount_POT=Event_number;
+}
+
+void ALFA_RawDataCollection::Set_pattern_POT(std::vector<bool> pattern_number)
+{
+  patternId=pattern_number;
+}
+
+void ALFA_RawDataCollection::Set_scaler_POT(uint16_t scaler_number)
+{
+  scalerId=scaler_number;
+}
+
+void ALFA_RawDataCollection::Set_ADC1_POT(uint16_t ADC1_number)
+{
+  ADC1Id=ADC1_number;
+}
+
+void ALFA_RawDataCollection::Set_ADC2_POT(uint16_t ADC2_number)
+{
+  ADC2Id=ADC2_number;
+}
+
+void ALFA_RawDataCollection::SetTrigSyncErr(bool bit)
+{
+  TrigSyncErrId=bit;
+}
+
+void ALFA_RawDataCollection::PushBack_POT(ALFA_RawData PMF_HIT)
+{
+  POT_DATA.push_back(PMF_HIT);
+}  
+
+
+void ALFA_RawDataCollection::SetZero_POT()
+{
+
+  MBId_POT = 0;    // MB number
+   
+  MrodId_POT = 0;    // Mrodnumber
+
+  EventCount_POT=0; 
+
+  patternId.clear(); 
+  scalerId=0; 
+  ADC1Id=0; 
+  ADC2Id=0;
+  TrigSyncErrId=false;
+
+  POT_DATA.clear();
+}
+