CDFootPrint.cxx

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:     DChain
// Module:      CDFootPrint
//
// Description: keep record of which building-block a CDCandidate uses.
//
// Implimentation:
//     <Notes on implimentation>
//
// Author:      Simon Patton
// Created:     Wed Oct 30 13:29:34 EST 1996
// $Id: CDFootPrint.cxx,v 1.3 2009/10/14 07:18:50 hujf Exp $
//
// Revision history
//
// $Log: CDFootPrint.cxx,v $
// Revision 1.3  2009/10/14 07:18:50  hujf
// see ChangeLog
//
// Revision 1.2  2009/09/22 08:24:41  hujf
// see ChangeLog
//
// Revision 1.1.1.1  2009/03/03 06:05:56  maqm
// first import of BesDChain
//
// Revision 1.1  2001/04/11 13:19:01  urner
// transition to files with CD prefix. Addition of new files
//
// Revision 1.2  2001/03/30 20:13:08  cdj
// CDFootPrint now resets its m_numberIssued when the last CDFootPrint is deleted
//
// Revision 1.1.1.1  2000/12/18 22:17:25  cdj
// imported CleoDChain
//
// Revision 1.13  1998/04/17 18:55:50  sjp
// Modified to use latest types
//
// Revision 1.12  1997/09/03 14:58:34  sjp
// Use new report.h and KTKinematicData
//
// Revision 1.11  1997/08/29 17:00:36  sjp
// Modified to handle new Cairn Templated classes
//
// Revision 1.10  1997/08/19 23:02:48  sjp
// Restructured package to be independent of CleoDChain
//
// Revision 1.9  1997/08/19 20:40:23  sjp
// Updated to use <package>/<file>.h include structure.
//   (Note: This version of the code has not been compiled)
//
// Revision 1.8  1997/01/21 20:36:02  sjp
// Changed CPP flags and include because of library reorganization
//
// Revision 1.7  1996/12/20 21:26:55  sjp
// major overhaul, and fixed memoery bug
//
// Revision 1.6  1996/11/04 16:48:35  sjp
// Variable length storage is implemented
//
// Revision 1.3  1996/04/06 02:49:28  sjp
// Added equality check and `contains' function
//
// Revision 1.2  1996/02/20 00:36:00  sjp
// Changed 'fresh' to return CDFootPrint, made other return values 'const'
//
// Revision 1.1  1995/11/09 20:01:57  sjp
// New class to keep track of object that have already been `used'.
//
 
// system include files
#include <iostream>
#include <stdlib.h> // For 'exit'
 
// user include files
#include "BesDChain/CDFootPrint.h"
 
//
// constants, enums and typedefs
//
 
//
// static data member definitions
//
uint32_t CDFootPrint::m_numberIssued     = 0;
uint32_t CDFootPrint::m_numberFootprints = 0;
 
std::ostream& operator<<( std::ostream& os, const CDFootPrint& obj ) {
  os << "0x" << std::hex;
  for ( int i = obj.m_size - 1; i >= 0; i-- ) { os << obj.m_array[i]; }
  os << std::dec;
 
  return os;
}
// friend classses and functions
 
//
// constructors and destructor
//
 
//------ default constructor -----
//
CDFootPrint::CDFootPrint() : m_size( 0 ), m_array( 0 ) { ++m_numberFootprints; }
 
//------ copy constructor -----
//
CDFootPrint::CDFootPrint( const CDFootPrint& aOtherPrint ) : m_size( 0 ), m_array( 0 ) {
  //
  // book the memory and copy contents of aOtherPrint
  //
  resize( aOtherPrint.m_size );
  for ( uint32_t index = 0; index != m_size; ++index )
  { m_array[index] = aOtherPrint.m_array[index]; }
  ++m_numberFootprints;
}
 
//------ Destructor -----
//
CDFootPrint::~CDFootPrint() {
  //
  // delete memory
  //
  delete[] m_array;
  if ( 0 == --m_numberFootprints ) { reset(); }
}
 
//
// assignment operators
//
 
const CDFootPrint& CDFootPrint::operator=( const CDFootPrint& aOtherPrint ) {
  if ( this == &aOtherPrint )
  {
    //
    // if Footprint is assigned to itself do nothing.
    //
    return ( *this );
  }
  //
  // book the memory and copy contents of aOtherPrint
  //
  resize( aOtherPrint.m_size );
  for ( uint32_t index = 0; index != m_size; ++index )
  { m_array[index] = aOtherPrint.m_array[index]; }
  return ( *this );
}
 
const CDFootPrint& CDFootPrint::operator+=( const CDFootPrint& aOtherPrint ) {
  if ( this == &aOtherPrint )
  {
    //
    // if Footprint is added and assigned to itself do nothing.
    //
    return ( *this );
  }
  if ( m_size >= aOtherPrint.m_size )
  {
    //
    // if this Footprint is larger or equal than to aOtherPrint,
    //   only `or' with the contents of aOtherPoint
    //
    for ( uint32_t index = 0; index != aOtherPrint.m_size; ++index )
    { m_array[index] |= aOtherPrint.m_array[index]; }
  }
  else
  {
    //
    // if this Footprint is smaller than to aOtherPrint book new memory
    // Note: can not use resize, as this thorws away old memory
    //
    uint32_t* tmp_ptr = new uint32_t[aOtherPrint.m_size];
    if ( 0 == tmp_ptr )
    {
      std::cerr << "No memory to allocate another kinematicData" << std::endl;
      exit( 1 );
    }
    //
    // for the length of the old memory, fill the new memory with
    //   `or' of old and aOtherPrint
    //
    for ( uint32_t index_1 = 0; index_1 != m_size; ++index_1 )
    { tmp_ptr[index_1] = m_array[index_1] | aOtherPrint.m_array[index_1]; }
    //
    // for the rest of length of the new memory, fill with aOtherPrint
    //
    for ( uint32_t index_2 = m_size; index_2 != aOtherPrint.m_size; ++index_2 )
    { tmp_ptr[index_2] = aOtherPrint.m_array[index_2]; }
    //
    // delete old memory
    //
    delete[] m_array;
    //
    // update member data elements
    //
    m_size  = aOtherPrint.m_size;
    m_array = tmp_ptr;
  }
  return ( *this );
}
 
//
// member functions
//
 
//------ fresh -----
// assign a fresh footprint to this object
//
CDFootPrint& CDFootPrint::fresh( void ) {
  if ( m_size != 0 )
  {
    //
    // if already assigned a value do nothing
    //
    return ( *this );
  }
 
  const uint32_t kBitsInByte = 8;
  //
  // Take a number and increase the number of CDFootPrints issued
  //
  uint32_t freshNumber = m_numberIssued++;
  //
  // calculate which bit, and which element to set
  //
  uint32_t element         = freshNumber / ( kBitsInByte * sizeof( uint32_t ) );
  uint32_t offsetInElement = freshNumber % ( kBitsInByte * sizeof( uint32_t ) );
  //
  // book enough memory
  //
  resize( element + 1 );
  //
  // fill all but the last part of the memory with zeros
  //
  for ( uint32_t index = 0; index < element; ++index ) { m_array[index] = uint32_t( 0 ); }
  //
  // fill in last part of memory with correct bit set
  //
  m_array[element] = uint32_t( 1 ) << offsetInElement;
  return ( *this );
}
 
//------ resize -----
// resize the arry for the footprint
// Note: This routine does NOT copy the current contents into the
//     new memory
//
void CDFootPrint::resize( const uint32_t aNewSize ) {
  if ( aNewSize == m_size )
  {
    //
    // if Footprint is already the right size do nothing.
    //
    return;
  }
  //
  // allocate a new section of memory, and delete old section
  //
  uint32_t* tmp_ptr = new uint32_t[aNewSize];
  if ( 0 == tmp_ptr )
  {
    std::cerr << "No memory to allocate another kinematicData" << std::endl;
    exit( 1 );
  }
  delete[] m_array;
  //
  // update member data elements
  //
  m_size  = aNewSize;
  m_array = tmp_ptr;
  //
  return;
}
 
//
// const member functions
//
 
//------ equality -----
// test to see if two footprints are identical
//
bool CDFootPrint::operator==( const CDFootPrint& aOtherPrint ) const {
  if ( this == &aOtherPrint )
  {
    //
    // if being compare with itself return `true'
    //
    return ( !false );
  }
  //
  // find the shortest length to compare the two memory sections
  //
  uint32_t shorterSize;
  if ( m_size > aOtherPrint.m_size ) { shorterSize = aOtherPrint.m_size; }
  else { shorterSize = m_size; }
  //
  // check shorter CDFootPrint matches the section longer CDFootPrint
  //
  uint32_t index = 0;
  while ( ( index != shorterSize ) && ( m_array[index] == aOtherPrint.m_array[index] ) )
  { ++index; }
  //
  // if check finished before the shorter CDFootPrint was covered,
  //   then two CDFootPrints are unequal
  //
  if ( index != shorterSize ) { return ( false ); }
  //
  // check that the rest of the longer footprint is zero
  //
  if ( m_size >= aOtherPrint.m_size )
  {
    while ( ( index != m_size ) && ( m_array[index] == uint32_t( 0 ) ) ) { ++index; }
    return ( m_size == index );
  }
  else
  {
    while ( ( index != aOtherPrint.m_size ) &&
            ( aOtherPrint.m_array[index] == uint32_t( 0 ) ) )
    { ++index; }
    return ( aOtherPrint.m_size == index );
  }
}
 
//------ non-equality -----
// test to see if two footprints are not idential
//
bool CDFootPrint::operator!=( const CDFootPrint& aOtherPrint ) const {
  return ( !operator==( aOtherPrint ) );
}
 
//------ addition -----
// combine two CDFootPrints to create a third
//
CDFootPrint CDFootPrint::operator+( const CDFootPrint& aOtherPrint ) const {
  CDFootPrint result( *this );
  result += aOtherPrint;
  return ( result );
}
 
//------ overlap -----
// true if this CDFootPrint overlaps with the other one
//
bool CDFootPrint::overlap( const CDFootPrint& aOtherPrint ) const {
  if ( this == &aOtherPrint )
  {
    //
    // if being tested with itself return `true'
    //
    return ( !false );
  }
  //
  // find the shortest length to compare the two memoery sections
  //
  uint32_t shorterSize;
  if ( m_size > aOtherPrint.m_size ) { shorterSize = aOtherPrint.m_size; }
  else { shorterSize = m_size; }
  //
  // check shorter CDFootPrint matches the section longer CDFootPrint
  //
  uint32_t index = 0;
  while ( ( index != shorterSize ) &&
          ( 0 == ( m_array[index] & aOtherPrint.m_array[index] ) ) )
  { ++index; }
  //
  // if check finished before the shorter CDFootPrint was covered,
  //   then two CDFootPrints have at least one bit in common
  //
  return ( index != shorterSize );
}
 
//------ contains -----
// true if this CDFootPrint contains the other one
//
bool CDFootPrint::contains( const CDFootPrint& aOtherPrint ) const {
  if ( this == &aOtherPrint )
  {
    //
    // if being tested with itself return `true'
    //
    return ( !false );
  }
  //
  // find the shortest length to compare the two memoery sections
  //
  uint32_t shorterSize;
  if ( m_size > aOtherPrint.m_size ) { shorterSize = aOtherPrint.m_size; }
  else { shorterSize = m_size; }
 
  //
  // for shorter CDFootPrint check aOtherPrint is within this one
  //
  uint32_t index = 0;
  while ( ( index != shorterSize ) &&
          ( m_array[index] == ( m_array[index] | aOtherPrint.m_array[index] ) ) )
  { ++index; }
  //
  // if check finished before the shorter CDFootPrint was covered,
  //   then aOtherPrint has at least one bit outside this CDFootPrint
  //
  if ( index != shorterSize ) { return ( false ); }
  //
  // if this CDFootPrint is the longer then aOtherPrint is totally contained
  //
  if ( m_size > aOtherPrint.m_size ) { return ( !false ); }
  //
  // as aOtherPrint is longer need to check rest of it is zero
  //
  while ( ( index != aOtherPrint.m_size ) && ( aOtherPrint.m_array[index] == uint32_t( 0 ) ) )
  { ++index; }
  //
  // if check finished before aOtherPrint was finished
  //   then aOtherPrint has at least one bit in the rest of it
  //
  return ( aOtherPrint.m_size == index );
}
 
//
// static member functions
//
 
//------ reset (a Static Function) -----
// set number issued to zero
//
void CDFootPrint::reset() { m_numberIssued = 0; }