diff --git a/ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawData.h b/ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawData.h
index 393c2106ad10831e4d9735b7f452a7b08dc20f09..38cd98d90ee01b9ee7a8c9c26b3bfc2733ff7d16 100644
--- a/ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawData.h
+++ b/ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawData.h
@@ -35,7 +35,7 @@ class ALFA_RawData
   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 SetMarocChan_PMF(const std::vector<uint16_t>& MarocChan);
   void PushBack_PMF(uint16_t fiber_hit);
   void Set_error_bit17(bool bit);
 
@@ -47,33 +47,33 @@ class ALFA_RawData
     
   // 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;};
+  uint16_t GetWordId_PMF() const {return m_WordId;};
+  uint16_t GetPMFId_PMF() const {return m_PMFId;};
+  uint16_t GetMBId_PMF() const {return m_MBId;};
+  uint32_t GetEventCount_PMF() const {return m_EventCount;};
+  const std::vector<uint16_t>& GetMarocHit() const {return m_MarocChan;};
+  uint32_t Get_Chan(uint16_t Numchan) const {return m_MarocChan[Numchan];}; // used in SaraPkg
+  uint32_t GetSize() const {return m_MarocChan.size();};
+  uint16_t Get_bit26_27() const {return m_bit26_27;};
+  uint16_t Get_bit24_27() const  {return m_bit24_27;};	
+  bool Get_bit16() const {return m_bit16;};
+  bool Get_bit18() const {return m_bit18;};
+  bool Get_error_bit17() const {return m_error_bit17;};
 
   // Vector containing all 16 bits data words (undecoded) 
-  std::vector<uint16_t> HitChan() const {return MarocChan;}
+  const std::vector<uint16_t>& HitChan() const {return m_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;}
+  const std::vector<uint32_t>* dataWords() const {return &m_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
+  uint16_t m_WordId;
+  uint16_t m_PMFId;  
+  uint16_t m_MBId; 
+  uint32_t m_EventCount;
+  std::vector<uint16_t> m_MarocChan; // sostituisce il p_hit di prima
   bool     m_bit16;
   bool     m_bit18;
   bool     m_error_bit17;
@@ -82,7 +82,7 @@ class ALFA_RawData
 
   // 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;
+  std::vector<uint32_t> m_dataWords;
 
 };
 #endif // ALFA_RAWDATA_H
diff --git a/ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawDataCollection.h b/ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawDataCollection.h
index 7ccbeb85274111747b05fc887adc8b87ad47102e..84d084981e5bacdac93349caa26ce6db8fc64238 100644
--- a/ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawDataCollection.h
+++ b/ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawDataCollection.h
@@ -22,24 +22,24 @@ class ALFA_RawDataCollection : public DataVector<ALFA_RawData>
  private:
  
   //Motherboard id
-  uint16_t MBId_POT;
+  uint16_t m_MBId_POT;
   //Mrod id
-  uint16_t MrodId_POT;
+  uint16_t m_MrodId_POT;
   //Event counter
-  uint32_t EventCount_POT;
+  uint32_t m_EventCount_POT;
   //Hit store for one PMF
-  std::vector<ALFA_RawData> POT_DATA;
+  std::vector<ALFA_RawData> m_POT_DATA;
 
   //pattern id
-  std::vector<bool> patternId;
+  std::vector<bool> m_patternId;
   //scaler id
-  uint16_t scalerId;
+  uint16_t m_scalerId;
   //ADC1 id Chan0
-  uint16_t ADC1Id;
+  uint16_t m_ADC1Id;
   //ADC1 id Chan1
-  uint16_t ADC2Id;
+  uint16_t m_ADC2Id;
   //syncronization error of PMF 24 (trigger info)
-  bool TrigSyncErrId;
+  bool m_TrigSyncErrId;
 
  public:
   //typedef 
@@ -63,9 +63,9 @@ class ALFA_RawDataCollection : public DataVector<ALFA_RawData>
   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 PushBack_POT(const ALFA_RawData& PMF_HIT);
   
-  void Set_pattern_POT(std::vector<bool> pattern_number);
+  void Set_pattern_POT(const 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);
@@ -78,17 +78,17 @@ class ALFA_RawDataCollection : public DataVector<ALFA_RawData>
   // Methods to access the decoded information
  
 
-  uint16_t GetMBId_POT() const {return MBId_POT;};
-  uint16_t GetMrodId_POT() const {return MrodId_POT;};
-  uint32_t GetEventCount_POT()  const {return EventCount_POT;};
-  std::vector<bool> Get_pattern_POT()  const {return patternId;};
-  uint16_t Get_scaler_POT()  const {return scalerId;};
-  uint16_t Get_ADC1_POT()  const {return ADC1Id;};
-  uint16_t Get_ADC2_POT()  const {return ADC2Id;};
-  bool GetTrigSyncErr()  const {return TrigSyncErrId;};
-
-  std::vector<ALFA_RawData> Get_POT_DATA()  const {return POT_DATA;};
-  ALFA_RawData Get_POT_PMF_DATA(uint32_t Numpmf)  const {return POT_DATA[Numpmf];};
+  uint16_t GetMBId_POT() const {return m_MBId_POT;};
+  uint16_t GetMrodId_POT() const {return m_MrodId_POT;};
+  uint32_t GetEventCount_POT()  const {return m_EventCount_POT;};
+  const std::vector<bool>& Get_pattern_POT()  const {return m_patternId;};
+  uint16_t Get_scaler_POT()  const {return m_scalerId;};
+  uint16_t Get_ADC1_POT()  const {return m_ADC1Id;};
+  uint16_t Get_ADC2_POT()  const {return m_ADC2Id;};
+  bool GetTrigSyncErr()  const {return m_TrigSyncErrId;};
+
+  const std::vector<ALFA_RawData>& Get_POT_DATA()  const {return m_POT_DATA;};
+  ALFA_RawData Get_POT_PMF_DATA(uint32_t Numpmf)  const {return m_POT_DATA[Numpmf];};
 
 
 };
diff --git a/ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawDataCollection_charge.h b/ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawDataCollection_charge.h
index fa94db5bd042310770e773c86a6040d3f3ac3c11..32f8e957841de4a43945e231bc7fb8c3f52a3a43 100644
--- a/ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawDataCollection_charge.h
+++ b/ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawDataCollection_charge.h
@@ -22,17 +22,17 @@ class ALFA_RawDataCollection_charge : public DataVector<ALFA_RawData_charge>
  private:
  
   //Motherboard id
-  uint16_t MBId_POT;
+  uint16_t m_MBId_POT;
   //Mrod id
-  uint16_t MrodId_POT;
+  uint16_t m_MrodId_POT;
   //Event counter
-  uint32_t EventCount_POT;
+  uint32_t m_EventCount_POT;
   //Hit store for one PMF
-  std::vector<ALFA_RawData_charge> POT_DATA;
+  std::vector<ALFA_RawData_charge> m_POT_DATA;
   //Time Stamp
-  uint32_t TimeStamp_POT;
+  uint32_t m_TimeStamp_POT;
   //Bunch Crossing ID
-  uint32_t BCId_POT;
+  uint32_t m_BCId_POT;
 
  public:
   //typedef 
@@ -56,7 +56,7 @@ class ALFA_RawDataCollection_charge : public DataVector<ALFA_RawData_charge>
   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 PushBack_POT(const ALFA_RawData_charge& PMF_HIT);
   
   void SetTimeStamp_POT(uint32_t TimeStamp);
   void SetBCId_POT(uint32_t BCId);
@@ -65,15 +65,15 @@ class ALFA_RawDataCollection_charge : public DataVector<ALFA_RawData_charge>
   
   // 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;};
+  uint16_t GetMBId_POT() const {return m_MBId_POT;};
+  uint16_t GetMrodId_POT() const {return m_MrodId_POT;};
+  uint32_t GetEventCount_POT() const {return m_EventCount_POT;};
  
-  uint32_t GetTimeStamp_POT() {return TimeStamp_POT;};	
-  uint32_t GetBCId_POT() {return BCId_POT;};	
+  uint32_t GetTimeStamp_POT() const {return m_TimeStamp_POT;};	
+  uint32_t GetBCId_POT() const {return m_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];};
+  const std::vector<ALFA_RawData_charge> Get_POT_DATA() const {return m_POT_DATA;};
+  ALFA_RawData_charge Get_POT_PMF_DATA(uint32_t Numpmf) const {return m_POT_DATA[Numpmf];};
 
 
 };
diff --git a/ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawDataContainer.h b/ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawDataContainer.h
index 0f8d2820ce541f5c106861d9339ded81fe510da5..bbecdc62ce164fab749f38f082560085f3159af1 100644
--- a/ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawDataContainer.h
+++ b/ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawDataContainer.h
@@ -45,29 +45,29 @@ class ALFA_RawDataContainer : public DataVector<ALFA_RawDataCollection> {
   // Data words in the ROD header
   
   // Full Event marker
-  static const uint32_t FullEVmarker = 0xaa1234aa;
+  static const uint32_t s_FullEVmarker = 0xaa1234aa;
   // ROB marker
-  static const uint32_t ROBmarker = 0xdd1234dd;
+  static const uint32_t s_ROBmarker = 0xdd1234dd;
   // ROD marker
-  static const uint32_t RODmarker = 0xee1234ee;
+  static const uint32_t s_RODmarker = 0xee1234ee;
 
-  static const uint32_t RODheadersize = 0x00000009; 
-  static const uint32_t RODversion  = 0x03010000;      
+  static const uint32_t s_RODheadersize = 0x00000009; 
+  static const uint32_t s_RODversion  = 0x03010000;      
 
   //Time Stamp
-  uint32_t TimeStamp;
+  uint32_t m_TimeStamp;
   //Time Stamp ns
-  uint32_t TimeStampns;
+  uint32_t m_TimeStampns;
   //Bunch Crossing ID
-  uint32_t BCId;
+  uint32_t m_BCId;
   //LumiBlock ID
-  uint32_t LumiBlock;
+  uint32_t m_LumiBlock;
   //Lvl1 trigger pattern (fired items in lvl1 trigger)
-  std::vector<bool> lvl1Pattern;
+  std::vector<bool> m_lvl1Pattern;
   //Lvl2 trigger pattern (fired items in lvl2 trigger)
-  std::vector<bool> lvl2Pattern;
+  std::vector<bool> m_lvl2Pattern;
   //EF pattern (fired items in EF)
-  std::vector<bool> efPattern;
+  std::vector<bool> m_efPattern;
 
  public:  
 
@@ -78,38 +78,38 @@ class ALFA_RawDataContainer : public DataVector<ALFA_RawDataCollection> {
  
   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;};  	
+  bool is_FullEVmarker() const {return m_wordMarker == s_FullEVmarker;};
+  bool is_ROBmarker() const {return m_wordMarker == s_ROBmarker;};  	
+  bool is_RODmarker() const {return m_wordMarker == s_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;}
+  uint16_t subdetId()  const {return m_subdetId;}
+  uint16_t mrodId()    const {return m_mrodId;}
+  uint32_t runNum()    const {return m_runNum;}
+  uint16_t runType()   const {return m_runType;}
+  uint32_t lvl1Id()    const {return m_lvl1Id;}
+  uint16_t ecrId()     const {return m_ecrId;}
+  uint16_t bcId()      const {return m_bcId;}
+  uint16_t trigtypeId() const {return m_triggerTypeId;}
+  uint32_t DetEventType() const    {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 SetLvl1Pattern(const std::vector<bool>& tmplvl1_pattern);
+  void SetLvl2Pattern(const std::vector<bool>& tmplvl2_pattern);
+  void SetEFPattern(const 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;};	
+  const std::vector<bool>& GetLvl1Pattern_POT() const {return m_lvl1Pattern;};
+  const std::vector<bool>& GetLvl2Pattern_POT() const {return m_lvl2Pattern;};
+  const std::vector<bool>& GetEFPattern_POT() const {return m_efPattern;};
+  uint32_t GetTimeStamp() const {return m_TimeStamp;};	
+  uint32_t GetTimeStampns() const {return m_TimeStampns;};	
+  uint32_t GetLumiBlock() const {return m_LumiBlock;};
+  uint32_t GetBCId() const {return m_BCId;};	
 
  private:
   
diff --git a/ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawDataContainer_charge.h b/ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawDataContainer_charge.h
index 2912a10fc2a43ed414d259671455dd23e06dcec8..6181dcb1b23f9b1828e6e83af032ecc082f45732 100644
--- a/ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawDataContainer_charge.h
+++ b/ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawDataContainer_charge.h
@@ -43,14 +43,14 @@ class ALFA_RawDataContainer_charge : public DataVector<ALFA_RawDataCollection_ch
   // Data words in the ROD header
   
   // Full Event marker
-  static const uint32_t FullEVmarker = 0xaa1234aa;
+  static const uint32_t s_FullEVmarker = 0xaa1234aa;
   // ROB marker
-  static const uint32_t ROBmarker = 0xdd1234dd;
+  static const uint32_t s_ROBmarker = 0xdd1234dd;
   // ROD marker
-  static const uint32_t RODmarker = 0xee1234ee;
+  static const uint32_t s_RODmarker = 0xee1234ee;
 
-  static const uint32_t RODheadersize = 0x00000009; 
-  static const uint32_t RODversion  = 0x03010000;      
+  static const uint32_t s_RODheadersize = 0x00000009; 
+  static const uint32_t s_RODversion  = 0x03010000;      
 
  public:  
 
@@ -61,20 +61,20 @@ class ALFA_RawDataContainer_charge : public DataVector<ALFA_RawDataCollection_ch
  
   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;};  	
+  bool is_FullEVmarker() const {return m_wordMarker == s_FullEVmarker;};
+  bool is_ROBmarker()    const {return m_wordMarker == s_ROBmarker;};  	
+  bool is_RODmarker()    const {return m_wordMarker == s_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;}
+  uint16_t subdetId()   const {return m_subdetId;}
+  uint16_t mrodId()     const {return m_mrodId;}
+  uint32_t runNum()     const {return m_runNum;}
+  uint16_t runType()    const {return m_runType;}
+  uint32_t lvl1Id()     const {return m_lvl1Id;}
+  uint16_t ecrId()      const {return m_ecrId;}
+  uint16_t bcId()       const {return m_bcId;}
+  uint16_t trigtypeId() const {return m_triggerTypeId;}
+  uint32_t DetEventType() const {return m_DetEventType;}
   
  private:
   
diff --git a/ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawData_charge.h b/ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawData_charge.h
index 62f04c20dea759d52304ca8bc784483f392f12d6..63a85aee5f171eb03a286e2eebfa6623c7767805 100644
--- a/ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawData_charge.h
+++ b/ForwardDetectors/ALFA/ALFA_RawEv/ALFA_RawEv/ALFA_RawData_charge.h
@@ -38,7 +38,7 @@ class ALFA_RawData_charge
   void SetEventCount_PMF(uint32_t Event_number);
   void SetChargeChan_PMF(uint16_t ChargeChan_number);
 
-  void SetChargeChanVect_PMF(std::vector<uint16_t> ChargeChan);
+  void SetChargeChanVect_PMF(const std::vector<uint16_t>& ChargeChan);
   void PushBack_PMF(uint16_t ChargeChan_number);
 
   void SetZero_PMF();
@@ -48,39 +48,39 @@ class ALFA_RawData_charge
   
   // 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;};
+  uint16_t GetPMFId_PMF() const {return m_PMFId;};
+  uint16_t GetChannelNum_PMF() const {return m_ChannelNumId;};
+  uint16_t GetMBId_PMF() const {return m_MBId;};
+  uint16_t GetFiberFirmware_PMF() const {return m_FiberFirmwareId;};
+  uint32_t GetEventCount_PMF() const {return m_EventCount;};
+  uint16_t GetChargeHit() const {return m_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;};
+  bool Get_bit12() const {return m_bit12;};
 
   // Vector containing all 16 bits data words (undecoded)
-  std::vector<uint16_t> ChargeChanVect_number() const {return ChargeChan;}
+  const std::vector<uint16_t>& ChargeChanVect_number() const {return m_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;}
+  const std::vector<uint32_t>* dataWords() const {return &m_dataWords;}
 
  private:
 
   // Data info TSM: 
-  uint16_t ChannelNumId;
-  uint16_t PMFId;  
-  uint16_t MBId; 
-  uint16_t  FiberFirmwareId; 
-  uint32_t EventCount;
-  uint16_t ChargeChanId; 
+  uint16_t m_ChannelNumId;
+  uint16_t m_PMFId;  
+  uint16_t m_MBId; 
+  uint16_t m_FiberFirmwareId; 
+  uint32_t m_EventCount;
+  uint16_t m_ChargeChanId; 
   bool     m_bit12;
-  std::vector<uint16_t> ChargeChan; 
+  std::vector<uint16_t> m_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;
+  std::vector<uint32_t> m_dataWords;
 
 };
 #endif // ALFA_RAWDATA_CHARGE_H
diff --git a/ForwardDetectors/ALFA/ALFA_RawEv/CMakeLists.txt b/ForwardDetectors/ALFA/ALFA_RawEv/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3ea275c543de39ac9cb52fc399dc816c49699feb
--- /dev/null
+++ b/ForwardDetectors/ALFA/ALFA_RawEv/CMakeLists.txt
@@ -0,0 +1,35 @@
+################################################################################
+# Package: ALFA_RawEv
+################################################################################
+
+# Declare the package name:
+atlas_subdir( ALFA_RawEv )
+
+# Declare the package's dependencies:
+atlas_depends_on_subdirs( PUBLIC
+                          Control/CLIDSvc
+                          Control/DataModel
+                          Control/SGTools
+                          Simulation/HitManagement
+                          PRIVATE
+                          Control/StoreGate
+                          Event/EventContainers
+                          GaudiKernel )
+
+# External dependencies:
+find_package( ROOT COMPONENTS Core Tree MathCore Hist RIO pthread )
+
+# Component(s) in the package:
+atlas_add_library( ALFA_RawEv
+                   src/*.cxx
+                   PUBLIC_HEADERS ALFA_RawEv
+                   INCLUDE_DIRS ${ROOT_INCLUDE_DIRS}
+                   LINK_LIBRARIES ${ROOT_LIBRARIES} DataModel SGTools HitManagement StoreGateLib SGtests
+                   PRIVATE_LINK_LIBRARIES GaudiKernel )
+
+atlas_add_dictionary( ALFA_RawEvDict
+                      ALFA_RawEv/ALFA_RawEvDict.h
+                      ALFA_RawEv/selection.xml
+                      INCLUDE_DIRS ${ROOT_INCLUDE_DIRS}
+                      LINK_LIBRARIES ${ROOT_LIBRARIES} DataModel SGTools HitManagement StoreGateLib SGtests GaudiKernel ALFA_RawEv )
+
diff --git a/ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_RawData.cxx b/ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_RawData.cxx
index 37b86e4afebceb9f6923efa7458907916f93ad9f..89db4cc494c2923d8d164955b83fe8e0ce84239a 100644
--- a/ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_RawData.cxx
+++ b/ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_RawData.cxx
@@ -6,33 +6,31 @@
 #include "GaudiKernel/MsgStream.h"
 
 ALFA_RawData::ALFA_RawData():
-  WordId(0),
-  PMFId(0),  
-  MBId(0), 
-  EventCount(0),
-  MarocChan(),
+  m_WordId(0),
+  m_PMFId(0),  
+  m_MBId(0), 
+  m_EventCount(0),
+  m_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_WordId(0),
+  m_PMFId(PMFId),  
+  m_MBId(0), 
+  m_EventCount(0),
+  m_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>();
 }
 
 ////////////////////////
@@ -40,45 +38,44 @@ ALFA_RawData::ALFA_RawData(uint16_t PMFId):
 ////////////////////////
 ALFA_RawData::~ALFA_RawData()
 {
-  if (p_dataWords) delete p_dataWords;
 }
 
 
 void ALFA_RawData::SetWordId_PMF(uint16_t Word_number)
 {
-  WordId=Word_number;
+  m_WordId=Word_number;
 }
 
 void ALFA_RawData::SetPMFId_PMF(uint16_t PMF_number)
 {
-  PMFId=PMF_number;
+  m_PMFId=PMF_number;
 }
 
 void ALFA_RawData::SetMBId_PMF(uint16_t MB_number)
 {
-  MBId=MB_number;
+  m_MBId=MB_number;
 }
 
 void ALFA_RawData::SetEventCount_PMF(uint32_t Event_number)
 {
-  EventCount=Event_number;
+  m_EventCount=Event_number;
 }
 
 
-void ALFA_RawData::SetMarocChan_PMF(std::vector<uint16_t> HitChan)
+void ALFA_RawData::SetMarocChan_PMF(const std::vector<uint16_t>& HitChan)
 {
-  MarocChan=HitChan;
+  m_MarocChan=HitChan;
 
 
 }
 
 void ALFA_RawData::PushBack_PMF(uint16_t fiber_hit){
-  MarocChan.push_back(fiber_hit);
+  m_MarocChan.push_back(fiber_hit);
 }
 
 void ALFA_RawData::addData(uint32_t dataWord) 
 {
-  p_dataWords->push_back(dataWord);
+  m_dataWords.push_back(dataWord);
 }
 
 void ALFA_RawData::Set_error_bit17(bool bit)
@@ -89,17 +86,17 @@ void ALFA_RawData::Set_error_bit17(bool bit)
 
 void ALFA_RawData::SetZero_PMF() 
 {
-  WordId=0;
-  PMFId=0; 
-  MBId=0;
-  EventCount=0; 
+  m_WordId=0;
+  m_PMFId=0; 
+  m_MBId=0;
+  m_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();
+  m_MarocChan.clear();
+  m_dataWords.clear();
 }
 
 
diff --git a/ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_RawDataCollection.cxx b/ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_RawDataCollection.cxx
index 1928071bdc79ac71169a50c91254f7257ced1446..6cdb4868345a57ca949a077e1795810db039a043 100644
--- a/ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_RawDataCollection.cxx
+++ b/ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_RawDataCollection.cxx
@@ -8,110 +8,110 @@
 // 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)
+  m_MBId_POT(0),
+  m_MrodId_POT(0),
+  m_EventCount_POT(0),
+  m_POT_DATA(),
+  m_patternId(),
+  m_scalerId(0),
+  m_ADC1Id(0),
+  m_ADC2Id(0),
+  m_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)
+  m_MBId_POT(MB_number),
+  m_MrodId_POT(0),
+  m_EventCount_POT(0),
+  m_POT_DATA(),
+  m_patternId(),
+  m_scalerId(0),
+  m_ADC1Id(0),
+  m_ADC2Id(0),
+  m_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)
+  m_MBId_POT(MB_number),
+  m_MrodId_POT(Mrod_number),
+  m_EventCount_POT(0),
+  m_POT_DATA(),
+  m_patternId(),
+  m_scalerId(0),
+  m_ADC1Id(0),
+  m_ADC2Id(0),
+  m_TrigSyncErrId(0)
 { }
 
 
 
 void ALFA_RawDataCollection::SetMBId_POT(uint16_t MB_number)
 {
-  MBId_POT=MB_number;
+  m_MBId_POT=MB_number;
 }  
   
   
 void ALFA_RawDataCollection::SetMrodId_POT(uint16_t Mrod_number)
 {
-  MrodId_POT=Mrod_number;
+  m_MrodId_POT=Mrod_number;
 }  
 
 
 void ALFA_RawDataCollection::SetEventCount_POT(uint32_t Event_number)
 {
-  EventCount_POT=Event_number;
+  m_EventCount_POT=Event_number;
 }
 
-void ALFA_RawDataCollection::Set_pattern_POT(std::vector<bool> pattern_number)
+void ALFA_RawDataCollection::Set_pattern_POT(const std::vector<bool>& pattern_number)
 {
-  patternId=pattern_number;
+  m_patternId=pattern_number;
 }
 
 void ALFA_RawDataCollection::Set_scaler_POT(uint16_t scaler_number)
 {
-  scalerId=scaler_number;
+  m_scalerId=scaler_number;
 }
 
 void ALFA_RawDataCollection::Set_ADC1_POT(uint16_t ADC1_number)
 {
-  ADC1Id=ADC1_number;
+  m_ADC1Id=ADC1_number;
 }
 
 void ALFA_RawDataCollection::Set_ADC2_POT(uint16_t ADC2_number)
 {
-  ADC2Id=ADC2_number;
+  m_ADC2Id=ADC2_number;
 }
 
 void ALFA_RawDataCollection::SetTrigSyncErr(bool bit)
 {
-  TrigSyncErrId=bit;
+  m_TrigSyncErrId=bit;
 }
 
-void ALFA_RawDataCollection::PushBack_POT(ALFA_RawData PMF_HIT)
+void ALFA_RawDataCollection::PushBack_POT(const ALFA_RawData& PMF_HIT)
 {
-  POT_DATA.push_back(PMF_HIT);
+  m_POT_DATA.push_back(PMF_HIT);
 }  
 
 
 void ALFA_RawDataCollection::SetZero_POT()
 {
 
-  MBId_POT = 0;    // MB number
+  m_MBId_POT = 0;    // MB number
    
-  MrodId_POT = 0;    // Mrodnumber
+  m_MrodId_POT = 0;    // Mrodnumber
 
-  EventCount_POT=0; 
+  m_EventCount_POT=0; 
 
-  patternId.clear(); 
-  scalerId=0; 
-  ADC1Id=0; 
-  ADC2Id=0;
-  TrigSyncErrId=false;
+  m_patternId.clear(); 
+  m_scalerId=0; 
+  m_ADC1Id=0; 
+  m_ADC2Id=0;
+  m_TrigSyncErrId=false;
 
-  POT_DATA.clear();
+  m_POT_DATA.clear();
 }
 
diff --git a/ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_RawDataCollection_charge.cxx b/ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_RawDataCollection_charge.cxx
index 848ba068df63f262d75f196771f349447ac89fc6..4ddc91dc67a9a62de5cbf039e2138d86f42a7b38 100644
--- a/ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_RawDataCollection_charge.cxx
+++ b/ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_RawDataCollection_charge.cxx
@@ -8,82 +8,82 @@
 // Default constructor
 ALFA_RawDataCollection_charge::ALFA_RawDataCollection_charge() :
   DataVector<ALFA_RawData_charge>(),
-  MBId_POT(0),
-  MrodId_POT(0),
-  EventCount_POT(0),
-  POT_DATA(),
-  TimeStamp_POT(0),
-  BCId_POT(0)
+  m_MBId_POT(0),
+  m_MrodId_POT(0),
+  m_EventCount_POT(0),
+  m_POT_DATA(),
+  m_TimeStamp_POT(0),
+  m_BCId_POT(0)
 { }
 
 // Full constructor
 ALFA_RawDataCollection_charge::ALFA_RawDataCollection_charge(uint16_t MB_number) :
   DataVector<ALFA_RawData_charge>(),
-  MBId_POT(MB_number),
-  MrodId_POT(0),
-  EventCount_POT(0),
-  POT_DATA(),
-  TimeStamp_POT(0),
-  BCId_POT(0)
+  m_MBId_POT(MB_number),
+  m_MrodId_POT(0),
+  m_EventCount_POT(0),
+  m_POT_DATA(),
+  m_TimeStamp_POT(0),
+  m_BCId_POT(0)
 { }
 
 // Full constructor
 ALFA_RawDataCollection_charge::ALFA_RawDataCollection_charge( uint16_t Mrod_number, uint16_t MB_number) :
   DataVector<ALFA_RawData_charge>(),
-  MBId_POT(MB_number),
-  MrodId_POT(Mrod_number),
-  EventCount_POT(0),
-  POT_DATA(),
-  TimeStamp_POT(0),
-  BCId_POT(0)
+  m_MBId_POT(MB_number),
+  m_MrodId_POT(Mrod_number),
+  m_EventCount_POT(0),
+  m_POT_DATA(),
+  m_TimeStamp_POT(0),
+  m_BCId_POT(0)
 { }
 
 
 
 void ALFA_RawDataCollection_charge::SetMBId_POT(uint16_t MB_number)
 {
-  MBId_POT=MB_number;
+  m_MBId_POT=MB_number;
 }  
   
   
 void ALFA_RawDataCollection_charge::SetMrodId_POT(uint16_t Mrod_number)
 {
-  MrodId_POT=Mrod_number;
+  m_MrodId_POT=Mrod_number;
   }  
 
 
 void ALFA_RawDataCollection_charge::SetEventCount_POT(uint32_t Event_number)
 {
-  EventCount_POT=Event_number;
+  m_EventCount_POT=Event_number;
 }
 
 void ALFA_RawDataCollection_charge::SetTimeStamp_POT(uint32_t TimeStamp)
 {
-  TimeStamp_POT=TimeStamp;
+  m_TimeStamp_POT=TimeStamp;
 }
 
 void ALFA_RawDataCollection_charge::SetBCId_POT(uint32_t BCId)
 {
-  BCId_POT=BCId;
+  m_BCId_POT=BCId;
 }
 
-void ALFA_RawDataCollection_charge::PushBack_POT(ALFA_RawData_charge PMF_HIT)
+void ALFA_RawDataCollection_charge::PushBack_POT(const ALFA_RawData_charge& PMF_HIT)
 {
-  POT_DATA.push_back(PMF_HIT);
+  m_POT_DATA.push_back(PMF_HIT);
 }  
 
 
 void ALFA_RawDataCollection_charge::SetZero_POT()
 {
 
-  MBId_POT = 0;    // MB number
+  m_MBId_POT = 0;    // MB number
    
-  MrodId_POT = 0;    // Mrodnumber
+  m_MrodId_POT = 0;    // Mrodnumber
 
-  EventCount_POT=0; 
-  TimeStamp_POT=0; 
-  BCId_POT=0;
+  m_EventCount_POT=0; 
+  m_TimeStamp_POT=0; 
+  m_BCId_POT=0;
 
-  POT_DATA.clear();
+  m_POT_DATA.clear();
 }
 
diff --git a/ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_RawDataContainer.cxx b/ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_RawDataContainer.cxx
index 857b666596683feef7a9999d5860f4fb5f358493..028feeb59c0aded080ef6a54a53d9f4362cc8f27 100644
--- a/ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_RawDataContainer.cxx
+++ b/ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_RawDataContainer.cxx
@@ -41,11 +41,11 @@ ALFA_RawDataContainer::ALFA_RawDataContainer():
   m_runType(0),
   m_triggerTypeId(0),
   m_DetEventType(0),
-  TimeStamp(0),
-  TimeStampns(0),
-  BCId(0),
-  LumiBlock(0),
-  lvl1Pattern()
+  m_TimeStamp(0),
+  m_TimeStampns(0),
+  m_BCId(0),
+  m_LumiBlock(0),
+  m_lvl1Pattern()
 {
 }
 
@@ -77,37 +77,37 @@ ALFA_RawDataContainer::size_type ALFA_RawDataContainer::digit_size() const {
 
 void ALFA_RawDataContainer::SetTimeStamp(uint32_t tmpTimeStamp)
 {
-  TimeStamp=tmpTimeStamp;
+  m_TimeStamp=tmpTimeStamp;
 }
 
 void ALFA_RawDataContainer::SetTimeStampns(uint32_t tmpTimeStampns)
 {
-  TimeStampns=tmpTimeStampns;
+  m_TimeStampns=tmpTimeStampns;
 }
 
 void ALFA_RawDataContainer::SetLumiBlock(uint32_t tmpLumiBlock)
 {
-  LumiBlock=tmpLumiBlock;
+  m_LumiBlock=tmpLumiBlock;
 }
 
 void ALFA_RawDataContainer::SetBCId(uint32_t tmpBCId)
 {
-  BCId=tmpBCId;
+  m_BCId=tmpBCId;
 }
 
-void ALFA_RawDataContainer::SetLvl1Pattern(std::vector<bool> tmplvl1_pattern)
+void ALFA_RawDataContainer::SetLvl1Pattern(const std::vector<bool>& tmplvl1_pattern)
 {
-  lvl1Pattern = tmplvl1_pattern;
+  m_lvl1Pattern = tmplvl1_pattern;
 }
 
-void ALFA_RawDataContainer::SetLvl2Pattern(std::vector<bool> tmplvl2_pattern)
+void ALFA_RawDataContainer::SetLvl2Pattern(const std::vector<bool>& tmplvl2_pattern)
 {
-  lvl2Pattern = tmplvl2_pattern;
+  m_lvl2Pattern = tmplvl2_pattern;
 }
 
-void ALFA_RawDataContainer::SetEFPattern(std::vector<bool> tmpef_pattern)
+void ALFA_RawDataContainer::SetEFPattern(const std::vector<bool>& tmpef_pattern)
 {
-  efPattern = tmpef_pattern;
+  m_efPattern = tmpef_pattern;
 }
 
 
@@ -124,13 +124,13 @@ void ALFA_RawDataContainer::setZero()
   m_triggerTypeId = 0;
   m_DetEventType = 0;
 
-  TimeStamp=0; 
-  TimeStampns=0;
-  LumiBlock=0;
-  BCId=0;
-  lvl1Pattern.clear();
-  lvl2Pattern.clear();
-  efPattern.clear();
+  m_TimeStamp=0; 
+  m_TimeStampns=0;
+  m_LumiBlock=0;
+  m_BCId=0;
+  m_lvl1Pattern.clear();
+  m_lvl2Pattern.clear();
+  m_efPattern.clear();
 
 }
 
diff --git a/ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_RawData_charge.cxx b/ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_RawData_charge.cxx
index 9ec8eabaf8d6c0300881e938295fdee80f0af356..83a294fbaeeef953c57337ba1bba64fd78aee933 100644
--- a/ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_RawData_charge.cxx
+++ b/ForwardDetectors/ALFA/ALFA_RawEv/src/ALFA_RawData_charge.cxx
@@ -6,29 +6,27 @@
 #include "GaudiKernel/MsgStream.h"
 
 ALFA_RawData_charge::ALFA_RawData_charge():
-  ChannelNumId(0),
-  PMFId(0),
-  MBId(0),
-  FiberFirmwareId(0),
-  EventCount(0),
-  ChargeChanId(0),
+  m_ChannelNumId(0),
+  m_PMFId(0),
+  m_MBId(0),
+  m_FiberFirmwareId(0),
+  m_EventCount(0),
+  m_ChargeChanId(0),
   m_bit12(0),
-  ChargeChan() 
+  m_ChargeChan() 
 {
-  p_dataWords = new std::vector<uint32_t>();
 }
 
 ALFA_RawData_charge::ALFA_RawData_charge(uint16_t PMFId):
-  ChannelNumId(0),
-  PMFId(PMFId),
-  MBId(0),
-  FiberFirmwareId(0),
-  EventCount(0),
-  ChargeChanId(0),
+  m_ChannelNumId(0),
+  m_PMFId(PMFId),
+  m_MBId(0),
+  m_FiberFirmwareId(0),
+  m_EventCount(0),
+  m_ChargeChanId(0),
   m_bit12(0),
-  ChargeChan() 
+  m_ChargeChan() 
 {
-  p_dataWords = new std::vector<uint32_t>();
 }
 
 ////////////////////////
@@ -36,68 +34,67 @@ ALFA_RawData_charge::ALFA_RawData_charge(uint16_t PMFId):
 ////////////////////////
 ALFA_RawData_charge::~ALFA_RawData_charge()
 {
-  if (p_dataWords) delete p_dataWords;
 }
 
 void ALFA_RawData_charge::SetPMFId_PMF(uint16_t PMF_number)
 {
-  PMFId=PMF_number;
+  m_PMFId=PMF_number;
 }
 
 void ALFA_RawData_charge::SetChannelNum_PMF(uint16_t Channel_number)
 {
-  ChannelNumId=Channel_number;
+  m_ChannelNumId=Channel_number;
 }
 
 void ALFA_RawData_charge::SetMBId_PMF(uint16_t MB_number)
 {
-  MBId=MB_number;
+  m_MBId=MB_number;
 }
 
 void ALFA_RawData_charge::SetFiberFirmware_PMF(uint16_t FiberFirmware_number)
 {
-  FiberFirmwareId=FiberFirmware_number;
+  m_FiberFirmwareId=FiberFirmware_number;
 }
 
 void ALFA_RawData_charge::SetEventCount_PMF(uint32_t Event_number)
 {
-  EventCount=Event_number;
+  m_EventCount=Event_number;
 }
 
 
 void ALFA_RawData_charge::SetChargeChan_PMF(uint16_t ChargeChan_number)
 {
-  ChargeChanId=ChargeChan_number;
+  m_ChargeChanId=ChargeChan_number;
 }
 
 
-void ALFA_RawData_charge::SetChargeChanVect_PMF(std::vector<uint16_t> ChargeChanVect_number)
+void ALFA_RawData_charge::SetChargeChanVect_PMF(const std::vector<uint16_t>& ChargeChanVect_number)
 {
-  ChargeChan=ChargeChanVect_number;
+  m_ChargeChan=ChargeChanVect_number;
 }
 
 
 void ALFA_RawData_charge::PushBack_PMF(uint16_t ChargeChan_number){
-  ChargeChan.push_back(ChargeChan_number);
+  m_ChargeChan.push_back(ChargeChan_number);
 }
 
 
 void ALFA_RawData_charge::addData(uint32_t dataWord) 
 {
-  p_dataWords->push_back(dataWord);
+  m_dataWords.push_back(dataWord);
 }
 
 
 void ALFA_RawData_charge::SetZero_PMF() 
 {
-  PMFId=0;
-  ChannelNumId=0;
-  MBId=0;
-  EventCount=0; 
-  FiberFirmwareId=0; 
+  m_PMFId=0;
+  m_ChannelNumId=0;
+  m_MBId=0;
+  m_EventCount=0; 
+  m_FiberFirmwareId=0; 
   m_bit12=false;
-  ChargeChan.clear();
-  p_dataWords->clear();
+  m_ChargeChan.clear();
+  m_dataWords.clear();
 }