/data3/calcul/jacquem/working_dir/Micromegas/micromegasFrameWork/src/root/MTEvent.cpp

Go to the documentation of this file.

/* @version $Revision: 1922 $ * @modifiedby $Author: jacquem $ * @lastmodified $Date: 2012-10-24 15:21:19 +0200 (Wed, 24 Oct 2012) $ */
#include "TDirectory.h"
#include "TProcessID.h"

#include "root/MTEvent.hh"
#include "root/MTChannel.hh"

#include "event/Event.hh"
#include "event/ChannelHit.hh"
#include "event/Run.hh"
#include "geometry/Chamber.hh"
#include "geometry/Chip.hh"
#include "geometry/Board.hh"
#include "geometry/Dif.hh"
#include "geometry/Detector.hh"
#include "tools/MicroException.hh"
#include "tools/Log.hh"


#include <iostream>
#include <sstream>

using namespace std;

ClassImp(MTEvent)

TClonesArray *MTEvent::fgChannels = 0;

/*------------------------------------------------------------------------------
 *
 *    MTEvent implementation
 */
//______________________________________________________________________________
MTEvent::MTEvent() : fTrack(NULL), fEventId(0), fTemperature(0.), fPressure(0), fTimestamp(0), fDifSynchro(0), fTimeInfo(true), fSquareEvt (false ), fBorderEvt (false ), fChipEvt (false ), fCrcIsCorrect(true), fNchannel(0), fValid(VALID)
{
   // Create an MTEvent object.
   // When the constructor is invoked for the first time, the class static
   // variable fgChannels is 0 and the TClonesArray fgChannels is created.

   if (!fgChannels) {
       fgChannels = new TClonesArray("MTChannel", 1000);
   }
   fChannels = fgChannels;
   fNbHitPerAbsTime.clear();
}

//______________________________________________________________________________
MTEvent::~MTEvent()
{
   Clear();
}



//______________________________________________________________________________
MTEvent&  MTEvent::operator=( const  MTEvent& rhs)
{

  // It is not a real copy as Channels are share as static class member
  // So both source and destination MTEvent share the same channels and MTTrack
   fSquareEvt = rhs.fSquareEvt;
   fBorderEvt = rhs.fBorderEvt;
   fChipEvt = rhs.fChipEvt;
   fTimeInfo = rhs.fTimeInfo;
   fEventId = rhs.fEventId;
   fTemperature = rhs.fTemperature;
   fPressure = rhs.fPressure;
   fDifSynchro = rhs.fDifSynchro;
   fTimestamp = rhs.fTimestamp;
   fGlobalTriggerCounter = rhs.fGlobalTriggerCounter;
   fDifTriggerCounter = rhs.fDifTriggerCounter;
   fCrcIsCorrect = rhs.fCrcIsCorrect;
   fValid = rhs.fValid;
   fNchannel = rhs.fNchannel;

   fNbHitPerAbsTime = rhs.fNbHitPerAbsTime;
   fChannels = rhs.fChannels;
   fMeshVoltage = rhs.fMeshVoltage;
   fDriftVoltage = rhs.fDriftVoltage;
   fTrack = rhs.fTrack;
   //static TClonesArray *gChannels; // Do not copy class static member
   fTemperatureAsu1 = rhs.fTemperatureAsu1;
   fTemperatureAsu2 = rhs.fTemperatureAsu2;
   fTemperatureDif = rhs.fTemperatureDif;


  // ATTENTION A BIEN MODIFIER src/analuyse/root/merge.cpp FillEvent()
}

//______________________________________________________________________________
void MTEvent::Build(UInt_t evtId, ULong64_t difSynchro, Double32_t  temperature, Double32_t  pressure , ULong64_t  timestamp )
{
fEventId=evtId;
fTemperature=temperature;
fPressure=pressure;
fTimestamp=timestamp;
fDifSynchro = difSynchro;
}

//______________________________________________________________________________
MTEvent& MTEvent::operator=(const Event& aEvent)  

{
     try
      {
        fCrcIsCorrect = aEvent.getCrcIsCorrect();
        fValid = aEvent.getValidFlag();
        this->Build(aEvent.getId(), aEvent.getDifSynchro(), aEvent.getTemperature(), aEvent.getPressure(), aEvent.getTimeStamp());
        fTrack=NULL;
        fTimeInfo=true;
        fSquareEvt=false;
        fBorderEvt=false;
        fChipEvt=false;

        fTemperatureAsu1 = aEvent.getTemperatureAsu1();
        fTemperatureAsu2 = aEvent.getTemperatureAsu2();
        fTemperatureDif = aEvent.getTemperatureDif();

        ChamberMap_t chamberList = aEvent.getRun().getDetector().getChambers();
        for (ChamberMap_t::iterator iter=chamberList.begin(); iter!=chamberList.end(); iter++)
        {
          Chamber& chamber = *(iter->second);
          BoardMap_t boardList = chamber.getBoards();
          for ( BoardMap_t::iterator boardIter=boardList.begin(); boardIter!=boardList.end(); boardIter++)
          {
            ui32 difId = 0;
            Board& board = *(boardIter->second);
            try
            {
              const Dif* dif = board.getDif();
              if ( dif != NULL ) 
              {  // ! Gassilplex Board
                difId = board.getDif()->getId(); 
              }
              const BoardSlowControl& boardSC =  aEvent.getBoardSlowControl(chamber.getId(),difId,board.getId());
              this->SetDriftVoltage(chamber.getId(),difId,board.getId(),boardSC.getDrift().voltage);
              this->SetMeshVoltage(chamber.getId(),difId,board.getId(),boardSC.getMesh().voltage);
            }
            catch ( MicroException e) 
            {
             FILE_LOG(logDEBUG1) << "---BoardSlowControl not found chamberid[" << chamber.getId() << "] difId[" << difId <<"] boardId[" << board.getId() <<"]" << endl; 
            }
          }


                                        this->SetGlobalTriggerCounter(aEvent.getGlobalTriggerCounter());
                                        this->SetDifTriggerCounter(aEvent.getDifTriggerCounter());
          try
          {
              const  multiset<ChannelHit*,sorter>& list = aEvent.getChannelHitVector(chamber);
              int order = 0 ;
              for (set<ChannelHit*,sorter>::iterator iter=list.begin(); iter!=list.end(); iter++)
              {
                try
                {
                  //const ChannelHit& channelHit = *(*iter);
                  ChannelHit& channelHit = *(*iter);
                  if ( chamber.getType().find("GASSIPLEX")!=string::npos)
                                                                        {
                                                                                                channelHit.setTimestamp(aEvent.getTimeStamp());
                                                                  }


                  MTChannel *ch = this->AddChannel(channelHit, order);
                  //i32 deltaT = ch->GetBcIdDif() - ch->GetBcIdHit();
                  //if ( deltaT < 0 ) cout << "deltaT < 0" << endl;
                  //if ( deltaT == 0 ) cout << "deltaT == 0" << endl;
                  //ui32 time = ch->GetAbsTime();
                  //cout << "----EventId["<< GetId() << "] Dif Id["<< ch->GetSoftId().GetDifId() << "], Chip Id[" << ch->GetSoftId().GetChipId() << "]  deltat " << deltaT << endl;
                  //cout << " ---- Abs time:  " << time  << " EventId["<< GetId() << "] Dif Id["<< ch->GetSoftId().GetDifId() << "], Chip Id[" << ch->GetSoftId().GetChipId() << " Abs time:  " << time << endl; 
                  
    
                  



                  order++;  // because aEvent have already been  sorted
                } // end try block
                catch (MicroException e)
                {
                }
              } // end for channelHits for this chamber
          }
          catch (MicroException e)
          {
                    // get ChamberHitVector for next chamber
          }
        } // end for chamber
      this->GetChannels()->Sort(); // sort by absolute time --> See MTChannels.Compare()
      } //try block
      catch (MicroException e)
      {
          throw MicroException(e.getMessage());
      }
       // Save all objects in this file
      return *this;

}

//------------------------------------------
bool MTEvent::IsSquare(UInt_t nbPad, UInt_t &asu, UInt_t &abs_time, UInt_t chb) 
//input : nbPad = threshold where we consider an event "Square"; chb = chamber ID.
//outputs: asu = the asu where the event is square; abs_time = the abs_time when the event is square.
{
  //square boolean identifier
  bool square = false;
  //set reference values
  asu = -1;
  abs_time = -1;
  
  //declare the hits counter map
  map<unsigned int,map<unsigned int,int> > channels_map;// key1=asu (board_id), key2=hit_time      
  
  //loop on all the channels of the event
  UInt_t nchannel = this->GetNchannel();
  for (int j=0;j<nchannel;j++){
    
    //this channel
    MTChannel* channel = (MTChannel*)this->GetChannels()->UncheckedAt(j);

    if (channel->GetChamberId()==chb)
      { 
        //at each channel get board_id and hit_time
        UInt_t hit_time =  channel->GetBcIdAbs() - (channel->GetBcIdDif() - channel->GetBcIdHit() );
        UInt_t board_id = channel->GetBoardId();
    
        //upgrade the hits counter of the good board at the good time:
        // if this asu doesn't exist yet
        if ( channels_map.find(board_id) == channels_map.end()) { 
          //create it in the map and fill it
          map<unsigned int, int> nbHitMap;
          nbHitMap[hit_time]=1;
          channels_map.insert(make_pair(board_id,nbHitMap));
        }
        // if this asu already exist 
        else{ 
          //find it
          map<unsigned int, int> &nbHitMap =  channels_map.find(board_id)->second;
          //if this hit_time doesn't exist yet
          if (nbHitMap.find(hit_time) == nbHitMap.end()){ 
            //add id
            nbHitMap.insert(make_pair(hit_time,1)); 
          }
          //if this abs time already exist
          else{ 
            //fill it
            nbHitMap[hit_time] = nbHitMap[hit_time]++;
          }
        }  
      }      
  }
  
  //Loop on each board, at each time, to identify if this event is square
  map<unsigned int, map<unsigned int,int> >::iterator iter1;
  for(iter1=channels_map.begin();iter1!=channels_map.end();iter1++){
    
    unsigned int azu=iter1->first;
    map<unsigned int,int> hits_per_time=iter1->second;
    
    map<unsigned int,int>::iterator iter2;
    for(iter2=hits_per_time.begin();iter2!=hits_per_time.end();iter2++){
      
      unsigned int time = iter2->first;
      int nb_hits = iter2->second;
      
      //if this is a square event
      if (nb_hits>=nbPad) {
        square=true;
        asu = azu;
        abs_time = time;
      }
    }
  }
  return square;      
}

//------------------------------------------
bool MTEvent::IsBorder(UInt_t nbPad, UInt_t &asu, UInt_t &abs_time, UInt_t chb) 
//input : nbPad = threshold where we consider an event "Border"; chb = chamber ID.
//outputs: asu = the asu where the event is border; abs_time = the abs_time when the event is border.
{
  //border boolean identifier
  bool border = false;
  //set reference values
  asu = -1;
  abs_time = -1;
  
  //an event can be border only if it is not square (square threshold set to 450 hits)
  UInt_t A;
  UInt_t T;
  if(this->IsSquare(450,A,T,chb)==0) {
    //declare the hits counter map
    map<unsigned int,map<unsigned long,unsigned int> > channels_map;// key1=asu (board_id), key2=hit_time      
    
    //loop on all the channels of the event
    UInt_t nchannel = this->GetNchannel();
    for (unsigned int j=0;j<nchannel;j++){
      
      //this channel
      MTChannel* channel = (MTChannel*)this->GetChannels()->UncheckedAt(j);
      
      if (channel->GetChamberId()==chb)
        { 
          //at each channel get board_id and hit_time
          ULong_t hit_time =  channel->GetBcIdAbs() - (channel->GetBcIdDif() - channel->GetBcIdHit() );
          UInt_t board_id = channel->GetBoardId();
          
          //get the position of this hit/channel
          //Int_t xpos = channel->GetX()/1000;
          //Int_t ypos = channel->GetY()/1000;
          
          //if the hit is not on the borders of an asu go to next hit
          if (channel->GetX() != 0000 && channel->GetX() != 310000 && channel->GetX() != 320000 && channel->GetX() != 640000 && channel->GetX() != 650000 && channel->GetX() != 960000 && channel->GetY() != 000000 && channel->GetY() != 470000 && channel->GetY() != 480000 && channel->GetY() != 960000) continue;
          
          //upgrade the hits counter of the good board at the good time
          if (channels_map.find(board_id) == channels_map.end()) { // if this asu doesn't exist yet
            
            map<unsigned long, unsigned int> nbHitMap;
          nbHitMap[hit_time]=1;
          channels_map.insert(make_pair(board_id,nbHitMap));
          }
          else{ // if this asu already exist 
            
            map<unsigned long, unsigned int> &nbHitMap =  channels_map.find(board_id)->second;
            if (nbHitMap.find(hit_time) == nbHitMap.end()){ //if this hit_time doesn't exist yet
              
              nbHitMap.insert(make_pair(hit_time,1)); 
            }
            else{ //if this abs time already exist
              
              nbHitMap[hit_time] = nbHitMap[hit_time]++;
            }
          }  
        }      
      
      //Loop on each board, at each time, to identify if this event is border
      map<unsigned int, map<unsigned long,unsigned int> >::iterator iter1;
      for(iter1=channels_map.begin();iter1!=channels_map.end();iter1++){
        
        unsigned int azu=iter1->first;
        map<unsigned long,unsigned int> hits_per_time=iter1->second;
        
        map<unsigned long,unsigned int>::iterator iter2;
        for(iter2=hits_per_time.begin();iter2!=hits_per_time.end();iter2++){
          
          unsigned long time = iter2->first;
          unsigned int nb_hits = iter2->second;
          
          //if this is a border event
          if (nb_hits>=nbPad) {
            border = true;
            asu = azu;
            abs_time = time;
          }
        }
      }
    }
  }
  return border;      
}
  
//------------------------------------------
bool MTEvent::IsChip(UInt_t nbPad, UInt_t &chip, UInt_t &abs_time, UInt_t chb) 
//input : nbPad = threshold where we consider an event "Chip"; chb = chamber ID.
//outputs: chip = the chip where the event is chip; abs_time = the abs_time when the event is chip.
{
  //chip boolean identifier
  bool me_chip = false;
  //set reference values
  chip = -1;
  abs_time = -1;
  
  //declare the hits counter map
  map<unsigned int,map<unsigned long,unsigned int> > channels_map;// key1=chip (chip_id), key2=hit_time      
  
  //loop on all the channels of the event
  UInt_t nchannel = this->GetNchannel();
  for (unsigned int j=0;j<nchannel;j++){
    
    //this channel
    MTChannel* channel = (MTChannel*)this->GetChannels()->UncheckedAt(j);
    
    if (channel->GetChamberId()==chb)
      { 
        //at each channel get chip_id and hit_time
        ULong_t hit_time =  channel->GetBcIdAbs() - (channel->GetBcIdDif() - channel->GetBcIdHit() );
        UInt_t chip_id = channel->GetChipId();
        
        //get the position of this hit/channel
        //Int_t xpos = channel->GetX()/1000;
        //Int_t ypos = channel->GetY()/1000;
        
        //if the hit is not on the chips of an chip go to next hit
        if (channel->GetX() != 0000 && channel->GetX() != 310000 && channel->GetX() != 320000 && channel->GetX() != 640000 && channel->GetX() != 650000 && channel->GetX() != 960000 && channel->GetY() != 000000 && channel->GetY() != 470000 && channel->GetY() != 480000 && channel->GetY() != 960000) continue;
        
        //upgrade the hits counter of the good chip at the good time
        if (channels_map.find(chip_id) == channels_map.end()) { // if this chip doesn't exist yet
          
          map<unsigned long, unsigned int> nbHitMap;
          nbHitMap[hit_time]=1;
          channels_map.insert(make_pair(chip_id,nbHitMap));
        }
        else{ // if this chip already exist 
          
          map<unsigned long, unsigned int> &nbHitMap =  channels_map.find(chip_id)->second;
          if (nbHitMap.find(hit_time) == nbHitMap.end()){ //if this hit_time doesn't exist yet
            
            nbHitMap.insert(make_pair(hit_time,1)); 
          }
          else{ //if this abs time already exist
            
            nbHitMap[hit_time] = nbHitMap[hit_time]++;
          }
        }  
      }
    
    //Loop on each chip, at each time, to identify if this event is chip
    map<unsigned int, map<unsigned long,unsigned int> >::iterator iter1;
    for(iter1=channels_map.begin();iter1!=channels_map.end();iter1++){
      
      unsigned int chiip=iter1->first;
      map<unsigned long,unsigned int> hits_per_time=iter1->second;
      
      map<unsigned long,unsigned int>::iterator iter2;
      for(iter2=hits_per_time.begin();iter2!=hits_per_time.end();iter2++){
        
        unsigned long time = iter2->first;
        unsigned int nb_hits = iter2->second;
        
        //if this is a chip event
        if (nb_hits>=nbPad) {
          me_chip = true;
          chip = chiip;
          abs_time = time;
        }
      }
    }
  } 
  return me_chip;      
}
  
  //------------------------------------------
Float_t MTEvent::GetMeshVoltage(const Int_t chamberId,Int_t difId, Int_t boardId) const 
{
   if ( fMeshVoltage.find(chamberId) != fMeshVoltage.end())
    {
      map<UInt_t, map<UInt_t, Float_t>* >* difContainer = fMeshVoltage.find(chamberId)->second;
      if (difContainer->find(difId) !=  difContainer->end())
      {
        map<UInt_t , Float_t>* boardContainer = difContainer->find(difId)->second;
        if (boardContainer->find(boardId) !=  boardContainer->end())
        {
            return boardContainer->find(boardId)->second;
        }
        else
        {
          throw MicroException("MTEvent::GetMeshVoltage : no board found");
        }
      }
      else
      {
          throw MicroException("MTEvent::GetMeshVoltage : no board found");
      }
    }
    else
{
}
    {
      throw MicroException("MTEvent::GetMeshVoltage : no board found");
    }

}
//------------------------------------------
Float_t MTEvent::GetDriftVoltage(const Int_t chamberId,Int_t difId, Int_t boardId) const
{
   if ( fDriftVoltage.find(chamberId) != fDriftVoltage.end())
    {
      map<UInt_t, map<UInt_t, Float_t>* >* difContainer = fDriftVoltage.find(chamberId)->second;
      if (difContainer->find(difId) !=  difContainer->end())
      {
        map<UInt_t , Float_t>* boardContainer = difContainer->find(difId)->second;
        if (boardContainer->find(boardId) !=  boardContainer->end())
        {
            return boardContainer->find(boardId)->second;
        }
        else
        {
          throw MicroException("MTEvent::GetDriftVoltage : no board found");
        }
      }
      else
      {
          throw MicroException("MTEvent::GetDriftVoltage : no board found");
      }
    }
    else
    {
      throw MicroException("MTEvent::GetDriftVoltage : no board found");
    }



}
//------------------------------------------
void    MTEvent::SetMeshVoltage(const Int_t chamberId, Int_t difId, Int_t boardId,const Float_t aValue) 
{
  // Search or create difs container for this chamber id
    if ( fMeshVoltage.find(chamberId) != fMeshVoltage.end())
    { // difs list already exit for this chamber
    }
    else
    { // does not exit create it
      map<UInt_t , map<UInt_t, Float_t>* > *difContainer = new map<UInt_t, map<UInt_t, Float_t>* >();
      fMeshVoltage.insert(make_pair(chamberId,difContainer));
    }

    // Now we are sure that container for this chamber Id exist
    map<UInt_t, map<UInt_t, Float_t>* >* difContainer = fMeshVoltage.find(chamberId)->second;


    // Search or create boards container for this Difs
    if ( difContainer->find(difId) != difContainer->end())
    { // board list already exit for this dif
    }
    else
    {
      map<UInt_t, Float_t>* boardContainer = new map<UInt_t, Float_t>();
      difContainer->insert(make_pair(difId,boardContainer));
    }

    // Now we are sure that container for this chamber Id  and DifId exist
    map<ui32, Float_t>* boardContainer = difContainer->find(difId)->second;

    if ( boardContainer->find(boardId) != boardContainer->end())
    {
      (*boardContainer)[boardId] = aValue;
    }
    else
    {
      boardContainer->insert(make_pair(boardId,aValue));
    }
}

//------------------------------------------
void    MTEvent::SetDriftVoltage(const Int_t chamberId, Int_t difId, Int_t boardId,const Float_t aValue)
{
  // Search or create difs container for this chamber id
    if ( fDriftVoltage.find(chamberId) != fDriftVoltage.end())
    { // difs list already exit for this chamber
    }
    else
    { // does not exit create it
      map<UInt_t , map<UInt_t, Float_t>* > *difContainer = new map<UInt_t, map<UInt_t, Float_t>* >();
      fDriftVoltage.insert(make_pair(chamberId,difContainer));
    }

    // Now we are sure that container for this chamber Id exist
    map<UInt_t, map<UInt_t, Float_t>* >* difContainer = fDriftVoltage.find(chamberId)->second;


    // Search or create boards container for this Difs
    if ( difContainer->find(difId) != difContainer->end())
    { // board list already exit for this dif
    }
    else
    {
      map<UInt_t, Float_t>* boardContainer = new map<UInt_t, Float_t>();
      difContainer->insert(make_pair(difId,boardContainer));
    }

    // Now we are sure that container for this chamber Id  and DifId exist
    map<ui32, Float_t>* boardContainer = difContainer->find(difId)->second;
    if ( boardContainer->find(boardId) != boardContainer->end())
    {
      (*boardContainer)[boardId] = aValue;
    }
    else
    {
      boardContainer->insert(make_pair(boardId,aValue));
    }





}


//______________________________________________________________________________
MTChannel* MTEvent::AddChannel(const ChannelHit& hit, UInt_t order) {
//Int_t value, UInt_t softId, UInt_t hardId, Int_t valueX, Int_t valueY, Int_t valueZ, UInt_t order)

   // Add a new fTrack to the list of fTracks for this event.
   // To avoid calling the very time consuming operator new for each fTrack,
   // the standard but not well know C++ operator "new with placement"
   // is called. If fTracks[i] is 0, a new Track object will be created
   // otherwise the previous Track[i] will be overwritten.


   TClonesArray &channels = *fChannels;

   MTChannel *channel = new(channels[fNchannel++]) MTChannel(hit, order);
   UInt_t bcIdHit =  channel->GetBcIdHit();
   if ( bcIdHit != 0 )
   {
     UInt_t boardId = channel->GetSoftId().GetBoardId(); 
     UInt_t absolute_time = channel->GetAbsTime() ;
     this->AddHitForAbsTime(boardId,absolute_time,1);
   }

   return channel;
}
//______________________________________________________________________________
MTChannel* MTEvent::AddChannel(MTChannel* aChannel) {
//Int_t value, UInt_t softId, UInt_t hardId, Int_t valueX, Int_t valueY, Int_t valueZ, UInt_t order)

   // Add a new fTrack to the list of fTracks for this event.
   // To avoid calling the very time consuming operator new for each fTrack,
   // the standard but not well know C++ operator "new with placement"
   // is called. If fTracks[i] is 0, a new Track object will be created
   // otherwise the previous Track[i] will be overwritten.


   TClonesArray &channels = *fChannels;
   MTChannel *channel = new(channels[fNchannel++]) MTChannel(*aChannel);
   UInt_t bcIdHit =  channel->GetBcIdHit();
   if ( bcIdHit != 0 )
   {
     UInt_t boardId = channel->GetSoftId().GetBoardId(); 
     UInt_t absolute_time = channel->GetAbsTime();
     this->AddHitForAbsTime(boardId,absolute_time,1);

   }
   

//   channels[fNchannel++]  = aChannel;

   return aChannel;
}

//______________________________________________________________________________
void MTEvent::Clear(Option_t * /*option*/)
{
  fChannels->Clear("C"); //will also call Channel::Clear
  fNchannel = 0;

  for (std::map< UInt_t, std::map<UInt_t, UInt_t>* >::iterator iter = fNbHitPerAbsTime.begin(); iter != fNbHitPerAbsTime.end(); iter++)
  {
    map<UInt_t, UInt_t> *byBoard = iter->second;
    delete byBoard;
  }
  fNbHitPerAbsTime.clear();
}


//______________________________________________________________________________
void MTEvent::Reset(Option_t * /*option*/)
{
// Static function to reset all static objects for this event
//   fgChannels->Delete(option);

   delete fgChannels; fgChannels = 0;
}

//______________________________________________________________________________
void MTEvent::SetNchannel(Int_t n) {
    fNchannel = n;
    if ( fNchannel == 0 )
        { fgChannels->Delete(); }
}

//______________________________________________________________________________
// Rappel: Les Channels sont trie dans le TClonesArray par Order

MTChannel* MTEvent::GetChannelByOrder(UInt_t order,UInt_t aChamberId)  const
{
   UInt_t items = 0;

   TIter myiter(fChannels);
   MTChannel* channel;
   while( channel=(MTChannel *)myiter.Next())
   {
     if ( channel->GetChamberId() == aChamberId )
     {
       if ( order == items )
       {
         return channel;
       }
       items++;
     }
   }
   return NULL;


}

//______________________________________________________________________________
UInt_t MTEvent::GetNchannel(UInt_t aChamberId) const
{
   UInt_t items = 0;

   TIter myiter(fChannels);
   MTChannel* channel;
   while( channel=(MTChannel *)myiter.Next())
   {
     if ( channel->GetChamberId() == aChamberId )
     {
       items++;
     }
   }
   return items;
}

//______________________________________________________________________________
void MTEvent::AddHitForAbsTime(UInt_t boardId, UInt_t abs_time, UInt_t increment)
{

 map<UInt_t, UInt_t>* boardMap = NULL;

 // Search map for the boardId
 if ( fNbHitPerAbsTime.find(boardId) != fNbHitPerAbsTime.end())
 {
    boardMap = fNbHitPerAbsTime.find(boardId)->second;   
 }
 else
 {
    boardMap = new map<UInt_t, UInt_t>();
    fNbHitPerAbsTime.insert(make_pair(boardId,boardMap));
 }


  // seatch ab_time in boardId map
 if (boardMap->find(abs_time) != boardMap->end())
 {
    UInt_t b4 =  boardMap->find(abs_time)->second;
    UInt_t foo = b4   + increment;
    (*boardMap)[abs_time]=foo;
 }
 else
 {
      boardMap->insert(make_pair(abs_time,increment));
 }

 
 boardMap = fNbHitPerAbsTime.find(boardId)->second;


}

//______________________________________________________________________________
UInt_t  MTEvent::GetNbHitPerAbsTime(UInt_t boardId,UInt_t abs_time) const 
{
  map<UInt_t, UInt_t>* boardMap = NULL;

  if ( fNbHitPerAbsTime.find(boardId) != fNbHitPerAbsTime.end())
  {
    boardMap = fNbHitPerAbsTime.find(boardId)->second;
    return boardMap->find(abs_time)->second;
  }

  else
  {
    return 0;
  }

}

//______________________________________________________________________________
bool MTEvent::IsValid(void) const
{

   if (( fValid & VALID ) == VALID )return true;
  return false;
}

//______________________________________________________________________________
void MTEvent::SetTemperatureAsu1(UInt_t difId,Float_t asu1)
{
  if ( fTemperatureAsu1.find(difId) != fTemperatureAsu1.end())
    { // dif already exit/ replace value
       fTemperatureAsu1[difId] = asu1;
    }
    else
    { // does not exit create it
      fTemperatureAsu1.insert(make_pair(difId,asu1));
    }
}
//______________________________________________________________________________
void MTEvent::SetTemperatureAsu2(UInt_t difId,Float_t asu2)
{
  if ( fTemperatureAsu2.find(difId) != fTemperatureAsu2.end())
    { // dif already exit/ replace value
       fTemperatureAsu2[difId] = asu2;
    }
    else
    { // does not exit create it
      fTemperatureAsu2.insert(make_pair(difId,asu2));
    }
}
//______________________________________________________________________________
void MTEvent::SetTemperatureDif(UInt_t difId,Float_t dif)
{
  if ( fTemperatureDif.find(difId) != fTemperatureDif.end())
    { // dif already exit/ replace value
       fTemperatureDif[difId] = dif;
    }
    else
    { // does not exit create it
      fTemperatureDif.insert(make_pair(difId,dif));
    }
}

//______________________________________________________________________________
void MTEvent::SetTemperature(UInt_t difId,Float_t asu1, Float_t asu2, Float_t dif)
{
  // Search or create difs container
    if ( fTemperatureAsu1.find(difId) != fTemperatureAsu1.end())
    { // dif already exit/ replace value
       fTemperatureAsu1[difId] = asu1;
    }
    else
    { // does not exit create it
      fTemperatureAsu1.insert(make_pair(difId,asu1));
    }
  // Search or create difs container
    if ( fTemperatureAsu2.find(difId) != fTemperatureAsu2.end())
    { // dif already exit/ replace value
       fTemperatureAsu2[difId] = asu2;
    }
    else
    { // does not exit create it
      fTemperatureAsu2.insert(make_pair(difId,asu2));
    }
  // Search or create difs container
    if ( fTemperatureDif.find(difId) != fTemperatureDif.end())
    { // dif already exit/ replace value
       fTemperatureDif[difId] = dif;
    }
    else
    { // does not exit create it
      fTemperatureDif.insert(make_pair(difId,dif));
    }
}
//______________________________________________________________________________
Float_t MTEvent::GetTemperatureAsu1( UInt_t difId ) const 
{
  if ( fTemperatureAsu1.find(difId) != fTemperatureAsu1.end())
  {
    return fTemperatureAsu1.find(difId)->second;
  }
  else
  {
    throw MicroException("MTEvent::GetTemperatureAsu1 : no difId found");
  }
}
//______________________________________________________________________________
Float_t MTEvent::GetTemperatureAsu2( UInt_t difId ) const 
{
  if ( fTemperatureAsu2.find(difId) != fTemperatureAsu2.end())
  {
    return fTemperatureAsu2.find(difId)->second;
  }
  else
  {
    throw MicroException("MTEvent::GetTemperatureAsu2 : no difId found");
  }
}
//______________________________________________________________________________
Float_t MTEvent::GetTemperatureDif( UInt_t difId ) const 
{
  if ( fTemperatureDif.find(difId) != fTemperatureDif.end())
  {
    return fTemperatureDif.find(difId)->second;
  }
  else
  {
    throw MicroException("MTEvent::GetTemperatureDif : no difId found");
  }
}

//______________________________________________________________________________
void MTEvent::SetValidFlag(UInt_t value,bool valid )
{
    fValid = fValid | fValid;
    if ( ! valid ) { fValid = fValid & 0xFFFE ; }
}

//______________________________________________________________________________
TString MTEvent::GetValidFlagString(void ) const
{
  TString result;
  if (  fValid == VALID ) { return "Valid" ;}
  if ( (fValid & UNKNOW_NOT_VALID )    == UNKNOW_NOT_VALID )    { result = result + " " + "UNKNOW_NOT_VALID" ;}
  if ( (fValid & BAD_CHIP_ID )         == BAD_CHIP_ID )         { result = result + " " + "BAD_CHIP_ID" ;}
  if ( (fValid & BAD_BOARD_ID )        == BAD_BOARD_ID )        { result = result + " " + "BAD_BOARD_ID" ;}
  if ( (fValid & BAD_DIF_ID )          == BAD_DIF_ID )          { result = result + " " + "BAD_DIF_ID" ;}
  if ( (fValid & CRC_ERROR )           == CRC_ERROR )           { result = result + " " + "CRC_ERROR" ;}
  if ( (fValid & ONLY_FFFF)            == ONLY_FFFF )           { result = result + " " + "ONLY_FFFF" ;}
  if ( (fValid & ONLY_AAAA)            == ONLY_AAAA )           { result = result + " " + "ONLY_AAAA" ;}
  if ( (fValid & ONLY_5555)            == ONLY_5555 )           { result = result + " " + "ONLY_5555" ;}
  if ( (fValid & GLOBAL_HEADER_ERROR)  == GLOBAL_HEADER_ERROR ) { result = result + " " + "GLOBAL_HEADER_ERROR" ;}
  if ( (fValid & FRAME_HEADER_ERROR)   == FRAME_HEADER_ERROR )  { result = result + " " + "FRAME_HEADER_ERROR" ;}
  if ( (fValid & TRAILER_C3_FOUND)     == TRAILER_C3_FOUND )    { result = result + " " + "TRAILER_C3_FOUND" ;}
  if ( (fValid & END_OF_FILE_ERROR)    == END_OF_FILE_ERROR )   { result = result + " " + "END_OF_FILE_ERROR" ;}


  return result;
}

---