Bdb packages | Design docs | Source docs | Guidelines | Recent releases
	Search | Site Map .

                 

---

/BdbBitMap/BdbDimensionContext.cc

Go to the documentation of this file.

//------------------------------------------------------------------------------
// File:
//      BdbDimensionContext.cc
//
// Description:
//       Transient class representing one dimension context.
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory
//
// Author List:
//      Jacek Becla, Igor Gaponenko           Original Authors
//
// Copyright Information:
//      Copyright (C) 1997-98      Stanford Linear Accelerator Center
//
//------------------------------------------------------------------------------

//-----------------------
// This Class's Header --
//-----------------------

#ifndef BDBDIMENSIONCONTEXT_HH
#include "BdbBitMap/BdbDimensionContext.hh"
#endif

//-------------------------------
// Collaborating Class Headers --
//-------------------------------




//---------------
// C++ Headers --
//---------------

#include <iostream.h>

//---------------------
// Local definitions --
//---------------------

static const d_ULong BITS_31 = 0x80000000 ;
static const d_ULong BITS_30 = 0x40000000 ;
static const d_ULong BITS_31_30 = ( BITS_31 | BITS_30 ) ;
static const d_ULong BITS_29_00 = 0x3FFFFFFF ;

// =====================================================
// ========                                    =========
// ========    constructor(s) / destructor     =========
// ========                                    =========
// =====================================================

/**  
 **  Default Constructor
 **/

BdbDimensionContext::BdbDimensionContext()
{
    _isInitialized = false ;
    _numBins = 0 ;
    _isCompressed = false ;
}


/**  
 **  Destructor
 **/

BdbDimensionContext::~BdbDimensionContext()
{
  // Flash the vectors if the context was initialized
  // and the vectors are not empty.

    if ( _isInitialized ) {

      // If we use compressing then we have to flash compressed
      // vectors first.

        if ( _isCompressed ) {
            flashComprVectors() ;
        }

      // And after that we will flush the information
      // remaining in tempoary vectors.

        if ( _countTmpVector32 ) {
            flashTmpVectors() ;
        }
    }
}

/**
 **  Initialize context object.
 **/

BdbStatus
BdbDimensionContext::init(BdbRef(BdbBMDimension)& dimRef, d_Boolean isCompressed)
{
    BdbStatus status ;
    d_ULong i ;

  // Check if not initialized yet.

    if ( _isInitialized ) {
        return BdbcError ;
    }

  // Initialize some context variables.

    _dimRef       = dimRef ;
    _numBins      = _dimRef->getNumBins() ;
    _isCompressed = isCompressed ;

  // Set proper size of the bins' references array,
  // then set the values of references.

    status = _binRef.resize(_numBins) ;
    if ( status != BdbcSuccess ) {
        return status ;
    }

    for ( i = 0 ; i < _numBins ; i++ ) {
        status = _dimRef->getBin(i, _binRef[i], BdbcUpdate) ;
        if ( status != BdbcSuccess ) {
            return BdbcError ;
        }
    }

  // Set the proper size of temporary vectors.

    status = _tmpVector32.resize(_numBins) ;
    if ( status != BdbcSuccess ) {
        return status ;
    }
    status = _comprInProgress.resize(_numBins) ;
    if ( status != BdbcSuccess ) {
        return status ;
    }
    status = _comprZeroes.resize(_numBins) ;
    if ( status != BdbcSuccess ) {
        return status ;
    }
    status = _comprCounter.resize(_numBins) ;
    if ( status != BdbcSuccess ) {
        return status ;
    }

  // Clear the contens of temporary and compressing
  // vectors before to be sure that the context is successfuly
  // initialized.

    clearTmpVectors() ;
    clearComprVectors() ;

  // Done.

    _isInitialized = true ;

    return BdbcSuccess ;
}


/**
 **  Find a proper bin number.
 **/

d_ULong
BdbDimensionContext::findBinNumber(d_Float value) const
{
    d_ULong bin = -1 ;

    // -- For the beginning just check for underflow/overflow
    //    condition. In this case we should assign the neares
    //    (border) bin.

    if ( value <= _dimRef->getMinValue()) {
        return 0 ;
    }
    if ( value >= _dimRef->getMaxValue()) {
        return _numBins - 1 ;
    }

    // -- For more complicated situation we scan through the

    for ( d_ULong i = 0 ; i < _numBins ; i++ ) {
        if (( value >= _binRef[i]->getMinValue())&&( value < _binRef[i]->getMaxValue())) {
          bin = i ;
          break ;
        }
    }

    return bin ;
}

/**
 **  Initialize the contents of the temporary and
 **  compressing vectors by zeroes.
 **/

void
BdbDimensionContext::clearTmpVectors()
{
    for ( d_ULong i = 0 ; i < _numBins ; i++ ) {
        _tmpVector32[i] = 0 ;
    }
    _countTmpVector32 = 0 ;
}

void
BdbDimensionContext::clearComprVectors()
{
    for ( d_ULong i = 0 ; i < _numBins ; i++ ) {
        _comprInProgress[i] = false ;
    }
}

/**
 **  Flash the contents of the compressed vector
 **  into bits array.
 **/

BdbStatus
BdbDimensionContext::flashComprVector(d_ULong bin)
{
    BdbStatus status ;
    d_ULong data = ( BITS_29_00 & _comprCounter[bin] ) ;

  // Check for consistency.

    if ( ! _comprInProgress[bin] ) {
        cout << "BdbDimensionContext::flashComprVector - unexpected internal error." << endl ;
        return BdbcError ;
    }

  // Set the higher bits (31,30) into proper state.

    if ( _comprZeroes[bin] ) {
        data = BITS_31    | data ;
    } else {
        data = BITS_31_30 | data ;
    }
                                     
  // Uppend new value by the end of the bit string.

    status = _binRef[bin]->extendBy(data, 0) ;
    if ( BdbcSuccess != status ) {
        return status ;
    }

    _comprInProgress[bin] = false ;

    return BdbcSuccess ;
}

BdbStatus
BdbDimensionContext::flashComprVectors()
{
    d_ULong i ;
    BdbStatus status ;

    for ( i = 0 ; i < _numBins ; i++ ) {

        if ( _comprInProgress[i] ) {

            status = flashComprVector(i) ;
            if ( BdbcSuccess != status ) {
                return status ;
            }
        }
    }

    return BdbcSuccess ;
}

/**
 **  Flash the contents of the temporary
 **  into bits arrays.
 **/

BdbStatus
BdbDimensionContext::flashTmpVector(d_ULong bin)
{
    return _binRef[bin]->extendBy(_tmpVector32[bin], _countTmpVector32) ;
}

BdbStatus
BdbDimensionContext::flashTmpVectors()
{
    BdbStatus status ;
    d_ULong i ;

  // The flashing procedure depends on if we are doing
  // or not doing the vectors compression:

    if ( _isCompressed ) {

      // COMPRESSING:

        for ( i = 0 ; i < _numBins ; i++ ) {

          // Possible to compress?
          // Here we check if we have 30 "0"-es or "1"-s.

            if (( _countTmpVector32 == 30 ) &&
                (( BITS_29_00 == ( BITS_29_00 & _tmpVector32[i] )) || ( ! _tmpVector32[i] ))) {

              // OK. We can compress this word.
              // Now we have to understand whether the compressing
              // is already in progress.

                if ( _comprInProgress[i] ) {

                  // Are we compressing the same ("0" or "1")?

                    if (((   _comprZeroes[i] ) && ( ! _tmpVector32[i] ))
                                               ||
                        (( ! _comprZeroes[i] ) && (   _tmpVector32[i] ))) {

                      // Yes. We are already compressing the same.
                      // Here we just update the compression counter.

                        _comprCounter[i] += 30 ;

                    } else {

                      // Since we were compressing "something" different,
                      // first we have to flash it and then start
                      // compressing new stuff.

                        status = flashComprVector(i) ;
                        if ( status != BdbcSuccess ) {
                            return status ;
                        }

                        _comprInProgress[i] = true ;
                        _comprZeroes[i]     = ! _tmpVector32[i] ;
                        _comprCounter[i]    = 30 ;

                    }

                } else {

                  // NO compressing in progress. We start the
                  // new one.

                    _comprInProgress[i] = true ;
                    _comprZeroes[i]     = ! _tmpVector32[i] ;
                    _comprCounter[i]    = 30 ;
                }

            } else {

              //  Compressing is not possible.
              //  If we are already compressing somthing, we should
              //  flash compression buffer before to flush the temporary one.

                if ( _comprInProgress[i] ) {
                    status = flashComprVector(i) ;
                    if ( status != BdbcSuccess ) {
                        return status ;
                    }
                }

                status = flashTmpVector(i) ;
                if ( status != BdbcSuccess ) {
                    return status ;
                }
            }
        }
    } else {

      // NOT COMPRESSING:
      //
      //   the contents of the temporary vectors is directly uppended
      //   to the end of variable sized bits array of their bin.

        for ( i = 0 ; i < _numBins ; i++ ) {

            status = flashTmpVector(i) ;
            if ( status != BdbcSuccess ) {
                return status ;
            }
        }
    }

  // Clear contents of the temporary vectors in order
  // to prepare them for next bits.

    clearTmpVectors() ;

    return BdbcSuccess ;
}

/**
 **  Add next value to the index database through context
 **/

BdbStatus
BdbDimensionContext::add(d_Float value)
{
    BdbStatus status ;
    d_ULong i ;

    // -- Check if initialized.

    if ( ! _isInitialized ) {
        return BdbcError ;
    }

    // -- Find a proper bin.

    d_ULong bin = findBinNumber(value) ;

    if ( bin == -1 ) {
        return BdbcError ;
    }

    // -- Add the bits to the temporary cache vectors.

    for ( i = 0 ; i < _numBins ; i++ ) {

        d_ULong mask = ( 1 & ( i == bin )) << _countTmpVector32 ;

        _tmpVector32[i] = _tmpVector32[i] | mask ;
    }
    _countTmpVector32++ ;

    // -- Flash the cache vectors if they are full.

    if ( _countTmpVector32 >= 30 ) {
        status = flashTmpVectors() ;
        if ( status != BdbcSuccess ) {
            return status ;
        }
    }

    return BdbcSuccess ;
}

/////////////////
// End Of File //
/////////////////

 

---

BaBar Public Site | SLAC | News | Links | Who's Who | Contact Us

Page Owner: Jacek Becla
Last Update: October 04, 2002