home

MTEvent Class Reference

#include <MTEvent.hh>

Inheritance diagram for MTEvent:

[legend]Collaboration diagram for MTEvent:


Public Member Functions
	MTEvent ()
virtual	~MTEvent ()
MTEvent &	operator= (const Event &rhs)
MTEvent &	operator= (const MTEvent &rhs)
void	Build (UInt_t evtId, ULong64_t difSynchro, Double32_t temperature, Double32_t pressure, ULong64_t timestamp)
void	SetTrack (MTTrack *aTrack)
MTTrack *	GetTrack (void) const
bool	GetSquareEvt (void) const
void	SetSquareEvt (bool value)
bool	GetBorderEvt (void) const
void	SetBorderEvt (bool value)
bool	GetChipEvt (void) const
void	SetChipEvt (bool value)
bool	GetTimeInfo (void) const
void	SetTimeInfo (bool value)
std::vector< UInt_t > &	GetDtCandidate ()
void	Clear (Option_t *option="")
void	SortChannel ()
void	SetGlobalTriggerCounter (UInt_t value)
void	SetDifTriggerCounter (UInt_t value)
UInt_t	GetGlobalTriggerCounter (void) const
UInt_t	GetDifTriggerCounter (void) const
void	AddHitForAbsTime (UInt_t boardId, UInt_t abs_time, UInt_t increment)
UInt_t	GetNbHitPerAbsTime (UInt_t boardId, UInt_t abs_time) const
std::map< UInt_t, std::map< UInt_t, UInt_t > * > &	GetNbHitPerAbsTime ()
bool	GetCrcIsCorrect (void) const
UInt_t	GetValidFlag (void) const
TString	GetValidFlagString (void) const
void	SetValidFlag (UInt_t value, bool valid=true)
bool	IsValid (void) const
void	SetCrcIsCorrect (bool value)
bool	IsSquare (UInt_t nbPad, UInt_t &asu, UInt_t &abs_time, UInt_t chb)
bool	IsBorder (UInt_t nbPad, UInt_t &asu, UInt_t &abs_time, UInt_t chb)
bool	IsChip (UInt_t nbPad, UInt_t &chip, UInt_t &abs_time, UInt_t chb)
void	SetDifSynchro (ULong64_t t)
void	SetTemperature (Double32_t t)
void	SetPressure (Double32_t t)
void	SetTimestamp (ULong64_t t)
void	SetEventId (UInt_t aId)
MTChannel *	AddChannel (const ChannelHit &hit, UInt_t order)
MTChannel *	AddChannel (MTChannel *aChannel)
UInt_t	GetEventId () const
UInt_t	GetId () const
ULong64_t	GetDifSynchro () const
UInt_t	GetNchannel () const
void	SetNchannel (Int_t n)
UInt_t	GetNchannel (UInt_t chamberId) const
Double32_t	GetTemperature () const
ULong64_t	GetTimestamp () const
Double32_t	GetPressure () const
TClonesArray *	GetChannels () const
MTChannel *	GetChannelByOrder (UInt_t order, UInt_t chamberId) const
std::map< UInt_t, std::map< UInt_t, std::map< UInt_t, Float_t > * > * >	GetMeshVoltage () const
std::map< UInt_t, std::map< UInt_t, std::map< UInt_t, Float_t > * > * >	GetDriftVoltage () const
Float_t	GetMeshVoltage (const Int_t chamberId, Int_t difId, Int_t boardId) const
Float_t	GetDriftVoltage (const Int_t chamberId, Int_t difId, Int_t boardId) const
void	SetMeshVoltage (const Int_t chamberId, Int_t difId, Int_t boardId, const Float_t aValue)
void	SetDriftVoltage (const Int_t chamberId, Int_t difId, Int_t boardId, const Float_t aValue)
void	SetTemperature (UInt_t difId, Float_t asu1, Float_t asu2, Float_t dif)
void	SetTemperatureAsu1 (UInt_t difId, Float_t asu1)
void	SetTemperatureAsu2 (UInt_t difId, Float_t asu2)
void	SetTemperatureDif (UInt_t difId, Float_t dif)
Float_t	GetTemperatureAsu1 (UInt_t difId) const
Float_t	GetTemperatureAsu2 (UInt_t difId) const
Float_t	GetTemperatureDif (UInt_t difId) const
std::map< UInt_t, Float_t >	GetTemperatureAsu1 (void) const
std::map< UInt_t, Float_t >	GetTemperatureAsu2 (void) const
std::map< UInt_t, Float_t >	GetTemperatureDif (void) const
Static Public Member Functions
static void	Reset (Option_t *option="")
Private Attributes
bool	fSquareEvt
bool	fBorderEvt
bool	fChipEvt
bool	fTimeInfo
UInt_t	fEventId
Double32_t	fTemperature
std::map< UInt_t, Float_t >	fTemperatureAsu1
std::map< UInt_t, Float_t >	fTemperatureAsu2
std::map< UInt_t, Float_t >	fTemperatureDif
Double32_t	fPressure
ULong64_t	fDifSynchro
ULong64_t	fTimestamp
UInt_t	fGlobalTriggerCounter
UInt_t	fDifTriggerCounter
std::map< UInt_t, std::map< UInt_t, UInt_t > * >	fNbHitPerAbsTime
Int_t	fNchannel
TClonesArray *	fChannels
std::map< UInt_t, std::map< UInt_t, std::map< UInt_t, Float_t > * > * >	fMeshVoltage
std::map< UInt_t, std::map< UInt_t, std::map< UInt_t, Float_t > * > * >	fDriftVoltage
std::vector< UInt_t >	fDtCandidate
MTTrack *	fTrack
bool	fCrcIsCorrect
UInt_t	fValid
Static Private Attributes
static TClonesArray *	fgChannels

Detailed Description

CLASS EVENT (containing Header and MTChannel)

Hardroc + Dirac: 1 evenement == 1 lecture de tous les chips d'une Dif
Gassiplex : 1 evenement == 1 Trigger PM == 1 ecriture Gassiplex

Definition at line 26 of file MTEvent.hh.

Constructor & Destructor Documentation

MTEvent::MTEvent ( )

MTEvent::~MTEvent ( ) [virtual]

Definition at line 48 of file MTEvent.cpp.

00049 {
00050    Clear();
00051 }

Member Function Documentation

MTEvent & MTEvent::operator= ( const Event & rhs )

Definition at line 101 of file MTEvent.cpp.

00103 {
00104      try
00105       {
00106         fCrcIsCorrect = aEvent.getCrcIsCorrect();
00107         fValid = aEvent.getValidFlag();
00108         this->Build(aEvent.getId(), aEvent.getDifSynchro(), aEvent.getTemperature(), aEvent.getPressure(), aEvent.getTimeStamp());
00109         fTrack=NULL;
00110         fTimeInfo=true;
00111         fSquareEvt=false;
00112         fBorderEvt=false;
00113         fChipEvt=false;
00114 
00115         fTemperatureAsu1 = aEvent.getTemperatureAsu1();
00116         fTemperatureAsu2 = aEvent.getTemperatureAsu2();
00117         fTemperatureDif = aEvent.getTemperatureDif();
00118 
00119         ChamberMap_t chamberList = aEvent.getRun().getDetector().getChambers();
00120         for (ChamberMap_t::iterator iter=chamberList.begin(); iter!=chamberList.end(); iter++)
00121         {
00122           Chamber& chamber = *(iter->second);
00123           BoardMap_t boardList = chamber.getBoards();
00124           for ( BoardMap_t::iterator boardIter=boardList.begin(); boardIter!=boardList.end(); boardIter++)
00125           {
00126             ui32 difId = 0;
00127             Board& board = *(boardIter->second);
00128             try
00129             {
00130               const Dif* dif = board.getDif();
00131               if ( dif != NULL ) 
00132               {  // ! Gassilplex Board
00133                 difId = board.getDif()->getId(); 
00134               }
00135               const BoardSlowControl& boardSC =  aEvent.getBoardSlowControl(chamber.getId(),difId,board.getId());
00136               this->SetDriftVoltage(chamber.getId(),difId,board.getId(),boardSC.getDrift().voltage);
00137               this->SetMeshVoltage(chamber.getId(),difId,board.getId(),boardSC.getMesh().voltage);
00138             }
00139             catch ( MicroException e) 
00140             {
00141              FILE_LOG(logDEBUG1) << "---BoardSlowControl not found chamberid[" << chamber.getId() << "] difId[" << difId <<"] boardId[" << board.getId() <<"]" << endl; 
00142             }
00143           }
00144 
00145 
00146                                         this->SetGlobalTriggerCounter(aEvent.getGlobalTriggerCounter());
00147                                         this->SetDifTriggerCounter(aEvent.getDifTriggerCounter());
00148           try
00149           {
00150               const  multiset<ChannelHit*,sorter>& list = aEvent.getChannelHitVector(chamber);
00151               int order = 0 ;
00152               for (set<ChannelHit*,sorter>::iterator iter=list.begin(); iter!=list.end(); iter++)
00153               {
00154                 try
00155                 {
00156                   //const ChannelHit& channelHit = *(*iter);
00157                   ChannelHit& channelHit = *(*iter);
00158                   if ( chamber.getType().find("GASSIPLEX")!=string::npos)
00159                                                                         {
00160                                                                                                 channelHit.setTimestamp(aEvent.getTimeStamp());
00161                                                                   }
00162 
00163 
00164                   MTChannel *ch = this->AddChannel(channelHit, order);
00165                   //i32 deltaT = ch->GetBcIdDif() - ch->GetBcIdHit();
00166                   //if ( deltaT < 0 ) cout << "deltaT < 0" << endl;
00167                   //if ( deltaT == 0 ) cout << "deltaT == 0" << endl;
00168                   //ui32 time = ch->GetAbsTime();
00169                   //cout << "----EventId["<< GetId() << "] Dif Id["<< ch->GetSoftId().GetDifId() << "], Chip Id[" << ch->GetSoftId().GetChipId() << "]  deltat " << deltaT << endl;
00170                   //cout << " ---- Abs time:  " << time  << " EventId["<< GetId() << "] Dif Id["<< ch->GetSoftId().GetDifId() << "], Chip Id[" << ch->GetSoftId().GetChipId() << " Abs time:  " << time << endl; 
00171                   
00172     
00173                   
00174 
00175 
00176 
00177                   order++;  // because aEvent have already been  sorted
00178                 } // end try block
00179                 catch (MicroException e)
00180                 {
00181                 }
00182               } // end for channelHits for this chamber
00183           }
00184           catch (MicroException e)
00185           {
00186                     // get ChamberHitVector for next chamber
00187           }
00188         } // end for chamber
00189       this->GetChannels()->Sort(); // sort by absolute time --> See MTChannels.Compare()
00190       } //try block
00191       catch (MicroException e)
00192       {
00193           throw MicroException(e.getMessage());
00194       }
00195        // Save all objects in this file
00196       return *this;
00197 
00198 }

MTEvent & MTEvent::operator= ( const MTEvent & rhs )

Definition at line 56 of file MTEvent.cpp.

00057 {
00058 
00059   // It is not a real copy as Channels are share as static class member
00060   // So both source and destination MTEvent share the same channels and MTTrack
00061    fSquareEvt = rhs.fSquareEvt;
00062    fBorderEvt = rhs.fBorderEvt;
00063    fChipEvt = rhs.fChipEvt;
00064    fTimeInfo = rhs.fTimeInfo;
00065    fEventId = rhs.fEventId;
00066    fTemperature = rhs.fTemperature;
00067    fPressure = rhs.fPressure;
00068    fDifSynchro = rhs.fDifSynchro;
00069    fTimestamp = rhs.fTimestamp;
00070    fGlobalTriggerCounter = rhs.fGlobalTriggerCounter;
00071    fDifTriggerCounter = rhs.fDifTriggerCounter;
00072    fCrcIsCorrect = rhs.fCrcIsCorrect;
00073    fValid = rhs.fValid;
00074    fNchannel = rhs.fNchannel;
00075 
00076    fNbHitPerAbsTime = rhs.fNbHitPerAbsTime;
00077    fChannels = rhs.fChannels;
00078    fMeshVoltage = rhs.fMeshVoltage;
00079    fDriftVoltage = rhs.fDriftVoltage;
00080    fTrack = rhs.fTrack;
00081    //static TClonesArray *gChannels; // Do not copy class static member
00082    fTemperatureAsu1 = rhs.fTemperatureAsu1;
00083    fTemperatureAsu2 = rhs.fTemperatureAsu2;
00084    fTemperatureDif = rhs.fTemperatureDif;
00085 
00086 
00087   // ATTENTION A BIEN MODIFIER src/analuyse/root/merge.cpp FillEvent()
00088 }

void MTEvent::Build	(	UInt_t	evtId,
		ULong64_t	difSynchro,
		Double32_t	temperature,
		Double32_t	pressure,
		ULong64_t	timestamp
	)

Definition at line 91 of file MTEvent.cpp.

Referenced by operator=().

00092 {
00093 fEventId=evtId;
00094 fTemperature=temperature;
00095 fPressure=pressure;
00096 fTimestamp=timestamp;
00097 fDifSynchro = difSynchro;
00098 }

void MTEvent::SetTrack ( MTTrack * aTrack ) [inline]

Definition at line 79 of file MTEvent.hh.

Referenced by FillEvent(), Find_track(), and main().

00079 { fTrack = aTrack;};

MTTrack* MTEvent::GetTrack ( void ) const [inline]

Definition at line 80 of file MTEvent.hh.

Referenced by buildCaloEvent(), Fill_histos(), FillEvent(), main(), and selectAndCopyEvent().

00080 {  return fTrack;} ;

bool MTEvent::GetSquareEvt ( void ) const [inline]

Definition at line 82 of file MTEvent.hh.

Referenced by FillEvent(), main(), and selectAndCopyEvent().

00082 { return fSquareEvt; } ;

void MTEvent::SetSquareEvt ( bool value ) [inline]

Definition at line 83 of file MTEvent.hh.

Referenced by FillEvent(), and main().

00083 { fSquareEvt = value; } ;

bool MTEvent::GetBorderEvt ( void ) const [inline]

Definition at line 84 of file MTEvent.hh.

Referenced by FillEvent().

00084 { return fBorderEvt; } ;

void MTEvent::SetBorderEvt ( bool value ) [inline]

Definition at line 85 of file MTEvent.hh.

Referenced by FillEvent().

00085 { fBorderEvt = value; } ;

bool MTEvent::GetChipEvt ( void ) const [inline]

Definition at line 86 of file MTEvent.hh.

Referenced by FillEvent().

00086 {return fChipEvt; } ;

void MTEvent::SetChipEvt ( bool value ) [inline]

Definition at line 87 of file MTEvent.hh.

Referenced by FillEvent().

00087 { fChipEvt = value; } ;

bool MTEvent::GetTimeInfo ( void ) const [inline]

Definition at line 88 of file MTEvent.hh.

Referenced by FillEvent(), main(), and selectAndCopyEvent().

00088 { return fTimeInfo; } ;

void MTEvent::SetTimeInfo ( bool value ) [inline]

Definition at line 89 of file MTEvent.hh.

Referenced by FillEvent(), main(), and Valid_time().

00089 { fTimeInfo = value; } ;

std::vector<UInt_t>& MTEvent::GetDtCandidate ( ) [inline]

Definition at line 91 of file MTEvent.hh.

Referenced by main(), and selectAndCopyEvent().

00091 { return fDtCandidate; }

void MTEvent::Clear ( Option_t * option = "" )

Definition at line 642 of file MTEvent.cpp.

Referenced by main(), and ~MTEvent().

00643 {
00644   fChannels->Clear("C"); //will also call Channel::Clear
00645   fNchannel = 0;
00646 
00647   for (std::map< UInt_t, std::map<UInt_t, UInt_t>* >::iterator iter = fNbHitPerAbsTime.begin(); iter != fNbHitPerAbsTime.end(); iter++)
00648   {
00649     map<UInt_t, UInt_t> *byBoard = iter->second;
00650     delete byBoard;
00651   }
00652   fNbHitPerAbsTime.clear();
00653 }

void MTEvent::Reset ( Option_t * option = "" ) [static]

Definition at line 657 of file MTEvent.cpp.

Referenced by G__setup_memfuncMTEvent(), and G__TreeClass_481_0_17().

00658 {
00659 // Static function to reset all static objects for this event
00660 //   fgChannels->Delete(option);
00661 
00662    delete fgChannels; fgChannels = 0;
00663 }

void MTEvent::SortChannel ( ) [inline]

Definition at line 95 of file MTEvent.hh.

00095 { fChannels->Sort(); };

void MTEvent::SetGlobalTriggerCounter ( UInt_t value ) [inline]

Definition at line 96 of file MTEvent.hh.

Referenced by FillEvent(), main(), and operator=().

00096 { fGlobalTriggerCounter = value; };

void MTEvent::SetDifTriggerCounter ( UInt_t value ) [inline]

Definition at line 97 of file MTEvent.hh.

Referenced by FillEvent(), and operator=().

00097 { fDifTriggerCounter = value; };

UInt_t MTEvent::GetGlobalTriggerCounter ( void ) const [inline]

Definition at line 98 of file MTEvent.hh.

Referenced by FillEvent(), and main().

00098 { return fGlobalTriggerCounter; };

UInt_t MTEvent::GetDifTriggerCounter ( void ) const [inline]

Definition at line 99 of file MTEvent.hh.

Referenced by FillEvent(), and main().

00099 { return fDifTriggerCounter; };

void MTEvent::AddHitForAbsTime	(	UInt_t	boardId,
		UInt_t	abs_time,
		UInt_t	increment
	)

Definition at line 715 of file MTEvent.cpp.

Referenced by AddChannel().

00716 {
00717 
00718  map<UInt_t, UInt_t>* boardMap = NULL;
00719 
00720  // Search map for the boardId
00721  if ( fNbHitPerAbsTime.find(boardId) != fNbHitPerAbsTime.end())
00722  {
00723     boardMap = fNbHitPerAbsTime.find(boardId)->second;   
00724  }
00725  else
00726  {
00727     boardMap = new map<UInt_t, UInt_t>();
00728     fNbHitPerAbsTime.insert(make_pair(boardId,boardMap));
00729  }
00730 
00731 
00732   // seatch ab_time in boardId map
00733  if (boardMap->find(abs_time) != boardMap->end())
00734  {
00735     UInt_t b4 =  boardMap->find(abs_time)->second;
00736     UInt_t foo = b4   + increment;
00737     (*boardMap)[abs_time]=foo;
00738  }
00739  else
00740  {
00741       boardMap->insert(make_pair(abs_time,increment));
00742  }
00743 
00744  
00745  boardMap = fNbHitPerAbsTime.find(boardId)->second;
00746 
00747 
00748 }

UInt_t MTEvent::GetNbHitPerAbsTime	(	UInt_t	boardId,
		UInt_t	abs_time
	)			const

Definition at line 751 of file MTEvent.cpp.

Referenced by main().

00752 {
00753   map<UInt_t, UInt_t>* boardMap = NULL;
00754 
00755   if ( fNbHitPerAbsTime.find(boardId) != fNbHitPerAbsTime.end())
00756   {
00757     boardMap = fNbHitPerAbsTime.find(boardId)->second;
00758     return boardMap->find(abs_time)->second;
00759   }
00760 
00761   else
00762   {
00763     return 0;
00764   }
00765 
00766 }

std::map< UInt_t, std::map<UInt_t, UInt_t>* >& MTEvent::GetNbHitPerAbsTime ( ) [inline]

Definition at line 103 of file MTEvent.hh.

00103 { return fNbHitPerAbsTime; };

bool MTEvent::GetCrcIsCorrect ( void ) const [inline]

Definition at line 105 of file MTEvent.hh.

Referenced by FillEvent(), and main().

00105 { return fCrcIsCorrect;} ;

UInt_t MTEvent::GetValidFlag ( void ) const [inline]

Definition at line 106 of file MTEvent.hh.

Referenced by FillEvent(), and main().

00106 { return fValid;} ;

TString MTEvent::GetValidFlagString ( void ) const

Definition at line 889 of file MTEvent.cpp.

00890 {
00891   TString result;
00892   if (  fValid == VALID ) { return "Valid" ;}
00893   if ( (fValid & UNKNOW_NOT_VALID )    == UNKNOW_NOT_VALID )    { result = result + " " + "UNKNOW_NOT_VALID" ;}
00894   if ( (fValid & BAD_CHIP_ID )         == BAD_CHIP_ID )         { result = result + " " + "BAD_CHIP_ID" ;}
00895   if ( (fValid & BAD_BOARD_ID )        == BAD_BOARD_ID )        { result = result + " " + "BAD_BOARD_ID" ;}
00896   if ( (fValid & BAD_DIF_ID )          == BAD_DIF_ID )          { result = result + " " + "BAD_DIF_ID" ;}
00897   if ( (fValid & CRC_ERROR )           == CRC_ERROR )           { result = result + " " + "CRC_ERROR" ;}
00898   if ( (fValid & ONLY_FFFF)            == ONLY_FFFF )           { result = result + " " + "ONLY_FFFF" ;}
00899   if ( (fValid & ONLY_AAAA)            == ONLY_AAAA )           { result = result + " " + "ONLY_AAAA" ;}
00900   if ( (fValid & ONLY_5555)            == ONLY_5555 )           { result = result + " " + "ONLY_5555" ;}
00901   if ( (fValid & GLOBAL_HEADER_ERROR)  == GLOBAL_HEADER_ERROR ) { result = result + " " + "GLOBAL_HEADER_ERROR" ;}
00902   if ( (fValid & FRAME_HEADER_ERROR)   == FRAME_HEADER_ERROR )  { result = result + " " + "FRAME_HEADER_ERROR" ;}
00903   if ( (fValid & TRAILER_C3_FOUND)     == TRAILER_C3_FOUND )    { result = result + " " + "TRAILER_C3_FOUND" ;}
00904   if ( (fValid & END_OF_FILE_ERROR)    == END_OF_FILE_ERROR )   { result = result + " " + "END_OF_FILE_ERROR" ;}
00905 
00906 
00907   return result;
00908 }

void MTEvent::SetValidFlag	(	UInt_t	value,
		bool	valid = `true`
	)

Definition at line 882 of file MTEvent.cpp.

Referenced by FillEvent().

00883 {
00884     fValid = fValid | fValid;
00885     if ( ! valid ) { fValid = fValid & 0xFFFE ; }
00886 }

bool MTEvent::IsValid ( void ) const

Definition at line 769 of file MTEvent.cpp.

Referenced by FillEvent(), main(), and selectAndCopyEvent().

00770 {
00771 
00772    if (( fValid & VALID ) == VALID )return true;
00773   return false;
00774 }

void MTEvent::SetCrcIsCorrect ( bool value ) [inline]

Definition at line 111 of file MTEvent.hh.

Referenced by FillEvent(), and main().

00111 { fCrcIsCorrect = value; };

bool MTEvent::IsSquare	(	UInt_t	nbPad,
		UInt_t &	asu,
		UInt_t &	abs_time,
		UInt_t	chb
	)

Definition at line 201 of file MTEvent.cpp.

Referenced by main().

00202         : nbPad = threshold where we consider an event "Square"; chb = chamber ID.
00203 //outputs: asu = the asu where the event is square; abs_time = the abs_time when the event is square.
00204 {
00205   //square boolean identifier
00206   bool square = false;
00207   //set reference values
00208   asu = -1;
00209   abs_time = -1;
00210   
00211   //declare the hits counter map
00212   map<unsigned int,map<unsigned int,int> > channels_map;// key1=asu (board_id), key2=hit_time      
00213   
00214   //loop on all the channels of the event
00215   UInt_t nchannel = this->GetNchannel();
00216   for (int j=0;j<nchannel;j++){
00217     
00218     //this channel
00219     MTChannel* channel = (MTChannel*)this->GetChannels()->UncheckedAt(j);
00220 
00221     if (channel->GetChamberId()==chb)
00222       { 
00223         //at each channel get board_id and hit_time
00224         UInt_t hit_time =  channel->GetBcIdAbs() - (channel->GetBcIdDif() - channel->GetBcIdHit() );
00225         UInt_t board_id = channel->GetBoardId();
00226     
00227         //upgrade the hits counter of the good board at the good time:
00228         // if this asu doesn't exist yet
00229         if ( channels_map.find(board_id) == channels_map.end()) { 
00230           //create it in the map and fill it
00231           map<unsigned int, int> nbHitMap;
00232           nbHitMap[hit_time]=1;
00233           channels_map.insert(make_pair(board_id,nbHitMap));
00234         }
00235         // if this asu already exist 
00236         else{ 
00237           //find it
00238           map<unsigned int, int> &nbHitMap =  channels_map.find(board_id)->second;
00239           //if this hit_time doesn't exist yet
00240           if (nbHitMap.find(hit_time) == nbHitMap.end()){ 
00241             //add id
00242             nbHitMap.insert(make_pair(hit_time,1)); 
00243           }
00244           //if this abs time already exist
00245           else{ 
00246             //fill it
00247             nbHitMap[hit_time] = nbHitMap[hit_time]++;
00248           }
00249         }  
00250       }      
00251   }
00252   
00253   //Loop on each board, at each time, to identify if this event is square
00254   map<unsigned int, map<unsigned int,int> >::iterator iter1;
00255   for(iter1=channels_map.begin();iter1!=channels_map.end();iter1++){
00256     
00257     unsigned int azu=iter1->first;
00258     map<unsigned int,int> hits_per_time=iter1->second;
00259     
00260     map<unsigned int,int>::iterator iter2;
00261     for(iter2=hits_per_time.begin();iter2!=hits_per_time.end();iter2++){
00262       
00263       unsigned int time = iter2->first;
00264       int nb_hits = iter2->second;
00265       
00266       //if this is a square event
00267       if (nb_hits>=nbPad) {
00268         square=true;
00269         asu = azu;
00270         abs_time = time;
00271       }
00272     }
00273   }
00274   return square;      
00275 }

bool MTEvent::IsBorder	(	UInt_t	nbPad,
		UInt_t &	asu,
		UInt_t &	abs_time,
		UInt_t	chb
	)

Definition at line 278 of file MTEvent.cpp.

00279         : nbPad = threshold where we consider an event "Border"; chb = chamber ID.
00280 //outputs: asu = the asu where the event is border; abs_time = the abs_time when the event is border.
00281 {
00282   //border boolean identifier
00283   bool border = false;
00284   //set reference values
00285   asu = -1;
00286   abs_time = -1;
00287   
00288   //an event can be border only if it is not square (square threshold set to 450 hits)
00289   UInt_t A;
00290   UInt_t T;
00291   if(this->IsSquare(450,A,T,chb)==0) {
00292     //declare the hits counter map
00293     map<unsigned int,map<unsigned long,unsigned int> > channels_map;// key1=asu (board_id), key2=hit_time      
00294     
00295     //loop on all the channels of the event
00296     UInt_t nchannel = this->GetNchannel();
00297     for (unsigned int j=0;j<nchannel;j++){
00298       
00299       //this channel
00300       MTChannel* channel = (MTChannel*)this->GetChannels()->UncheckedAt(j);
00301       
00302       if (channel->GetChamberId()==chb)
00303         { 
00304           //at each channel get board_id and hit_time
00305           ULong_t hit_time =  channel->GetBcIdAbs() - (channel->GetBcIdDif() - channel->GetBcIdHit() );
00306           UInt_t board_id = channel->GetBoardId();
00307           
00308           //get the position of this hit/channel
00309           //Int_t xpos = channel->GetX()/1000;
00310           //Int_t ypos = channel->GetY()/1000;
00311           
00312           //if the hit is not on the borders of an asu go to next hit
00313           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;
00314           
00315           //upgrade the hits counter of the good board at the good time
00316           if (channels_map.find(board_id) == channels_map.end()) { // if this asu doesn't exist yet
00317             
00318             map<unsigned long, unsigned int> nbHitMap;
00319           nbHitMap[hit_time]=1;
00320           channels_map.insert(make_pair(board_id,nbHitMap));
00321           }
00322           else{ // if this asu already exist 
00323             
00324             map<unsigned long, unsigned int> &nbHitMap =  channels_map.find(board_id)->second;
00325             if (nbHitMap.find(hit_time) == nbHitMap.end()){ //if this hit_time doesn't exist yet
00326               
00327               nbHitMap.insert(make_pair(hit_time,1)); 
00328             }
00329             else{ //if this abs time already exist
00330               
00331               nbHitMap[hit_time] = nbHitMap[hit_time]++;
00332             }
00333           }  
00334         }      
00335       
00336       //Loop on each board, at each time, to identify if this event is border
00337       map<unsigned int, map<unsigned long,unsigned int> >::iterator iter1;
00338       for(iter1=channels_map.begin();iter1!=channels_map.end();iter1++){
00339         
00340         unsigned int azu=iter1->first;
00341         map<unsigned long,unsigned int> hits_per_time=iter1->second;
00342         
00343         map<unsigned long,unsigned int>::iterator iter2;
00344         for(iter2=hits_per_time.begin();iter2!=hits_per_time.end();iter2++){
00345           
00346           unsigned long time = iter2->first;
00347           unsigned int nb_hits = iter2->second;
00348           
00349           //if this is a border event
00350           if (nb_hits>=nbPad) {
00351             border = true;
00352             asu = azu;
00353             abs_time = time;
00354           }
00355         }
00356       }
00357     }
00358   }
00359   return border;      
00360 }

bool MTEvent::IsChip	(	UInt_t	nbPad,
		UInt_t &	chip,
		UInt_t &	abs_time,
		UInt_t	chb
	)

Definition at line 363 of file MTEvent.cpp.

00364         : nbPad = threshold where we consider an event "Chip"; chb = chamber ID.
00365 //outputs: chip = the chip where the event is chip; abs_time = the abs_time when the event is chip.
00366 {
00367   //chip boolean identifier
00368   bool me_chip = false;
00369   //set reference values
00370   chip = -1;
00371   abs_time = -1;
00372   
00373   //declare the hits counter map
00374   map<unsigned int,map<unsigned long,unsigned int> > channels_map;// key1=chip (chip_id), key2=hit_time      
00375   
00376   //loop on all the channels of the event
00377   UInt_t nchannel = this->GetNchannel();
00378   for (unsigned int j=0;j<nchannel;j++){
00379     
00380     //this channel
00381     MTChannel* channel = (MTChannel*)this->GetChannels()->UncheckedAt(j);
00382     
00383     if (channel->GetChamberId()==chb)
00384       { 
00385         //at each channel get chip_id and hit_time
00386         ULong_t hit_time =  channel->GetBcIdAbs() - (channel->GetBcIdDif() - channel->GetBcIdHit() );
00387         UInt_t chip_id = channel->GetChipId();
00388         
00389         //get the position of this hit/channel
00390         //Int_t xpos = channel->GetX()/1000;
00391         //Int_t ypos = channel->GetY()/1000;
00392         
00393         //if the hit is not on the chips of an chip go to next hit
00394         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;
00395         
00396         //upgrade the hits counter of the good chip at the good time
00397         if (channels_map.find(chip_id) == channels_map.end()) { // if this chip doesn't exist yet
00398           
00399           map<unsigned long, unsigned int> nbHitMap;
00400           nbHitMap[hit_time]=1;
00401           channels_map.insert(make_pair(chip_id,nbHitMap));
00402         }
00403         else{ // if this chip already exist 
00404           
00405           map<unsigned long, unsigned int> &nbHitMap =  channels_map.find(chip_id)->second;
00406           if (nbHitMap.find(hit_time) == nbHitMap.end()){ //if this hit_time doesn't exist yet
00407             
00408             nbHitMap.insert(make_pair(hit_time,1)); 
00409           }
00410           else{ //if this abs time already exist
00411             
00412             nbHitMap[hit_time] = nbHitMap[hit_time]++;
00413           }
00414         }  
00415       }
00416     
00417     //Loop on each chip, at each time, to identify if this event is chip
00418     map<unsigned int, map<unsigned long,unsigned int> >::iterator iter1;
00419     for(iter1=channels_map.begin();iter1!=channels_map.end();iter1++){
00420       
00421       unsigned int chiip=iter1->first;
00422       map<unsigned long,unsigned int> hits_per_time=iter1->second;
00423       
00424       map<unsigned long,unsigned int>::iterator iter2;
00425       for(iter2=hits_per_time.begin();iter2!=hits_per_time.end();iter2++){
00426         
00427         unsigned long time = iter2->first;
00428         unsigned int nb_hits = iter2->second;
00429         
00430         //if this is a chip event
00431         if (nb_hits>=nbPad) {
00432           me_chip = true;
00433           chip = chiip;
00434           abs_time = time;
00435         }
00436       }
00437     }
00438   } 
00439   return me_chip;      
00440 }

void MTEvent::SetDifSynchro ( ULong64_t t ) [inline]

Definition at line 116 of file MTEvent.hh.

Referenced by FillEvent(), and main().

00116 { fDifSynchro = t; };

void MTEvent::SetTemperature ( Double32_t t ) [inline]

Definition at line 117 of file MTEvent.hh.

Referenced by FillEvent().

00117 { fTemperature = t; };

void MTEvent::SetPressure ( Double32_t t ) [inline]

Definition at line 118 of file MTEvent.hh.

Referenced by FillEvent().

00118 { fPressure = t; };

void MTEvent::SetTimestamp ( ULong64_t t ) [inline]

Definition at line 119 of file MTEvent.hh.

Referenced by FillEvent().

00119 { fTimestamp = t; };

void MTEvent::SetEventId ( UInt_t aId ) [inline]

Definition at line 120 of file MTEvent.hh.

Referenced by main().

00120 { fEventId = aId; } ;

MTChannel * MTEvent::AddChannel	(	const ChannelHit &	hit,
		UInt_t	order
	)

Definition at line 590 of file MTEvent.cpp.

Referenced by main(), and operator=().

00590                                                                   {
00591 //Int_t value, UInt_t softId, UInt_t hardId, Int_t valueX, Int_t valueY, Int_t valueZ, UInt_t order)
00592 
00593    // Add a new fTrack to the list of fTracks for this event.
00594    // To avoid calling the very time consuming operator new for each fTrack,
00595    // the standard but not well know C++ operator "new with placement"
00596    // is called. If fTracks[i] is 0, a new Track object will be created
00597    // otherwise the previous Track[i] will be overwritten.
00598 
00599 
00600    TClonesArray &channels = *fChannels;
00601 
00602    MTChannel *channel = new(channels[fNchannel++]) MTChannel(hit, order);
00603    UInt_t bcIdHit =  channel->GetBcIdHit();
00604    if ( bcIdHit != 0 )
00605    {
00606      UInt_t boardId = channel->GetSoftId().GetBoardId(); 
00607      UInt_t absolute_time = channel->GetAbsTime() ;
00608      this->AddHitForAbsTime(boardId,absolute_time,1);
00609    }
00610 
00611    return channel;
00612 }

MTChannel * MTEvent::AddChannel ( MTChannel * aChannel )

Definition at line 614 of file MTEvent.cpp.

00614                                                   {
00615 //Int_t value, UInt_t softId, UInt_t hardId, Int_t valueX, Int_t valueY, Int_t valueZ, UInt_t order)
00616 
00617    // Add a new fTrack to the list of fTracks for this event.
00618    // To avoid calling the very time consuming operator new for each fTrack,
00619    // the standard but not well know C++ operator "new with placement"
00620    // is called. If fTracks[i] is 0, a new Track object will be created
00621    // otherwise the previous Track[i] will be overwritten.
00622 
00623 
00624    TClonesArray &channels = *fChannels;
00625    MTChannel *channel = new(channels[fNchannel++]) MTChannel(*aChannel);
00626    UInt_t bcIdHit =  channel->GetBcIdHit();
00627    if ( bcIdHit != 0 )
00628    {
00629      UInt_t boardId = channel->GetSoftId().GetBoardId(); 
00630      UInt_t absolute_time = channel->GetAbsTime();
00631      this->AddHitForAbsTime(boardId,absolute_time,1);
00632 
00633    }
00634    
00635 
00636 //   channels[fNchannel++]  = aChannel;
00637 
00638    return aChannel;
00639 }

UInt_t MTEvent::GetEventId ( void ) const [inline]

Definition at line 125 of file MTEvent.hh.

Referenced by GetId(), main(), and CaloEvent::operator=().

00125 { return fEventId; };

UInt_t MTEvent::GetId ( void ) const [inline]

Definition at line 126 of file MTEvent.hh.

00126 { return GetEventId(); };

ULong64_t MTEvent::GetDifSynchro ( ) const [inline]

Definition at line 127 of file MTEvent.hh.

Referenced by FillEvent(), and main().

00127 { return fDifSynchro; } ;

UInt_t MTEvent::GetNchannel ( ) const [inline]

Definition at line 128 of file MTEvent.hh.

Referenced by EventDisplay::adjustSlider(), buildCaloEvent(), EventDisplay::DisplayMTEvent(), Fill_histos(), FillChannels(), BeamProfile::FillHotChamber(), Find_track(), BeamProfile::GetHotChamber(), IsBorder(), IsChip(), IsSquare(), main(), CaloEvent::operator=(), selectAndCopyEvent(), and Valid_time().

00128 { return fNchannel; };

void MTEvent::SetNchannel ( Int_t n )

Definition at line 666 of file MTEvent.cpp.

Referenced by main().

00666                                  {
00667     fNchannel = n;
00668     if ( fNchannel == 0 )
00669         { fgChannels->Delete(); }
00670 }

UInt_t MTEvent::GetNchannel ( UInt_t chamberId ) const

Definition at line 698 of file MTEvent.cpp.

00699 {
00700    UInt_t items = 0;
00701 
00702    TIter myiter(fChannels);
00703    MTChannel* channel;
00704    while( channel=(MTChannel *)myiter.Next())
00705    {
00706      if ( channel->GetChamberId() == aChamberId )
00707      {
00708        items++;
00709      }
00710    }
00711    return items;
00712 }

Double32_t MTEvent::GetTemperature ( void ) const [inline]

Definition at line 132 of file MTEvent.hh.

Referenced by Average_pres_temp(), FillEvent(), main(), and selectAndCopyEvent().

00132 { return fTemperature; };

ULong64_t MTEvent::GetTimestamp ( void ) const [inline]

Definition at line 133 of file MTEvent.hh.

Referenced by buildCaloEvent(), FillEvent(), and main().

00133 {return fTimestamp;};

Double32_t MTEvent::GetPressure ( void ) const [inline]

Definition at line 134 of file MTEvent.hh.

Referenced by Average_pres_temp(), FillEvent(), main(), and selectAndCopyEvent().

00134 { return fPressure; };

TClonesArray* MTEvent::GetChannels ( ) const [inline]

Definition at line 135 of file MTEvent.hh.

Referenced by EventDisplay::adjustSlider(), buildCaloEvent(), EventDisplay::DisplayMTEvent(), Fill_histos(), FillChannels(), BeamProfile::FillHotChamber(), Find_track(), BeamProfile::GetHotChamber(), main(), operator=(), CaloEvent::operator=(), selectAndCopyEvent(), and Valid_time().

00135 { return fChannels; };

MTChannel * MTEvent::GetChannelByOrder	(	UInt_t	order,
		UInt_t	chamberId
	)			const

Definition at line 675 of file MTEvent.cpp.

00676 {
00677    UInt_t items = 0;
00678 
00679    TIter myiter(fChannels);
00680    MTChannel* channel;
00681    while( channel=(MTChannel *)myiter.Next())
00682    {
00683      if ( channel->GetChamberId() == aChamberId )
00684      {
00685        if ( order == items )
00686        {
00687          return channel;
00688        }
00689        items++;
00690      }
00691    }
00692    return NULL;
00693 
00694 
00695 }

std::map<UInt_t, std::map<UInt_t, std::map<UInt_t, Float_t>* >* > MTEvent::GetMeshVoltage ( ) const [inline]

Definition at line 139 of file MTEvent.hh.

Referenced by FillEvent(), and main().

00139 { return fMeshVoltage; };

std::map<UInt_t, std::map<UInt_t, std::map<UInt_t, Float_t>* >* > MTEvent::GetDriftVoltage ( ) const [inline]

Definition at line 140 of file MTEvent.hh.

Referenced by FillEvent(), and main().

00140 { return fDriftVoltage; };

Float_t MTEvent::GetMeshVoltage	(	const Int_t	chamberId,
		Int_t	difId,
		Int_t	boardId
	)			const

Definition at line 443 of file MTEvent.cpp.

00444 {
00445    if ( fMeshVoltage.find(chamberId) != fMeshVoltage.end())
00446     {
00447       map<UInt_t, map<UInt_t, Float_t>* >* difContainer = fMeshVoltage.find(chamberId)->second;
00448       if (difContainer->find(difId) !=  difContainer->end())
00449       {
00450         map<UInt_t , Float_t>* boardContainer = difContainer->find(difId)->second;
00451         if (boardContainer->find(boardId) !=  boardContainer->end())
00452         {
00453             return boardContainer->find(boardId)->second;
00454         }
00455         else
00456         {
00457           throw MicroException("MTEvent::GetMeshVoltage : no board found");
00458         }
00459       }
00460       else
00461       {
00462           throw MicroException("MTEvent::GetMeshVoltage : no board found");
00463       }
00464     }
00465     else
00466 {
00467 }
00468     {
00469       throw MicroException("MTEvent::GetMeshVoltage : no board found");
00470     }
00471 
00472 }

Float_t MTEvent::GetDriftVoltage	(	const Int_t	chamberId,
		Int_t	difId,
		Int_t	boardId
	)			const

Definition at line 474 of file MTEvent.cpp.

00475 {
00476    if ( fDriftVoltage.find(chamberId) != fDriftVoltage.end())
00477     {
00478       map<UInt_t, map<UInt_t, Float_t>* >* difContainer = fDriftVoltage.find(chamberId)->second;
00479       if (difContainer->find(difId) !=  difContainer->end())
00480       {
00481         map<UInt_t , Float_t>* boardContainer = difContainer->find(difId)->second;
00482         if (boardContainer->find(boardId) !=  boardContainer->end())
00483         {
00484             return boardContainer->find(boardId)->second;
00485         }
00486         else
00487         {
00488           throw MicroException("MTEvent::GetDriftVoltage : no board found");
00489         }
00490       }
00491       else
00492       {
00493           throw MicroException("MTEvent::GetDriftVoltage : no board found");
00494       }
00495     }
00496     else
00497     {
00498       throw MicroException("MTEvent::GetDriftVoltage : no board found");
00499     }
00500 
00501 
00502 
00503 }

void MTEvent::SetMeshVoltage	(	const Int_t	chamberId,
		Int_t	difId,
		Int_t	boardId,
		const Float_t	aValue
	)

Definition at line 505 of file MTEvent.cpp.

Referenced by FillEvent(), and operator=().

00506 {
00507   // Search or create difs container for this chamber id
00508     if ( fMeshVoltage.find(chamberId) != fMeshVoltage.end())
00509     { // difs list already exit for this chamber
00510     }
00511     else
00512     { // does not exit create it
00513       map<UInt_t , map<UInt_t, Float_t>* > *difContainer = new map<UInt_t, map<UInt_t, Float_t>* >();
00514       fMeshVoltage.insert(make_pair(chamberId,difContainer));
00515     }
00516 
00517     // Now we are sure that container for this chamber Id exist
00518     map<UInt_t, map<UInt_t, Float_t>* >* difContainer = fMeshVoltage.find(chamberId)->second;
00519 
00520 
00521     // Search or create boards container for this Difs
00522     if ( difContainer->find(difId) != difContainer->end())
00523     { // board list already exit for this dif
00524     }
00525     else
00526     {
00527       map<UInt_t, Float_t>* boardContainer = new map<UInt_t, Float_t>();
00528       difContainer->insert(make_pair(difId,boardContainer));
00529     }
00530 
00531     // Now we are sure that container for this chamber Id  and DifId exist
00532     map<ui32, Float_t>* boardContainer = difContainer->find(difId)->second;
00533 
00534     if ( boardContainer->find(boardId) != boardContainer->end())
00535     {
00536       (*boardContainer)[boardId] = aValue;
00537     }
00538     else
00539     {
00540       boardContainer->insert(make_pair(boardId,aValue));
00541     }
00542 }

void MTEvent::SetDriftVoltage	(	const Int_t	chamberId,
		Int_t	difId,
		Int_t	boardId,
		const Float_t	aValue
	)

Definition at line 545 of file MTEvent.cpp.

Referenced by FillEvent(), and operator=().

00546 {
00547   // Search or create difs container for this chamber id
00548     if ( fDriftVoltage.find(chamberId) != fDriftVoltage.end())
00549     { // difs list already exit for this chamber
00550     }
00551     else
00552     { // does not exit create it
00553       map<UInt_t , map<UInt_t, Float_t>* > *difContainer = new map<UInt_t, map<UInt_t, Float_t>* >();
00554       fDriftVoltage.insert(make_pair(chamberId,difContainer));
00555     }
00556 
00557     // Now we are sure that container for this chamber Id exist
00558     map<UInt_t, map<UInt_t, Float_t>* >* difContainer = fDriftVoltage.find(chamberId)->second;
00559 
00560 
00561     // Search or create boards container for this Difs
00562     if ( difContainer->find(difId) != difContainer->end())
00563     { // board list already exit for this dif
00564     }
00565     else
00566     {
00567       map<UInt_t, Float_t>* boardContainer = new map<UInt_t, Float_t>();
00568       difContainer->insert(make_pair(difId,boardContainer));
00569     }
00570 
00571     // Now we are sure that container for this chamber Id  and DifId exist
00572     map<ui32, Float_t>* boardContainer = difContainer->find(difId)->second;
00573     if ( boardContainer->find(boardId) != boardContainer->end())
00574     {
00575       (*boardContainer)[boardId] = aValue;
00576     }
00577     else
00578     {
00579       boardContainer->insert(make_pair(boardId,aValue));
00580     }
00581 
00582 
00583 
00584 
00585 
00586 }

void MTEvent::SetTemperature	(	UInt_t	difId,
		Float_t	asu1,
		Float_t	asu2,
		Float_t	dif
	)

Definition at line 814 of file MTEvent.cpp.

00815 {
00816   // Search or create difs container
00817     if ( fTemperatureAsu1.find(difId) != fTemperatureAsu1.end())
00818     { // dif already exit/ replace value
00819        fTemperatureAsu1[difId] = asu1;
00820     }
00821     else
00822     { // does not exit create it
00823       fTemperatureAsu1.insert(make_pair(difId,asu1));
00824     }
00825   // Search or create difs container
00826     if ( fTemperatureAsu2.find(difId) != fTemperatureAsu2.end())
00827     { // dif already exit/ replace value
00828        fTemperatureAsu2[difId] = asu2;
00829     }
00830     else
00831     { // does not exit create it
00832       fTemperatureAsu2.insert(make_pair(difId,asu2));
00833     }
00834   // Search or create difs container
00835     if ( fTemperatureDif.find(difId) != fTemperatureDif.end())
00836     { // dif already exit/ replace value
00837        fTemperatureDif[difId] = dif;
00838     }
00839     else
00840     { // does not exit create it
00841       fTemperatureDif.insert(make_pair(difId,dif));
00842     }
00843 }

void MTEvent::SetTemperatureAsu1	(	UInt_t	difId,
		Float_t	asu1
	)

Definition at line 777 of file MTEvent.cpp.

Referenced by FillEvent().

00778 {
00779   if ( fTemperatureAsu1.find(difId) != fTemperatureAsu1.end())
00780     { // dif already exit/ replace value
00781        fTemperatureAsu1[difId] = asu1;
00782     }
00783     else
00784     { // does not exit create it
00785       fTemperatureAsu1.insert(make_pair(difId,asu1));
00786     }
00787 }

void MTEvent::SetTemperatureAsu2	(	UInt_t	difId,
		Float_t	asu2
	)

Definition at line 789 of file MTEvent.cpp.

Referenced by FillEvent().

00790 {
00791   if ( fTemperatureAsu2.find(difId) != fTemperatureAsu2.end())
00792     { // dif already exit/ replace value
00793        fTemperatureAsu2[difId] = asu2;
00794     }
00795     else
00796     { // does not exit create it
00797       fTemperatureAsu2.insert(make_pair(difId,asu2));
00798     }
00799 }

void MTEvent::SetTemperatureDif	(	UInt_t	difId,
		Float_t	dif
	)

Definition at line 801 of file MTEvent.cpp.

Referenced by FillEvent().

00802 {
00803   if ( fTemperatureDif.find(difId) != fTemperatureDif.end())
00804     { // dif already exit/ replace value
00805        fTemperatureDif[difId] = dif;
00806     }
00807     else
00808     { // does not exit create it
00809       fTemperatureDif.insert(make_pair(difId,dif));
00810     }
00811 }

Float_t MTEvent::GetTemperatureAsu1 ( UInt_t difId ) const

Definition at line 845 of file MTEvent.cpp.

Referenced by FillEvent(), and main().

00846 {
00847   if ( fTemperatureAsu1.find(difId) != fTemperatureAsu1.end())
00848   {
00849     return fTemperatureAsu1.find(difId)->second;
00850   }
00851   else
00852   {
00853     throw MicroException("MTEvent::GetTemperatureAsu1 : no difId found");
00854   }
00855 }

Float_t MTEvent::GetTemperatureAsu2 ( UInt_t difId ) const

Definition at line 857 of file MTEvent.cpp.

Referenced by FillEvent(), and main().

00858 {
00859   if ( fTemperatureAsu2.find(difId) != fTemperatureAsu2.end())
00860   {
00861     return fTemperatureAsu2.find(difId)->second;
00862   }
00863   else
00864   {
00865     throw MicroException("MTEvent::GetTemperatureAsu2 : no difId found");
00866   }
00867 }

Float_t MTEvent::GetTemperatureDif ( UInt_t difId ) const

Definition at line 869 of file MTEvent.cpp.

Referenced by FillEvent(), and main().

00870 {
00871   if ( fTemperatureDif.find(difId) != fTemperatureDif.end())
00872   {
00873     return fTemperatureDif.find(difId)->second;
00874   }
00875   else
00876   {
00877     throw MicroException("MTEvent::GetTemperatureDif : no difId found");
00878   }
00879 }

std::map<UInt_t,Float_t> MTEvent::GetTemperatureAsu1 ( void ) const [inline]

Definition at line 157 of file MTEvent.hh.

00157 { return fTemperatureAsu1; } ;

std::map<UInt_t,Float_t> MTEvent::GetTemperatureAsu2 ( void ) const [inline]

Definition at line 158 of file MTEvent.hh.

00158 { return fTemperatureAsu2; } ;

std::map<UInt_t,Float_t> MTEvent::GetTemperatureDif ( void ) const [inline]

Definition at line 159 of file MTEvent.hh.

00159 { return fTemperatureDif; } ;

Member Data Documentation

bool MTEvent::fSquareEvt [private]

Definition at line 29 of file MTEvent.hh.

Referenced by GetSquareEvt(), operator=(), and SetSquareEvt().

bool MTEvent::fBorderEvt [private]

Definition at line 30 of file MTEvent.hh.

Referenced by GetBorderEvt(), operator=(), and SetBorderEvt().

bool MTEvent::fChipEvt [private]

Definition at line 31 of file MTEvent.hh.

Referenced by GetChipEvt(), operator=(), and SetChipEvt().

bool MTEvent::fTimeInfo [private]

Definition at line 32 of file MTEvent.hh.

Referenced by GetTimeInfo(), operator=(), and SetTimeInfo().

UInt_t MTEvent::fEventId [private]

Definition at line 34 of file MTEvent.hh.

Referenced by GetEventId(), operator=(), and SetEventId().

Double32_t MTEvent::fTemperature [private]

Definition at line 35 of file MTEvent.hh.

Referenced by GetTemperature(), operator=(), and SetTemperature().

std::map<UInt_t,Float_t> MTEvent::fTemperatureAsu1 [private]

Definition at line 36 of file MTEvent.hh.

Referenced by GetTemperatureAsu1(), operator=(), SetTemperature(), and SetTemperatureAsu1().

std::map<UInt_t,Float_t> MTEvent::fTemperatureAsu2 [private]

Definition at line 37 of file MTEvent.hh.

Referenced by GetTemperatureAsu2(), operator=(), SetTemperature(), and SetTemperatureAsu2().

std::map<UInt_t,Float_t> MTEvent::fTemperatureDif [private]

Definition at line 38 of file MTEvent.hh.

Referenced by GetTemperatureDif(), operator=(), SetTemperature(), and SetTemperatureDif().

Double32_t MTEvent::fPressure [private]

Definition at line 39 of file MTEvent.hh.

Referenced by GetPressure(), operator=(), and SetPressure().

ULong64_t MTEvent::fDifSynchro [private]

Definition at line 40 of file MTEvent.hh.

Referenced by GetDifSynchro(), operator=(), and SetDifSynchro().

ULong64_t MTEvent::fTimestamp [private]

Definition at line 41 of file MTEvent.hh.

Referenced by GetTimestamp(), operator=(), and SetTimestamp().

UInt_t MTEvent::fGlobalTriggerCounter [private]

Definition at line 42 of file MTEvent.hh.

Referenced by GetGlobalTriggerCounter(), operator=(), and SetGlobalTriggerCounter().

UInt_t MTEvent::fDifTriggerCounter [private]

Definition at line 43 of file MTEvent.hh.

Referenced by GetDifTriggerCounter(), operator=(), and SetDifTriggerCounter().

std::map<UInt_t, std::map<UInt_t, UInt_t>* > MTEvent::fNbHitPerAbsTime [private]

Definition at line 45 of file MTEvent.hh.

Referenced by AddHitForAbsTime(), Clear(), GetNbHitPerAbsTime(), and operator=().

Int_t MTEvent::fNchannel [private]

Definition at line 48 of file MTEvent.hh.

Referenced by GetNchannel(), and operator=().

TClonesArray* MTEvent::fChannels [private]

Definition at line 49 of file MTEvent.hh.

Referenced by AddChannel(), Clear(), GetChannelByOrder(), GetChannels(), GetNchannel(), operator=(), and SortChannel().

std::map<UInt_t, std::map<UInt_t, std::map<UInt_t, Float_t>* >* > MTEvent::fMeshVoltage [private]

Definition at line 54 of file MTEvent.hh.

Referenced by GetMeshVoltage(), operator=(), and SetMeshVoltage().

std::map<UInt_t, std::map<UInt_t, std::map<UInt_t, Float_t>* >* > MTEvent::fDriftVoltage [private]

Definition at line 55 of file MTEvent.hh.

Referenced by GetDriftVoltage(), operator=(), and SetDriftVoltage().

std::vector<UInt_t> MTEvent::fDtCandidate [private]

Definition at line 57 of file MTEvent.hh.

Referenced by GetDtCandidate().

MTTrack* MTEvent::fTrack [private]

Definition at line 59 of file MTEvent.hh.

Referenced by GetTrack(), operator=(), and SetTrack().

TClonesArray* MTEvent::fgChannels [static, private]

Definition at line 65 of file MTEvent.hh.

bool MTEvent::fCrcIsCorrect [private]

Definition at line 68 of file MTEvent.hh.

Referenced by GetCrcIsCorrect(), operator=(), and SetCrcIsCorrect().

UInt_t MTEvent::fValid [private]

Definition at line 69 of file MTEvent.hh.

Referenced by GetValidFlag(), GetValidFlagString(), IsValid(), operator=(), and SetValidFlag().

The documentation for this class was generated from the following files:

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

Generated on Mon Jan 7 13:18:55 2013 for MicromegasFramework by

1.4.7

MTEvent Class Reference

Public Member Functions

Static Public Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation