beamtime/cosy-nov11/go4/RPC/TGet4HitUnpacked.cxx (r4864/r2196)

Go to the documentation of this file.

#include "TGet4HitUnpacked.h"

TGet4HitUnpacked::TGet4HitUnpacked( void )
{
  // flags which indicated whether the edge data are set
  // are cleared
  m_bLeadingEdgeSet     = kFALSE;
  m_bTrailingEdgeSet    = kFALSE;
  
  uc_get4               = 0;
  uc_channel            = 0;

  u_EpochCycleLeading   = 0;
  u_EpochNoLeadingEdge  = 0;
  u_TsLeadingEdge       = 0;
  
  u_EpochCycleTrailing  = 0;
  u_EpochNoTrailingEdge = 0;
  u_TsTrailingEdge      = 0;
}

// Copy constructor, needed for memory reason?
TGet4HitUnpacked & TGet4HitUnpacked::operator=( const TGet4HitUnpacked & hitOriginal ) 
{
  if( this != &hitOriginal )
  { 
     this->Clear();
     uc_get4               = hitOriginal.GetGet4Index();
     uc_channel            = hitOriginal.GetChannel();

     m_bLeadingEdgeSet     = hitOriginal.IsLeadingSet();
     if( kTRUE == m_bLeadingEdgeSet )
     {
        u_EpochCycleLeading   = hitOriginal.GetEpochCycleLeading();
        u_EpochNoLeadingEdge  = hitOriginal.GetEpochLeading();
        u_TsLeadingEdge       = hitOriginal.GetTsLeading();
     }
 
     m_bTrailingEdgeSet    = hitOriginal.IsLeadingSet();
     if( kTRUE == m_bTrailingEdgeSet )
     {
        u_EpochCycleTrailing  = hitOriginal.GetEpochCycleTrailing();
        u_EpochNoTrailingEdge = hitOriginal.GetEpochTrailing();
        u_TsTrailingEdge      = hitOriginal.GetTsTrailing();
     }
     
   }
   return *this;
}

void TGet4HitUnpacked::ClearHit( void )
{
  // flags which indicated whether the edge data are set
  // are cleared
  m_bLeadingEdgeSet     = kFALSE;
  m_bTrailingEdgeSet    = kFALSE;
  
  uc_get4               = 0;
  uc_channel            = 0;

  u_EpochCycleLeading   = 0;
  u_EpochNoLeadingEdge  = 0;
  u_TsLeadingEdge       = 0;
  
  u_EpochCycleTrailing  = 0;
  u_EpochNoTrailingEdge = 0;
  u_TsTrailingEdge      = 0;
}


#ifndef ROC_GET4_BUILDEVENT
// Definition check because ROOT did not aknowledge roc::message in 
// old versions
// Maybe unnecessary
void TGet4HitUnpacked::SetMessage( roc::Message &msgNewEdge, UInt_t uEpoch, UInt_t epochCycleRaw )
{
  // first it is checked whether this is a GET4 data event.
  if ( msgNewEdge.getMessageType() == roc::MSG_GET4 )
  {
      // getting the edge flag
      UInt_t uEdge = msgNewEdge.getGet4Edge();
      if ( uEdge == 0 )
      {
         Bool_t bLeadingErrorSet = kFALSE;
         if ( m_bLeadingEdgeSet )
            // Error: The trailing edge is already set.
            bLeadingErrorSet = kTRUE; // => Continue however
            
         // storing the data
         m_bLeadingEdgeSet = kTRUE;
         
         uc_get4    = msgNewEdge.getGet4Number();
         uc_channel = msgNewEdge.getGet4ChNum();
         u_EpochNoLeadingEdge = uEpoch;
         u_EpochCycleLeading  = epochCycleRaw;
         u_TsLeadingEdge      = msgNewEdge.getGet4Ts();
         
         if ( m_bTrailingEdgeSet )
         {
            // Time Gating
            if( TIME_GATE*EPOCH_IN_NS < this->GetTOT() )
            {
               Double_t temptot = this->GetTOT();
               m_bTrailingEdgeSet = kFALSE;
//               throw CEOutOfTimeGate();
               throw CEOutOfTimeGateDetail( temptot );
            }
                  
            if( this->GetTOT() < -0.00001)
            {
               Double_t temptot = this->GetTOT();
               m_bTrailingEdgeSet = kFALSE;
//               throw CEGivesNegativeToT();
               throw CEGivesNegativeToTDetail( temptot );
            }
         }
         
         if ( kTRUE == bLeadingErrorSet )
            throw CELeadingEdgeAlreadySet();
      }
      else
      {
         if ( m_bTrailingEdgeSet )
            // Error: The trailing edge is already set.
            throw CETrailingEdgeAlreadySet();

         // storing the data
         m_bTrailingEdgeSet = kTRUE;

         uc_get4    = msgNewEdge.getGet4Number();
         uc_channel = msgNewEdge.getGet4ChNum();
         u_EpochNoTrailingEdge = uEpoch;
         u_EpochCycleTrailing  = epochCycleRaw;
         u_TsTrailingEdge      = msgNewEdge.getGet4Ts();

         if ( m_bLeadingEdgeSet )
         {
            // Time Gating         
            if( TIME_GATE*EPOCH_IN_NS < this->GetTOT() )
            {
               Double_t temptot = this->GetTOT();
               m_bLeadingEdgeSet = kFALSE;
//               throw CEOutOfTimeGate();
               throw CEOutOfTimeGateDetail( temptot );
            }

            // Should never happen, bad messages!
            if( this->GetTOT() < -0.00001)
            {
               Double_t temptot = this->GetTOT();
               m_bLeadingEdgeSet = kFALSE;
//               throw CEGivesNegativeToT();
               throw CEGivesNegativeToTDetail( temptot );
            }
         }
      }
  }
  else
  { 
    throw CENoGET4DataEvent(msgNewEdge.getMessageType());
  }
}
#endif // ROC_GET4_BUILDEVENT

Bool_t TGet4HitUnpacked::Complete( void ) const
{
  // The hit information is complete when leading and
  // trailing edge information are set.
  return m_bLeadingEdgeSet && m_bTrailingEdgeSet;
}

Double_t TGet4HitUnpacked::GetTOT( void ) const
{
  // calculation of time over threshold is only possible
  // if the hit information is complete.
  if ( Complete() )
  {
      // Time over threshold is the difference between timestamps of
      // trailing and leading edge multiplied by 0.05 ns.
      Double_t dToT = BIN_SIZE_IN_NS * (Double_t) ( (Double_t) u_TsTrailingEdge -
                   (Double_t)u_TsLeadingEdge );
      // When leading and trailing edge are not in the same epoch
      // the time over threshold has to be corrected
      if ( u_EpochNoLeadingEdge != u_EpochNoTrailingEdge )
      {
         if( u_EpochCycleLeading != u_EpochCycleTrailing )
         {
            dToT += EPOCH_IN_NS * (Double_t) ( (Double_t)u_EpochNoTrailingEdge - 
                                             (Double_t)u_EpochNoLeadingEdge +
                                             (Double_t)CYCLE_IN_EPOCHS * (Double_t) ( (Double_t)u_EpochCycleTrailing - 
                                             (Double_t)u_EpochCycleLeading )  );
         }
         else
         {
            dToT += EPOCH_IN_NS * (Double_t) ( (Double_t)u_EpochNoTrailingEdge - 
                                          (Double_t)u_EpochNoLeadingEdge );
         }
      }
      // returns tot in ns.
      return dToT;
    }
  else
    throw CEHitIsNotComplete();
}
Int_t TGet4HitUnpacked::GetRawTOT( void ) const
{
  // calculation of time over threshold is only possible
  // if the hit information is complete.
  if ( Complete() )
  {
      // Time over threshold is the difference between timestamps of
      // trailing and leading edge multiplied by 0.05 ns.
      Int_t iToT = (Int_t) ( (Int_t) u_TsTrailingEdge -
                   (Int_t)u_TsLeadingEdge );
      // When leading and trailing edge are not in the same epoch
      // the time over threshold has to be corrected
      if ( u_EpochNoLeadingEdge != u_EpochNoTrailingEdge )
      {
         if( u_EpochCycleLeading != u_EpochCycleTrailing )
         {
            iToT += EPOCH_IN_BINS * (Int_t) ( (Int_t)u_EpochNoTrailingEdge - 
                                                (Int_t)u_EpochNoLeadingEdge +
                                                CYCLE_IN_EPOCHS * (Int_t) ( (Int_t)u_EpochCycleTrailing - 
                                                                              (Int_t)u_EpochCycleLeading ) );
         }
         else
         {
            iToT += EPOCH_IN_BINS * (Int_t) ( (Int_t)u_EpochNoTrailingEdge - 
                                                (Int_t)u_EpochNoLeadingEdge );
         }
      }
      // returns tot in bin.
      return iToT;
  }
  else
    throw CEHitIsNotComplete();
}

Double_t TGet4HitUnpacked::Spacing( const TGet4HitUnpacked &hitFollowing ) const
{
  // calculation of pulse spacing is only possible
  // if the hit information of both hits is complete.
  if ( Complete() && hitFollowing.Complete() )
  {
      // calculation is the same like for time over threshold
      Double_t dSpacing = BIN_SIZE_IN_NS * 
            (Double_t) ( (Double_t)hitFollowing.u_TsLeadingEdge -
                        (Double_t)u_TsLeadingEdge );
      if ( u_EpochNoLeadingEdge != hitFollowing.u_EpochNoLeadingEdge )
      {
         dSpacing += EPOCH_IN_NS * (Double_t) ( (Double_t)hitFollowing.u_EpochNoLeadingEdge - 
                                       (Double_t)u_EpochNoLeadingEdge );
         if( u_EpochCycleLeading !=  hitFollowing.u_EpochCycleLeading )
         {
            dSpacing += EPOCH_IN_NS * (Double_t)CYCLE_IN_EPOCHS 
                                    * (Double_t) ( (Double_t)hitFollowing.u_EpochCycleLeading - 
                                                 (Double_t)u_EpochCycleLeading ) ;
         }
      }
      // returns pulse spacing in ns.
      return dSpacing;
  }
  else
    throw CEHitIsNotComplete();
}

Int_t TGet4HitUnpacked::CyclesDiff( const TGet4HitUnpacked &hitFollowing ) const
{
   return (Int_t) ( (Int_t)hitFollowing.u_EpochCycleLeading - (Int_t)u_EpochCycleLeading ) ;
}
Int_t TGet4HitUnpacked::EpochsDiff( const TGet4HitUnpacked &hitFollowing ) const
{
   return (Int_t) ( (Int_t)hitFollowing.u_EpochNoLeadingEdge - (Int_t)u_EpochNoLeadingEdge ) ;
}

UChar_t TGet4HitUnpacked::GetGet4Index() const
{
   return uc_get4;
}
UChar_t TGet4HitUnpacked::GetChannel() const
{
   return uc_channel;
}
UInt_t TGet4HitUnpacked::GetFullChan() const
{
   return ((UInt_t)uc_get4)*4 + (UInt_t)uc_channel;
}
UInt_t TGet4HitUnpacked::GetEpochCycleLeading() const
{
   return u_EpochCycleLeading;
}
UInt_t TGet4HitUnpacked::GetEpochLeading() const
{
   return u_EpochNoLeadingEdge;
}
UInt_t TGet4HitUnpacked::GetTsLeading() const
{
   return u_TsLeadingEdge;
}
UInt_t TGet4HitUnpacked::GetEpochCycleTrailing() const
{
   return u_EpochCycleTrailing;
}
UInt_t TGet4HitUnpacked::GetEpochTrailing() const
{
   return u_EpochNoTrailingEdge;
}
UInt_t TGet4HitUnpacked::GetTsTrailing() const
{
   return u_TsTrailingEdge;
}
Bool_t TGet4HitUnpacked::IsLeadingSet() const
{
   return m_bLeadingEdgeSet;
}
Bool_t TGet4HitUnpacked::IsTrailingSet() const
{
   return m_bTrailingEdgeSet;
}


void TGet4HitUnpacked::SetGet4Index(UChar_t get4_indexIn)
{
   uc_get4 = get4_indexIn;
   return ;
}
void TGet4HitUnpacked::SetChannel(UChar_t channelIn)
{
   uc_channel = channelIn;
   return ;
}
void TGet4HitUnpacked::SetFullChan(UInt_t fullChanIn)
{
   uc_get4    = (UChar_t)(fullChanIn/4);
   uc_channel = (UChar_t)(fullChanIn%4);
   return ;
}
// Used normally only for EXT_SYNC messages
void TGet4HitUnpacked::SetEpochLeading(UInt_t epochLeadingEdgeIn, UInt_t epochCycleIn)
{
   m_bLeadingEdgeSet    = kTRUE;
   m_bTrailingEdgeSet   = kTRUE;
   u_EpochNoLeadingEdge = epochLeadingEdgeIn;
   u_EpochCycleLeading  = epochCycleIn;
   return ;
}
void TGet4HitUnpacked::SetTsLeading(UInt_t tsLeadingIn) 
{
   u_TsLeadingEdge = tsLeadingIn;
   return ;
}

Int_t TGet4HitUnpacked::EpochEdgesDiff()
{
   // Just return the distance in terms of Epochs nb between the 2
   // edge messages
   if ( this->Complete() )
      return ((Int_t)u_EpochNoTrailingEdge - (Int_t)u_EpochNoLeadingEdge
                        + CYCLE_IN_EPOCHS * (Int_t) ( (Int_t)u_EpochCycleTrailing - 
                                                (Int_t)u_EpochCycleLeading ) );
   else
      throw CEHitIsNotComplete();
}


/* This is the function used to sort Hits in a list in 
 * function TimeOrderBlock
 * For this, it compares 
 * 1) The epoch index cycles
 * 2) The epoch indexes
 * 3) the leading edge timestamps
 */
bool TGet4HitUnpacked::operator<(const TGet4HitUnpacked &rhs) const
{
   // Epoch counter reset between the 2 hits ?
   if( GetEpochCycleLeading() < rhs.GetEpochCycleLeading() )
      return true;
   else if( GetEpochCycleLeading() > rhs.GetEpochCycleLeading() )
      return false;
   // Same cycle => Clock counter reset between the 2 hits ? (epoch
   else if( GetEpochLeading() < rhs.GetEpochLeading() )
      return true;
   else if( GetEpochLeading() > rhs.GetEpochLeading() )
      return false;
   // Same cycle and same epoch!
   else if( 0.0 <= Spacing(rhs) )
         return true;
   else return false;
}