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

                 

---

/BdbBitMap/BdbBMBuilderTest.cc

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//         $Id: BdbBMBuilderTest.cc,v 1.8 1999/02/06 02:04:26 gapon Exp $
//
// Description:
//        Main program for stand-alone program to populate indexing
//      database with test information.
//
// Environment:
//        Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//        Igor A. Gaponenko                Original Author
//
//------------------------------------------------------------------------

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

#include <string.h>
#include <assert.h>
#include <stdlib.h>

extern "C" {
}

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

#include <iostream.h>
#include <fstream.h>

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

#include "BdbUtil/Bdb.hh"
#include "AbsEvent/AbsEvent.hh"
#include "AbsEventTag/AbsEventTag.hh"
#include "AbsEventTag/AbsEventTagFloatIter.hh"
#include "TagData/TagTransient.hh"
#include "TagDataP/TagAttribute.hh"
#include "BdbAccess/BdbDbInfo.hh"
#include "BdbAccess/BdbDbTreeSingleton.hh"
#include "BdbClustering/BdbEvsHdrClusteringHint.hh"
#include "BdbClustering/BdbSimpleClusteringHint.hh"
#include "BdbTrees/BdbDbRegistrator.hh"
#include "BdbEvent/BdbEvent.hh"
#include "BdbEvent/BdbEventTag.hh"
#include "BdbEventStore/BdbCollection.hh"
#include "BdbEventStore/BdbEventStore.hh"
#include "BdbEventStore/BdbTreeNodeCollectionIterator.hh"
#include "BdbEventStore/BdbEventStoreIterator.hh"
#include "BdbEventStore/BdbTreeCollection.hh"
#include "BdbEventStore/BdbVectorCollection.hh"

#include "BdbIndexing/BdbDimTypes.hh"
#include "BdbBitMap/BdbBMIndexBuilderAPI.hh"
#include "BdbBitMap/BdbBMDimensionDescr.hh"

//-----------------------------------------------------------------------
// Local Macros, Typedefs, Structures, Unions and Forward Declarations --
//-----------------------------------------------------------------------

static const char rcsid[] = "$Id: BdbBMBuilderTest.cc,v 1.8 1999/02/06 02:04:26 gapon Exp $";

//--------------------------------------------------
// Create new indexing database in different ways --
//--------------------------------------------------

BdbStatus createDB(BdbBMIndexBuilderAPI* builder,
                   const char* index)
{
    const d_UShort nDims = 2 ;
    BdbBMDimensionDescr* dims[nDims] ;
    d_Float splits1[3] = {0.0, 1.0, 2.0} ;
    d_Float splits2[3] = {0.0, 1.0, 2.0} ;

    dims[0] = new BdbBMDimensionDescr("X-dim",
                                      BdbDimTypes::FloatDimType,
                                      0.0,
                                      2.0,
                                      2,
                                      false,
                                      splits1);

    dims[1] = new BdbBMDimensionDescr("Y-dim",
                                      BdbDimTypes::FloatDimType,
                                      0.0,
                                      2.0,
                                      2,
                                      false,
                                      splits2);

    return builder->create(index, (const BdbAbsDimensionDescr**) dims, nDims) ;
}

BdbStatus createDB_Interactive(BdbBMIndexBuilderAPI* builder,
                               const char* index)
{
  // Configure the dimensions & database.

    d_ULong nDims;
    d_ULong i ;

    cout << "nDims: " ; cin >> nDims ;

    BdbBMDimensionDescr** dims = new BdbBMDimensionDescr* [nDims] ;

    ooVArray(d_Float) minVal(nDims) ;
    ooVArray(d_Float) maxVal(nDims) ;

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

        char     dimName[80] ;
        d_ULong  nBins ;

        cout << "Dimension " << i << " name: " ; cin >> dimName ;
        cout << "MIN:   " ; cin >> minVal[i] ;
        cout << "MAX:   " ; cin >> maxVal[i] ;
        cout << "nBins: " ; cin >> nBins ;

        d_Float* splits = new d_Float[nBins+1] ;

        cout << "Split points (nBins+1), from MIN to MAX: " ;

        for ( d_ULong j = 0 ; j <= nBins ; j++ ) {
            cin >> splits[j] ;
        }

        dims[i] = new BdbBMDimensionDescr(dimName,
                                          BdbDimTypes::FloatDimType,
                                          minVal[i],
                                          maxVal[i],
                                          nBins,
                                          false,
                                          splits);

        delete splits ;
    }

    BdbStatus status = builder->create(index, (const BdbAbsDimensionDescr**) dims, nDims) ;
        
    delete [] dims ;

    return status ;
}

template<class T>
d_Boolean getToken(istream& infile, const char* token, T& value)
{
    char buf[255] ;

    if ( infile.eof()) {
        cout << "Error\t: Reading config file." << endl
             << "\t: File is not open." << endl ;
        return false ;
    }
    infile >> buf ;

    if ( strcmp(token, buf)) {
        cout << "Error\t: Reading config file." << endl
             << "\t: Keyword \"" << token << "\" was expected" << endl
             << "\t: instead of: \"" << buf << "\"" << endl ;
        return false ;
    }
    infile >> value ;

    return true ;
}

BdbStatus createDB_File(BdbBMIndexBuilderAPI* builder,
                        const char* index,
                        const char* filename)
{
    ifstream infile(filename) ;
    int flag ;

    if ( infile.eof()) {
        cout << "Error\t: Opening specified configuration file." << endl
             << "\t: File does not exist." << endl ;
        return BdbcError ;
    }

    d_UShort nDims;

    if ( ! getToken(infile, "NUMBER_OF_DIMENSIONS:", nDims)) {
        return BdbcError ;
    }

    BdbBMDimensionDescr** dims = new BdbBMDimensionDescr* [nDims] ;

    ooVArray(d_Float) minVal(nDims) ;
    ooVArray(d_Float) maxVal(nDims) ;

    d_Boolean equalBins ;

    for ( d_ULong i = 0 ; i < nDims ; i++ ) {

        char     dimName[80] ;
        d_ULong  nBins ;

        if ( ! getToken(infile, "DIMENSION:", dimName)) {
            return BdbcError ;
        }
        if ( ! getToken(infile, "MIN:", minVal[i])) {
            cout << "\t: Dimension: " << dimName << endl ;
            return BdbcError ;
        }
        if ( ! getToken(infile, "MAX:", maxVal[i])) {
            cout << "\t: Dimension: " << dimName << endl ;
            return BdbcError ;
        }
        if ( ! getToken(infile, "NUMBER_OF_BINS:", nBins)) {
            cout << "\t: Dimension: " << dimName << endl ;
            return BdbcError ;
        }

        d_Float* splits = new d_Float[nBins+1] ;

        if ( ! getToken(infile, "EQUAL_BINS:", flag)) {
            cout << "\t: Dimension: " << dimName << endl ;
            return BdbcError ;
        }

        if ( flag ) {
            equalBins = d_True ;
        } else {
            equalBins = d_False ;
        }

        if ( ! equalBins ) {
            for ( d_ULong j = 0 ; j <= nBins ; j++ ) {

                if ( ! getToken(infile, "SPLIT_POINT:", splits[j])) {
                    cout << "\t: Dimension: " << dimName << endl ;
                    return BdbcError ;
                }
            }
        }

        dims[i] = new BdbBMDimensionDescr(dimName,
                                          BdbDimTypes::FloatDimType,
                                          minVal[i],
                                          maxVal[i],
                                          nBins,
                                          equalBins,
                                          splits);

        delete splits ;
    }

    BdbStatus status = builder->create(index, (const BdbAbsDimensionDescr**) dims, nDims) ;
        
    delete [] dims ;

    return status ;
}

//-------------------------------
// Build new indexing database --
//-------------------------------

BdbStatus buildDB(BdbBMIndexBuilderAPI* builder, const char* filename)
{
    return builder->build(filename) ;
}

//----------------------------------------------------------------
// Generate a plain file to be loaded into an indexing database --
//----------------------------------------------------------------

BdbStatus generateFILE(const char* filename)
{
    d_ULong nDims ;
    d_ULong nEvents ;
    d_ULong i ;
    d_ULong j ;

  // Determine the shape of the output stream.

    cout << "nDims:   " ; cin >> nDims ;
    cout << "nEvents: " ; cin >> nEvents ;

    ooVArray(d_Float) minVal(nDims) ;
    ooVArray(d_Float) maxVal(nDims) ;

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

        cout << i << " : Enter MIN MAX : " ; cin >> minVal[i] >> maxVal[i] ;

        if ( minVal[i] >= maxVal[i] ) {
            cout << "MIN (" << minVal[i] << ")"
                 << " must be less then "
                 << "MAX(" << maxVal[i] << ")"
                 << endl ;
            return BdbcError ;
        }
    }

  // Generate the random sequence and write
  // into output file.

    ofstream outfile(filename) ;
    d_Float val ;

    for ( j = 0 ; j < nEvents ; j++ ) {
        for ( i = 0 ; i < nDims ; i++ ) {

            d_UShort ir = rand() ;
            d_Float  wr = ((d_Float) ir ) / ((d_Float) ( 1024 * 64 - 1)) ;

            val = minVal[i] + (maxVal[i] - minVal[i]) * wr  ;

            outfile << " " << val ;
        }
        outfile << endl ;
    }

    return BdbcSuccess ;
}

//------------------------------------------------------------------------------
// Generate a collection of event->tag to be loaded into an indexing database --
//------------------------------------------------------------------------------

class TagDimensionDescription {

public:

    TagDimensionDescription() {}

    inline void config(const char* name, d_Float min, d_Float max )
    {
        _name = name ;
        _min  = min ;
        _max  = max ;
    }

    inline const char*  name() { return _name.head() ; }
    inline d_Float      min()  { return _min ; }
    inline d_Float      max()  { return _max ; }

private:

    ooVString _name ;
    d_Float   _min ;
    d_Float   _max;
} ;

BdbStatus generateCOLLECTION(const char* collection)
{
    BdbStatus status = BdbcSuccess ;
    d_ULong nDims ;
    d_ULong nEvents ;
    d_ULong i ;
    d_ULong j ;
    TagDimensionDescription* descr ;

  // Determine the shape of the output stream.

    cout << "nDims:   " ; cin >> nDims ;
    cout << "nEvents: " ; cin >> nEvents ;
    
    descr = new TagDimensionDescription[nDims] ;

    d_Float minVal ;
    d_Float maxVal ;
    char name[80] ;

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

        cout << i << " : Enter NAME:         " ; cin >> name ;
        cout << i << " : Enter MIN and MAX : " ; cin >> minVal >> maxVal ;

        if ( minVal >= maxVal ) {
        
            cout << "MIN (" << minVal << ")"
                 << " must be less then "
                 << "MAX(" << maxVal << ")"
                 << endl ;
                 
            status = BdbcError ;
            
            break ;
        }

        descr[i].config(name, minVal, maxVal) ;        
    }

  // Initialize clustering hints.

    BdbDbRegistrator registrator ;
    BdbDbTreeSingleton::instance()->setRegistrator(&registrator) ;
 
    BdbEventStore* theStore = BdbEventStore::instance( ) ;

    BdbAbstractClusteringHint* theTreHint ;
    BdbAbstractClusteringHint* theVecHint ;
    BdbAbstractClusteringHint* theEvtHint ;
    BdbAbstractClusteringHint* theTagHint ;

    theStore->configureClustering() ;

    if ( theStore->useFullClustering()) {
        theTreHint = new BdbEvsClusteringHint(*theStore) ;
        theVecHint = new BdbEvsClusteringHint(*theStore) ;
        theEvtHint = new BdbEvsClusteringHint(*theStore) ;
        theTagHint = new BdbEvsClusteringHint(*theStore) ;
    } else {
        theTreHint = new BdbSimpleClusteringHint(*theStore) ;
        theVecHint = new BdbSimpleClusteringHint(*theStore) ;
        theEvtHint = new BdbSimpleClusteringHint(*theStore) ;
        theTagHint = new BdbSimpleClusteringHint(*theStore) ;
    }
    theTreHint->setComponent("col") ;
    theVecHint->setComponent("col") ;
    theEvtHint->setComponent("evt") ;
    theTagHint->setComponent("tag") ;

    theStore->configureClustering(theTreHint, theVecHint) ;

  // Try to locate collection. It should not exists.

    BdbCollection<BdbEvent> aCollection;

    status = theStore->collection( aCollection, collection );
    if ( BdbcSuccess == status ) {
        cout << "Collection: " << collection << " already exists. Try new one." << endl ;
        return BdbcError ;
    }
    
  // Create new collection.

    status = theStore->treeCollection(aCollection, collection);
    if ( BdbcSuccess == status ) {

      // Create the description if necessary
      
        aCollection.createDescription(aCollection.name()) ;
        
      // Get a persistent reference to the newely created collection.

        BdbHandle(BdbCollectionP) theCollectionP = aCollection.persistent() ;

      // Create and fill transient tag.

        AbsEventTag* theTag = new TagTransient() ;
        d_Float val ;

        for ( j = 0 ; j < nEvents ; j++ ) {
 
            for ( i = 0 ; i < nDims ; i++ ) {

                d_UShort ir = rand() ;
                d_Float  wr = ((d_Float) ir ) / ((d_Float) ( 1024 * 64 - 1)) ;

                val = descr[i].min() + (descr[i].max() - descr[i].min()) * wr  ;
                
                theTag->putFloat(val, descr[i].name()) ;
            }
            
          // Create new event event; attach it to the collection;
 
            BdbHandle(BdbEvent) theEventH = new( theEvtHint->updatedHint()) BdbEvent(j) ;

            aCollection.add(theEventH);
            theEventH->setOwner(theCollectionP) ;

          // Create new empty tag attached to the event.

            BdbHandle(BdbEventTag) theTagH = new (theTagHint->updatedHint()) BdbEventTag(theEventH) ;
            
          // Copy transient tag into the persistent one.

//            theCollectionP->fillTag(theTagH, theTag) ;
            

          // First define the keys & types

            const char* aKey ;

            AbsEventTagFloatIter* floatIter = theTag->floatIter() ;
            while ( floatIter->next()) {
                aKey = floatIter->key( );
                TagAttribute<float> floatKey(aCollection, aKey) ;
            }
            delete floatIter ;

          // Now define the values & save them in the tag

            aCollection.useAndResizeTag(theTagH) ;

            float aFloat ;
            floatIter = theTag->floatIter() ;
            while ( floatIter->next()) {
                aFloat = floatIter->value() ;
                aKey   = floatIter->key() ;
                TagAttribute<float> floatAttr(aCollection, aKey) ;
                floatAttr = aFloat ;
            }
            delete floatIter ;
            

        }
    }

///    theStore->commit() ;

    return BdbcSuccess ;
}

//-----------------------------------
// Dump indexing database contents --
//-----------------------------------

BdbStatus dumpDB_Header(BdbBMIndexBuilderAPI* builder)
{
    return builder->dump() ;
}

BdbStatus dumpDB_Dimension(BdbBMIndexBuilderAPI* builder)
{
    d_ULong dim ;
    d_ULong elements ;

    cout << "DIMENSION: " ; cin >> dim ;
    cout << "ELEMENTS:  " ; cin >> elements ;

    return builder->dump(dim, elements) ;
}

BdbStatus dumpDB_Bin(BdbBMIndexBuilderAPI* builder)
{
    d_ULong dim ;
    d_ULong bin ;
    d_ULong elements ;

    cout << "DIMENSION: " ; cin >> dim ;
    cout << "BIN:       " ; cin >> bin ;
    cout << "ELEMENTS:  " ; cin >> elements ;

    return builder->dump(dim, bin, elements) ;
}

//-----------------
// Main Function --
//-----------------

int
main( int argc, char* argv[] )
{
    int op ;
    char indexName[255] ;
    char collectionName[255] ;
    char fileName[255] ;
    char target[255] ;
    int flag ;
    d_Boolean isCompressed ;

    cout << "===================================" << endl;
    cout << "BitMapIndexBuilder test application" << endl;
    cout << "===================================" << endl;

    cout << " " << endl ;
    cout << " " << endl ;
    cout << " 1 - open existing database" << endl ;
    cout << " 2 - create new database (simplest 2D test)" << endl ;
    cout << " 3 - create new database (take description interactivly)" << endl ;
    cout << " 4 - create new database (load description from file)" << endl ;
    cout << " " << endl ;
    cout << " 5 - build database (fill by data) using events collection" << endl ;
    cout << " 6 - build database (fill by data) using text file" << endl ;
    cout << "70 - generate input tag file for index builder" << endl ;
    cout << "71 - generate a collection of events->tags" << endl ;
    cout << " " << endl ;
    cout << " 8 - dump : database->header" << endl ;
    cout << " 9 - dump : database->dimension" << endl ;
    cout << "10 - dump : database->dimension->bin" << endl ;
    cout << " " << endl ;
    cout << "11 - destroy existing database" << endl ;
    cout << "12 - reset database contents" << endl ;
    cout << " " << endl ;
    cout << "Action: " ; cin >> op ;

    ooInit() ;

    BdbBMIndexBuilderAPI* builder ;

  // Construct the API object in a special way,
  // by passing him a compression flag.

    if (( 2 == op ) || ( 3 == op ) || ( 4 == op )) {

        cout << "INDEX name:                   " ; cin >> indexName ;
        cout << "Compressed (0-false,1-true) : " ; cin >> flag ;

        if ( flag ) {
            isCompressed = d_True ;
        } else {
            isCompressed = d_False ;
        }

        builder = new BdbBMIndexBuilderAPI(isCompressed) ;

    } else {

        builder = new BdbBMIndexBuilderAPI() ;

    }

    builder->startUpdate( );

    switch ( op ) {
    case 1:
        
        cout << "INDEX name:     " ; cin >> indexName ;

        if ( BdbcSuccess == builder->open(indexName)) {
            cout << "open()- done." << endl ;
        } else {
            cout << "open() - failed." << endl ;
        }

        break ;

    case 2:

        if ( BdbcSuccess == createDB(builder, indexName )) {
            cout << "create() - done." << endl ;
        } else {
            cout << "create() - failed." << endl ;
        }

        break ;

    case 3:

        if ( BdbcSuccess == createDB_Interactive(builder, indexName)) {
            cout << "create() - done." << endl ;
        } else {
            cout << "create() - failed." << endl ;
        }

        break ;

    case 4:

        cout << "Configuration file name :     " ; cin >> fileName ;

        if ( BdbcSuccess == createDB_File(builder, indexName, fileName)) {
            cout << "create() - done." << endl ;
        } else {
            cout << "create() - failed." << endl ;
        }

        break ;

    case 5:

        cout << "INDEX name:            " ; cin >> indexName ;
        cout << "Input collection name: " ; cin >> collectionName ;

        strcpy(target, "COLLECTION:") ;
        strcat(target, collectionName) ;

        if ( BdbcSuccess == builder->open(indexName)) {

            cout << "open() - done." << endl ;

            if ( BdbcSuccess == buildDB(builder, target)) {
                cout << "build() - done." << endl ;
            } else {
                cout << "build() - failed." << endl ;
            }

        } else {
            cout << "open() - failed." << endl ;
        }

        break ;

    case 6:

        cout << "INDEX name:      " ; cin >> indexName ;
        cout << "Input file name: " ; cin >> fileName ;

        strcpy(target, "FILE:") ;
        strcat(target, fileName) ;


        if ( BdbcSuccess == builder->open(indexName)) {

            cout << "open() - done." << endl ;

            if ( BdbcSuccess == buildDB(builder, target)) {
                cout << "build() - done." << endl ;
            } else {
                cout << "build() - failed." << endl ;
            }

        } else {
            cout << "open() - failed." << endl ;
        }

        break ;

    case 70:

        cout << "Ouput FILE name: " ; cin >> fileName ;

        if ( BdbcSuccess == generateFILE(fileName)) {
            cout << "generateFILE() - done." << endl ;
        } else {
            cout << "generateFILE() - failed." << endl ;
        }


        break ;
        
    case 71:

        cout << "Ouput COLLECTION name: " ; cin >> fileName ;

        if ( BdbcSuccess == generateCOLLECTION(fileName)) {
            cout << "generateCOLLECTION() - done." << endl ;
        } else {
            cout << "generateCOLLECTION() - failed." << endl ;
        }


        break ;

    case 8:

        cout << "INDEX name:     " ; cin >> indexName ;

        if ( BdbcSuccess == builder->open(indexName)) {

            cout << "open() - done." << endl ;

            if ( BdbcSuccess == dumpDB_Header(builder)) {
                cout << "dump() - done." << endl ;
            } else {
                cout << "dump() - failed." << endl ;
            }

        } else {
            cout << "open() - failed." << endl ;
        }

        break ;

    case 9:

        cout << "INDEX name:     " ; cin >> indexName ;

        if ( BdbcSuccess == builder->open(indexName)) {

            cout << "open() - done." << endl ;

            if ( BdbcSuccess == dumpDB_Dimension(builder)) {
                cout << "dump() - done." << endl ;
            } else {
                cout << "dump() - failed." << endl ;
            }

        } else {
            cout << "open() - failed." << endl ;
        }

        break ;

    case 10:

        cout << "INDEX name:     " ; cin >> indexName ;

        if ( BdbcSuccess == builder->open(indexName)) {

            cout << "open() - done." << endl ;

            if ( BdbcSuccess == dumpDB_Bin(builder)) {
                cout << "dump() - done." << endl ;
            } else {
                cout << "dump() - failed." << endl ;
            }

        } else {
            cout << "open() - failed." << endl ;
        }

        break ;

    case 11:
        
        cout << "INDEX name:     " ; cin >> indexName ;

        if ( BdbcSuccess == builder->open(indexName)) {

            cout << "open() - done." << endl ;

            if ( BdbcSuccess == builder->destroy()) {
                cout << "destroy() - done." << endl ;
            } else {
                cout << "destroy() - failed." << endl ;
            }

        } else {
            cout << "open() - failed." << endl ;
        }

        break ;

    case 12:
        
        cout << "INDEX name:     " ; cin >> indexName ;

        if ( BdbcSuccess == builder->open(indexName)) {

            cout << "open() - done." << endl ;

            if ( BdbcSuccess == builder->reset()) {
                cout << "reset() - done." << endl ;
            } else {
                cout << "reset() - failed." << endl ;
            }

        } else {
            cout << "open() - failed." << endl ;
        }

        break ;
    }

    builder->commit( );

    return 0;
}

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

 

---

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

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