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

                 

---

/BdbCondRemote/BdbCondRemoteAccessor.cc

Go to the documentation of this file.

//-----------------------------------------------------------------------------
//
// File and Version Information:
//      $Id: BdbCondRemoteAccessor.cc,v 1.11 2002/06/21 18:49:55 ryd Exp $
//
// Description:
//      This class implements an interface of its base class BdbCondAccessor.
//
//      The current implementation provides remote access to the methadata
//      through TAO/CORBA.
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      Igor A. Gaponenko       Original Author
//
// Copyright Information:
//      Copyright (C) 2000      Lawrence Berkeley Laboratory
//
//-----------------------------------------------------------------------------
#include "BaBar/BaBar.hh"

// Work around a bug in ACE/TAO with DEC CXX6.3
#include <string.h>

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

#include "BdbCondRemote/BdbCondRemoteAccessor.hh"

// -------------------------
// -- Objectivity Headers --
// -------------------------

// -------------------
// -- BaBar Headers --
// -------------------

// ----------------------------
// -- BaBar Database Headers --
// ----------------------------

#include "BdbCond/BdbConditions.hh"
#include "BdbCond/BdbDatabase.hh"

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

extern "C" {
#include <assert.h>
}

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

#include "TaoTools/TaoClient.hh"
#include "ErrLogger/ErrLog.hh"

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

static const char  rcsid[] = "$Id: BdbCondRemoteAccessor.cc,v 1.11 2002/06/21 18:49:55 ryd Exp $";

// --------------------
// -- Static methods --
// --------------------

// ------------------
// -- Constructors --
// ------------------

BdbCondRemoteAccessor::BdbCondRemoteAccessor( const char* theFacility ) :
    BdbCondAccessor( ),
    _isInitialized(false),
    _taoClient(0),
    _OIDServer(BdbCondRemote::OIDServer::_nil( )),
    _bootFileName( CORBA::string_dup( "" )),
    _facilityName( "" ),
    _serviceName( "" )
{
  // Check the correctness of the facility name.

    if( 0 == theFacility ) {
        ErrMsg(fatal) << "BdbCondRemoteAccessor::BdbCondRemoteAccessor() -- FATAL ERROR IN TEH CONSTRUCTOR." << endl
                      << "    The invalid value has been passed as a parameter." << endmsg;
    }
    _facilityName = string( theFacility );

  // The other components of the name will be initialized later in a special
  // initializer method.
}

// ----------------
// -- Destructor --
// ----------------

BdbCondRemoteAccessor::~BdbCondRemoteAccessor( )
{
  // There is nothing to delete, because:
  //
  //    _taoClient    - is a singleton
  //    _OIDServer    - is an instance of a smart pointer object
  //    _bootFileName - ditto
}

// ----------------
// -- Operations --
// ----------------

BdbStatus
BdbCondRemoteAccessor::findObject( BdbDatabase*          theDatabasePtr,
                                   BdbHandle(BdbObject)& theObjectH,        
                                   const char*           theContainerName,  
                                   const BdbTime&        theTime )
{
  // NOTE: all external comunications of this method go via
  //       its caller for the following two purposes:
  //
  //         - stay in the correct context;
  //         - provide the consistent change in the caller's context.

    assert( 0 != theDatabasePtr );
    assert( 0 != theContainerName );

    BdbStatus status;

    theObjectH = 0;

  // Make sure the connection is initialized.

    if( ! initialize( )) return BdbcError;

  // Find an appropriate interval.

    BdbHandle(BdbInterval) BdbIntervalH;
    status = theDatabasePtr->findInterval( BdbIntervalH,
                                           theContainerName,
                                           theTime );
    if (( BdbcSuccess != status ) || BdbIsNull(BdbIntervalH)) {
        return BdbcError;
    }

  // Get an object from the interval.

    theObjectH = BdbIntervalH->getObject( );

    return BdbcSuccess;
}

BdbStatus
BdbCondRemoteAccessor::findObject( BdbDatabase*          theDatabasePtr,
                                   BdbHandle(BdbObject)& theObjectH,
                                   BdbIntervalBase&      theIntervalBase,
                                   BdbTime&              theVersionTime,
                                   const char*           theContainerName,
                                   const BdbTime&        theTime )
{
  // NOTE: Unlike its more primitive version which does not provide the validity
  //       period for the found object, this method directly obtains all its information 
  //       from a remote server including the complete context of BdbDatabase class.
  //
  //       Then the caller's context is updated from the obtained one.

    const char* errorString = "BdbCondRemoteAccessor::findObject() -- ERROR.";

    assert( 0 != theDatabasePtr );
    assert( 0 != theContainerName );

    BdbStatus status;

    theObjectH = 0;

    theIntervalBase.setBeginTime( BdbTime::minusInfinity );
    theIntervalBase.setEndTime  ( BdbTime::plusInfinity );

    theVersionTime = BdbTime::minusInfinity;

  // Make sure the connection is initialized.

    if( ! initialize( )) return BdbcError;

  // Ask remote server to do this job.

    BdbCondRemote::TimeType theRemoteTime = theTime.getGmtSec( );

    CORBA::Environment        theEnv;
    BdbCondRemote::StatusType theStatus;

    BdbCondRemote::OIDServer::ContextType_var   theContextVar;
    BdbCondRemote::OIDServer::ObjectContextType theObjectContext;
    BdbCondRemote::OIDServer_ptr                theNextServer;

    theStatus = _OIDServer->findObject( _bootFileName,
                                        theDatabasePtr->subsystemTLA( ),
                                        theContainerName,
                                        theRemoteTime,
                                        theContextVar,
                                        theObjectContext,
                                        theNextServer,
                                        theEnv );
    if( theEnv.exception( ) != 0 ) {
        ErrMsg(error) << errorString << endl
                      << "    Can not find desired object in this container due to" << endl
                      << "    exception occured while communicating with remote server." << endl
                      << "        DETECTOR ->  " << theDatabasePtr->subsystemTLA( ) << endl
                      << "        CONTAINER -> " << theContainerName << endmsg;
        return BdbcError;
    }
    if( BdbCondRemote::StatusSuccess != theStatus ) {
        ErrMsg(error) << errorString << endl
                      << "    Can not find desired object in this container due to" << endl
                      << "    error status returned by the remote server." << endl
                      << "        DETECTOR ->  " << theDatabasePtr->subsystemTLA( ) << endl
                      << "        CONTAINER -> " << theContainerName << endmsg;
        return BdbcError;
    }

  // Translate obtained results into the local data structures. Then update
  // the context of the caller.

    translateResult( theDatabasePtr,
                     theContainerName,
                     theObjectH,
                     theIntervalBase,
                     theVersionTime,
                     *(theContextVar.ptr( )),
                     theObjectContext );

  // Switch to another server if a non-null pointer was returned
  // and return resulting status.

    return switchServer( theNextServer );
}

BdbStatus
BdbCondRemoteAccessor::findInterval( BdbDatabase*            theDatabasePtr,
                                     BdbHandle(BdbInterval)& theIntervalH,
                                     const char*             theContainerName,
                                     const BdbTime&          theTime )
{
  // NOTE: This method obtains all its information from a remote server
  //       including the complete context of BdbDatabase class.
  //
  //       Then the caller's context is updated from the obtained one.

    const char* errorString = "BdbCondRemoteAccessor::findInterval() -- ERROR.";

    BdbStatus status;

    assert( 0 != theDatabasePtr );
    assert( 0 != theContainerName );

    theIntervalH = 0;

  // Make sure the connection is initialized.

    if( ! initialize( )) return BdbcError;

  // Ask remote server to do this job.

    BdbCondRemote::TimeType theRemoteTime = theTime.getGmtSec( );

    CORBA::Environment        theEnv;
    BdbCondRemote::StatusType theStatus;

    BdbCondRemote::OIDServer::ContextType_var theContextVar;
    BdbCondRemote::OIDServer_ptr              theNextServer;

    theStatus = _OIDServer->findInterval( _bootFileName,
                                          theDatabasePtr->subsystemTLA( ),
                                          theContainerName,
                                          theRemoteTime,
                                          theContextVar,
                                          theNextServer,
                                          theEnv );
    if( theEnv.exception( ) != 0 ) {
        ErrMsg(error) << errorString << endl
                      << "    Can not find desired interval in this container due to" << endl
                      << "    exception occured while communicating with remote server." << endl
                      << "        DETECTOR ->  " << theDatabasePtr->subsystemTLA( ) << endl
                      << "        CONTAINER -> " << theContainerName << endmsg;
        return BdbcError;
    }
    if( BdbCondRemote::StatusSuccess != theStatus ) {
        ErrMsg(error) << errorString << endl
                      << "    Can not find desired interval in this container due to" << endl
                      << "    error status returned by the remote server." << endl
                      << "        DETECTOR ->  " << theDatabasePtr->subsystemTLA( ) << endl
                      << "        CONTAINER -> " << theContainerName << endmsg;
        return BdbcError;
    }

  // Translate obtained results into the local data structures. Then update
  // the context of the caller.

    translateResult( theDatabasePtr,
                     theContainerName,
                     theIntervalH,
                     *(theContextVar.ptr( )));

  // Switch to another server if a non-null pointer was returned
  // and return resulting status.

    return switchServer( theNextServer );
}

BdbStatus
BdbCondRemoteAccessor::firstInterval( BdbDatabase*            theDatabasePtr,
                                      BdbHandle(BdbInterval)& theIntervalH,
                                      const char*             theContainerName )
{
  // NOTE: This method obtains all its information from a remote server
  //       including the complete context of BdbDatabase class.
  //
  //       Then the caller's context is updated from the obtained one.

    const char* errorString = "BdbCondRemoteAccessor::firstInterval() -- ERROR.";

    BdbStatus status;

    assert( 0 != theDatabasePtr );
    assert( 0 != theContainerName );

    theIntervalH = 0;

  // Make sure the connection is initialized.

    if( ! initialize( )) return BdbcError;

  // Ask remote server to do this job.

    CORBA::Environment        theEnv;
    BdbCondRemote::StatusType theStatus;

    BdbCondRemote::OIDServer::ContextType_var theContextVar;
    BdbCondRemote::OIDServer_ptr              theNextServer;

    theStatus = _OIDServer->firstInterval( _bootFileName,
                                           theDatabasePtr->subsystemTLA( ),
                                           theContainerName,
                                           theContextVar,
                                           theNextServer,
                                           theEnv );
    if( theEnv.exception( ) != 0 ) {
        ErrMsg(error) << errorString << endl
                      << "    Can not find the FIRST interval in this container due to" << endl
                      << "    exception occured while communicating with remote server." << endl
                      << "        DETECTOR ->  " << theDatabasePtr->subsystemTLA( ) << endl
                      << "        CONTAINER -> " << theContainerName << endmsg;
        return BdbcError;
    }
    if( BdbCondRemote::StatusSuccess != theStatus ) {
        ErrMsg(error) << errorString << endl
                      << "    Can not find the FIRST interval in this container due to" << endl
                      << "    error status returned by the remote server." << endl
                      << "        DETECTOR ->  " << theDatabasePtr->subsystemTLA( ) << endl
                      << "        CONTAINER -> " << theContainerName << endmsg;
        return BdbcError;
    }

  // Translate obtained results into the local data structures. Then update
  // the context of the caller.

    translateResult( theDatabasePtr,
                     theContainerName,
                     theIntervalH,
                     *(theContextVar.ptr( )));

  // Switch to another server if a non-null pointer was returned
  // and return resulting status.

    return switchServer( theNextServer );
}

BdbStatus
BdbCondRemoteAccessor::lastInterval(  BdbDatabase*            theDatabasePtr,
                                      BdbHandle(BdbInterval)& theIntervalH,
                                      const char*             theContainerName )
{
  // NOTE: This method obtains all its information from a remote server
  //       including the complete context of BdbDatabase class.
  //
  //       Then the caller's context is updated from the obtained one.

    const char* errorString = "BdbCondRemoteAccessor::lastInterval() -- ERROR.";

    BdbStatus status;

    assert( 0 != theDatabasePtr );
    assert( 0 != theContainerName );

    theIntervalH = 0;

  // Make sure the connection is initialized.

    if( ! initialize( )) return BdbcError;

  // Ask remote server to do this job.

    CORBA::Environment        theEnv;
    BdbCondRemote::StatusType theStatus;

    BdbCondRemote::OIDServer::ContextType_var theContextVar;
    BdbCondRemote::OIDServer_ptr              theNextServer;

    theStatus = _OIDServer->lastInterval( _bootFileName,
                                          theDatabasePtr->subsystemTLA( ),
                                          theContainerName,
                                          theContextVar,
                                          theNextServer,
                                          theEnv );
    if( theEnv.exception( ) != 0 ) {
        ErrMsg(error) << errorString << endl
                      << "    Can not find the LAST interval in this container due to" << endl
                      << "    exception occured while communicating with remote server." << endl
                      << "        DETECTOR ->  " << theDatabasePtr->subsystemTLA( ) << endl
                      << "        CONTAINER -> " << theContainerName << endmsg;
        return BdbcError;
    }
    if( BdbCondRemote::StatusSuccess != theStatus ) {
        ErrMsg(error) << errorString << endl
                      << "    Can not find the LAST interval in this container due to" << endl
                      << "    error status returned by the remote server." << endl
                      << "        DETECTOR ->  " << theDatabasePtr->subsystemTLA( ) << endl
                      << "        CONTAINER -> " << theContainerName << endmsg;
        return BdbcError;
    }

  // Translate obtained results into the local data structures. Then update
  // the context of the caller.

    translateResult( theDatabasePtr,
                     theContainerName,
                     theIntervalH,
                     *(theContextVar.ptr( )));

  // Switch to another server if a non-null pointer was returned
  // and return resulting status.

    return switchServer( theNextServer );
}

void
BdbCondRemoteAccessor::reset( )
{
  // The basic idea of this method is to clear a context associated with
  // this brand of the accessor.
  //
  // In the current implementation this method tells a remote server
  // to commit the currently held transaction if any.

    const char* errorString = "BdbCondRemoteAccessor::reset() -- ERROR.";

  // Make sure the connection is initialized.

    if( ! initialize( )) return;

  // Ask remote server to do this job.

    CORBA::Boolean            theTransactionWasOpen;
    CORBA::Environment        theEnv;
    BdbCondRemote::StatusType theStatus;

    theStatus = _OIDServer->commitTransaction( theTransactionWasOpen,
                                               theEnv );
    if( theEnv.exception( ) != 0 ) {
        ErrMsg(error) << errorString << endl
                      << "    Can not tell the remote server to commit current transaction due to" << endl
                      << "    exception occured while communicating with remote server." << endmsg;
        return;
    }
    if( BdbCondRemote::StatusSuccess != theStatus ) {
        ErrMsg(error) << errorString << endl
                      << "    Can not tell the remote server to commit current transaction due to" << endl
                      << "    error status returned by the remote server." << endmsg;
        return;
    }

    return;
}

// -------------
// -- Helpers --
// -------------

bool
BdbCondRemoteAccessor::initialize( )
{
    const char* errorString = "BdbCondRemoteAccessor::initialize() -- ERROR.";

  // Proceed only if the initialization has not beed done.

    if( _isInitialized ) return true;

  // Build the BOOT file name for more efficient operations.

    _bootFileName = CORBA::string_dup( BdbConditions::instance( )->bootName( ));

  // Use BOOT file name to locate the Name Service directory
  // where the service corresponding to the current federation.
  //
  // NOTE: that we relace all '/' by '\' in a service name in order to not
  //       confuse the binder at TaoTools/TaoServer class.

    _serviceName = string( BdbConditions::instance( )->bootName( ));

    size_t bytes = _serviceName.length( );
    for( size_t i = 0; i < bytes; i++ ) {
        if( '/' == _serviceName[i] ) _serviceName[i] = '\\';
    }

  // Get a TAO Client object which would serve an interface between
  // us and CORBA.

    _taoClient = TaoClient::getTaoClient( );
    if( 0 == _taoClient ) {
        ErrMsg(error) << errorString << endl
                      << "    Failed to obtain a TAO Client object." << endmsg;
        return false;
    }

  // Get initial object references for OID server via the Name Service.

    CORBA::Object_var theObj;

    theObj = _taoClient->getObject( _facilityName.c_str(),
                                    _serviceName.c_str() );
    if( CORBA::is_nil( theObj )) {
        ErrMsg(error) << errorString << endl
                      << "Failed to obtain an initial object reference through the Naming Service:" << endl
                      << "    FACILITY: " << _facilityName << endl
                      << "    SERVICE:  " << _serviceName << endl
                      << endmsg;
        return false;
    }

    _OIDServer = BdbCondRemote::OIDServer::_narrow( theObj );
    if( CORBA::is_nil( _OIDServer.in( ))) {
        ErrMsg(error) << errorString << endl
                      << "Failed to narrow the object reference into BdbCondRemote::OIDServer." << endl
                      << endmsg;
    }

  // Get the final server reference.

    CORBA::Environment theEnv;

    _OIDServer = _OIDServer->getServer( theEnv );
    if( theEnv.exception( ) != 0 ) {
        ErrMsg(error) << errorString << endl
                      << "    Can not obtain the final object reference through the initial one due to" << endl
                      << "    exception occured while communicating with remote server." << endmsg;
        return false;
    }
    if( CORBA::is_nil( _OIDServer.in( ))) {
        ErrMsg(error) << errorString << endl
                      << "Failed to obtain the final object reference through the initial one:" << endl
                      << "    FACILITY: " << _facilityName << endl
                      << "    SERVICE:  " << _serviceName << endl
                      << endmsg;
        return false;
    }

  // Ok. We have done it.

    _isInitialized = true;

    return true;
}

BdbStatus
BdbCondRemoteAccessor::switchServer( BdbCondRemote::OIDServer_ptr theNextServer )
{
    const char* errorString = "BdbCondRemoteAccessor::switchServer() -- ERROR.";

  // NOTE: We are doing the "narrowing" since it makes a copy of this object
  //       in the current virtual space. This will also establish a connection
  //       with the remote server.

    if( ! CORBA::is_nil( theNextServer )) {

        _OIDServer = BdbCondRemote::OIDServer::_narrow( theNextServer );
        if( CORBA::is_nil( _OIDServer.in( ))) {
            ErrMsg(error) << errorString << endl
                          << "Failed to narrow the new server reference into BdbCondRemote::OIDServer." << endl
                          << endmsg;
            return BdbcError;
        }
    }
    return BdbcSuccess;
}

void
BdbCondRemoteAccessor::translateResult( BdbDatabase*                                 theDatabasePtr,
                                        const char*                                  theContainerName,
                                        BdbHandle(BdbInterval)&                      theIntervalH,
                                        const BdbCondRemote::OIDServer::ContextType& theContext )
{
  // Translate results.

    toHandle( theContext.intervalOID, theIntervalH );

    BdbHandle(BdbDBObj) theIntervalDBH;
    toHandle( theContext.intervalDbOID, theIntervalDBH );

    BdbHandle(BdbContObj) theIntervalContH;
    toHandle( theContext.intervalContOID, theIntervalContH );

    BdbHandle(BdbCondRegistry) theRegistryH;
    toHandle( theContext.registryOID, theRegistryH );

    BdbHandle(BdbCondRevision) theBaselineRevisionH;
    toHandle( theContext.baselineRevisionOID, theBaselineRevisionH );

    BdbHandle(BdbCondRevision) theReviseAfterStoreRevisionH;
    toHandle( theContext.reviseAfterStoreRevisionOID, theReviseAfterStoreRevisionH );

    BdbHandle(BdbCondHistory) theHistoryH;
    toHandle( theContext.historyOID, theHistoryH );

    bool isLink        = theContext.isLink;
    bool isWriteLocked = theContext.isWriteLocked;

    BdbCondContainerLink link( theContext.symbLink.originName,
                               theContext.symbLink.detectorName,
                               theContext.symbLink.containerName );

    BdbHandle(BdbDBObj) theLinkDBH;
    toHandle( theContext.theLinkDbOID, theLinkDBH );

    BdbHandle(BdbContObj) theLinkContH;
    toHandle( theContext.theLinkContOID, theLinkContH );

  // Update the caller's context using the obtained results.

    theDatabasePtr->setCache( theContainerName,
                              theIntervalDBH,
                              theIntervalContH,
                              theRegistryH,
                              theBaselineRevisionH,
                              theReviseAfterStoreRevisionH,
                              theHistoryH,
                              isLink,
                              isWriteLocked,
                              link,
                              theLinkDBH,
                              theLinkContH );
}

void
BdbCondRemoteAccessor::translateResult( BdbDatabase*                                       theDatabasePtr,
                                        const char*                                        theContainerName,
                                        BdbHandle(BdbObject)&                              theObjectH,
                                        BdbIntervalBase&                                   theIntervalBase,
                                        BdbTime&                                           theVersionTime,
                                        const BdbCondRemote::OIDServer::ContextType&       theContext,
                                        const BdbCondRemote::OIDServer::ObjectContextType& theObjectContext )
{
  // Translate results.

    toHandle( theObjectContext.objectOID, theObjectH );

    theIntervalBase.setBeginTime( BdbTime( theObjectContext.beginTime ));
    theIntervalBase.setEndTime  ( BdbTime( theObjectContext.endTime ));

    theVersionTime=BdbTime( theObjectContext.versionTime.sec,
                            theObjectContext.versionTime.nsec );

    BdbHandle(BdbInterval) theIntervalH;
    toHandle( theContext.intervalOID, theIntervalH );

    BdbHandle(BdbDBObj) theIntervalDBH;
    toHandle( theContext.intervalDbOID, theIntervalDBH );

    BdbHandle(BdbContObj) theIntervalContH;
    toHandle( theContext.intervalContOID, theIntervalContH );

    BdbHandle(BdbCondRegistry) theRegistryH;
    toHandle( theContext.registryOID, theRegistryH );

    BdbHandle(BdbCondRevision) theBaselineRevisionH;
    toHandle( theContext.baselineRevisionOID, theBaselineRevisionH );

    BdbHandle(BdbCondRevision) theReviseAfterStoreRevisionH;
    toHandle( theContext.reviseAfterStoreRevisionOID, theReviseAfterStoreRevisionH );

    BdbHandle(BdbCondHistory) theHistoryH;
    toHandle( theContext.historyOID, theHistoryH );

    bool isLink        = theContext.isLink;
    bool isWriteLocked = theContext.isWriteLocked;

    BdbCondContainerLink link( theContext.symbLink.originName,
                               theContext.symbLink.detectorName,
                               theContext.symbLink.containerName );

    BdbHandle(BdbDBObj) theLinkDBH;
    toHandle( theContext.theLinkDbOID, theLinkDBH );

    BdbHandle(BdbContObj) theLinkContH;
    toHandle( theContext.theLinkContOID, theLinkContH );

  // Update the caller's context using the obtained results.
  //
  // NOTE: We do this operation in two steps: (1) the cache of the base class,
  //       (2) the cache of the subclass because the subclass's cache will be
  //       reset by the step 1.

    theDatabasePtr->setCache( theContainerName,
                              theIntervalDBH,
                              theIntervalContH,
                              theRegistryH,
                              theBaselineRevisionH,
                              theReviseAfterStoreRevisionH,
                              theHistoryH,
                              isLink,
                              isWriteLocked,
                              link,
                              theLinkDBH,
                              theLinkContH );

    theDatabasePtr->setIntervalCache( theIntervalH );
}

void
BdbCondRemoteAccessor::toHandle( const BdbCondRemote::OIDServer::OIDType& theOID,
                                 BdbHandle(BdbPersObj)&                   thePersObjH )
{
    BdbRef(BdbPersObj) thePersObjRef;

    thePersObjRef.set_DB( theOID.database );
    thePersObjRef.set_OC( theOID.container );
    thePersObjRef.set_page( theOID.page );
    thePersObjRef.set_slot( theOID.slot );

    thePersObjH = thePersObjRef;
}

void
BdbCondRemoteAccessor::toHandle( const BdbCondRemote::OIDServer::OIDType& theOID,
                                 BdbHandle(BdbObject)&                    theObjectH )
{
    BdbRef(BdbObject) theObjectRef;

    theObjectRef.set_DB( theOID.database );
    theObjectRef.set_OC( theOID.container );
    theObjectRef.set_page( theOID.page );
    theObjectRef.set_slot( theOID.slot );

    theObjectH = theObjectRef;
}

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

 

---

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

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