beamtime/cosy-jan12/go4/STS/TSTSHiterizer.cxx (r4864/r3090)

Go to the documentation of this file.

/*
 * TSTSHiterizer.cxx
 *
 *  Created on: Jan 9, 2012
 *      Author: isorokin
 */

#include "TSTSHiterizer.h"
#include "TMath.h"

TSTSHiterizer::TSTSHiterizer( Int_t det )
{
        fDetector = det;
        fTimeTolerance = kDefTimeTolerance;
        fTimeWindow = kDefTimeWindow;
        fLatestClusterTime = 0;
}

TSTSHiterizer::~TSTSHiterizer()
{
}


void TSTSHiterizer::ClearClustBuffers()
{
    fClusters[TSTSTopology::kPSide].clear();
    fClusters[TSTSTopology::kNSide].clear();
}



Bool_t TSTSHiterizer::Match( const TSTSCluster & clust1, const TSTSCluster & clust2) const
{
    Long64_t diff = clust1.GetTime() - clust2.GetTime();
    return TMath::Abs( diff ) <= fTimeTolerance;
}



/*
 * In triggered mode the method must be called only when all clusters are fed in.
 */
void TSTSHiterizer::ReconstructHits( Bool_t noTrigger )
{
    while( IsClusterBuffersFilled( noTrigger ) ) {
        TSTSTopology::ESTSSide oldestClusterSide = GetOldesetClusterSide();
        const TSTSCluster & oldestCluster = fClusters[oldestClusterSide].front();
        TSTSTopology::ESTSSide oppositeSide = TSTSTopology::OppositeSide( oldestClusterSide );
        std::deque<TSTSCluster>::iterator oppSideIter = fClusters[oppositeSide].begin();
        while( 1 ) {
            if( oppSideIter == fClusters[oppositeSide].end() ) {
                break;
            }
            if( oppSideIter->GetTime() - oldestCluster.GetTime() > fTimeTolerance  ) {
                break;
            }
            if( Match( oldestCluster, * oppSideIter) ) {
                CreateHit( oldestCluster, oldestClusterSide, * oppSideIter, oppositeSide );
            }
            oppSideIter++;
        }
        fClusters[oldestClusterSide].pop_front();
    }

    const Bool_t clearClustBuffersBetweenEvents = kTRUE;
    if( clearClustBuffersBetweenEvents ) {
        if( ! noTrigger ) {
            ClearClustBuffers();
        }
    }
}



void TSTSHiterizer::CheckTimeWindowSufficient( Long64_t newClustTime )
{
    if( fLatestClusterTime - newClustTime + fTimeTolerance > fTimeWindow ) {
        fTimeWindow = fTimeWindow * 2;
        printf( "Error in TSTSHiterizer: Time window is too small. Increasing by factor of 2. New value is %lld. Happened at time %lld\n", fTimeWindow, newClustTime );
    }
    if( newClustTime > fLatestClusterTime ) {
        fLatestClusterTime = newClustTime;
    }
}



void TSTSHiterizer::InsertClusterSorted(TSTSTopology::ESTSSide side, const TSTSCluster & cluster)
{
    if( fClusters[side].size() == 0 ) {
        fClusters[side].push_back( cluster );
    }
    else {
        for( std::deque<TSTSCluster>::iterator it = fClusters[side].end(); it != fClusters[side].begin(); it-- ) {
            if( cluster.GetTime() > ( it - 1 )->GetTime() ) {
                fClusters[side].insert( it, cluster );
                return;
            }
        }
    }
}




void TSTSHiterizer::FeedCluster( const TSTSCluster & cluster, TSTSTopology::ESTSSide side )
{
    CheckTimeWindowSufficient( cluster.GetTime() );
    InsertClusterSorted( side, cluster );
}



void TSTSHiterizer::CreateHit( const TSTSCluster & clust1, TSTSTopology::ESTSSide side1, const TSTSCluster & clust2, TSTSTopology::ESTSSide side2)
{
    if( side1 == TSTSTopology::kPSide ) {
        fHits.push_back( TSTSHit( clust1, clust2 ) );
    }
    else {
        fHits.push_back( TSTSHit( clust2, clust1 ) );
    }
}



/*
 * Assumes that the cluster buffers fClusters are not empty
 */
Bool_t TSTSHiterizer::IsClusterBuffersContainSufficientTimeInterval() const
{
    TSTSTopology::ESTSSide oldestClustSide = GetOldesetClusterSide();
    TSTSTopology::ESTSSide oppositeSide = TSTSTopology::OppositeSide( oldestClustSide );
    return fClusters[oppositeSide].back().GetTime() - fClusters[oldestClustSide].front().GetTime() > fTimeWindow;
}



Bool_t TSTSHiterizer::IsClusterBuffersFilled( Bool_t noTrigger ) const {
    if( fClusters[TSTSTopology::kPSide].size() == 0 ) return kFALSE;
    if( fClusters[TSTSTopology::kNSide].size() == 0 ) return kFALSE;
    if( noTrigger ) {
        if( ! IsClusterBuffersContainSufficientTimeInterval() ) return kFALSE;
    }
    return kTRUE;
}



void TSTSHiterizer::PrintBuffers() const
{
    printf( "===== Cluster buffer state: =====\n");
    printf( "Times of p-side clusters, size=%lu \n", fClusters[TSTSTopology::kPSide].size() );
    for( std::deque<TSTSCluster>::const_iterator it = fClusters[TSTSTopology::kPSide].begin(); it != fClusters[TSTSTopology::kPSide].end(); it++ ) {
        printf("%lld\n", it->GetTime() );
    }
    printf( "Times of n-side clusters, size=%lu \n", fClusters[TSTSTopology::kNSide].size());
    for( std::deque<TSTSCluster>::const_iterator it = fClusters[TSTSTopology::kNSide].begin(); it != fClusters[TSTSTopology::kNSide].end(); it++ ) {
        printf("%lld\n", it->GetTime() );
    }
}



/*
 * Assumes that the cluster buffers fClusters are not empty
 */
TSTSTopology::ESTSSide TSTSHiterizer::GetOldesetClusterSide() const
{
    return fClusters[TSTSTopology::kPSide].front().GetTime() < fClusters[TSTSTopology::kNSide].front().GetTime() ? TSTSTopology::kPSide : TSTSTopology::kNSide;
}

/*
 * In triggered mode the method must be called only when all clusters are already fed in.
 * Returns
 */

Bool_t TSTSHiterizer::FetchHit( Bool_t noTrigger, TSTSHit & hit )
{
    ReconstructHits( noTrigger );
    if( fHits.size() > 0 ) {
        hit = fHits.front();
        fHits.pop_front();
        return kTRUE;
    }
    return kFALSE;
}


/*
 * Clear all buffers. Normally not needed.
 */
void TSTSHiterizer::Clear()
{
    ClearClustBuffers();
    fHits.clear();
}