CDF KITS Project:/ include/ TrackingObjects/ Storable/ CdfTrackColl.hh		[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ]
	Architecture: [ i386 ] Version: [ 4.10.4 ] [ 4.10.5 ] [ 4.8.4 ] [ 4.8.4l3s ] [ 4.8.5 ] [ 4.9.0 ] [ 4.9.1 ] [ 4.9.1.hpt3 ] [ 4.9.1hpt3 ] [ 4.9.1top1 ] [ 5.0.0 ] [ 5.1.0 ] [ 5.1.0beamonly ] [ 5.1.1 ] [ 5.2.0 ] [ 5.3.0 ] [ 5.3.1 ] [ 5.3.1dsp ] [ 5.3.3 ] [ 5.3.3_nt ] [ 5.3.4 ] [ 6.1.1 ] [ 6.1.1b ] [ 6.1.2 ] [ 6.1.3 ] [ 6.1.4 ] [ 6.1.4int3 ] [ 6.1.4mc ] [ 6.1.4mc_a ] [ 6.1.6 ] [ development ]

 //============================================================================
 // CdfTrackColl.hh
 // ---------------
 // Collection of CdfTrack objects that can be stored and retrieved from the 
 // event record. The collection uses the RefVector class from the CDF Event
 // Data Model (EDM), and therefore provides direct access to the underlying 
 // container, std::vector< CdfTrack_lnk >. Tracks are stored by reference
 // in the container, using the  CdfTrack_lnk "smart pointer" class from 
 // the EDM as the reference. (The Link<> behaves like a normal pointer.)
 // The tracks themselves are stored directly in the event, since CdfTrack is
 // a StorableObject, but the collection manages the task of adding the tracks
 // to the event at the appropriate time.
 //
 // NOTE: Under no circumstances should users append to the event record
 //       any track contained in a CdfTrackColl.
 //
 // To add a track to the collection, one must add a properly initialized
 //  CdfTrack_lnk to the underlying vector. The typedef CdfTrack_lnk has 
 // been defined in CdfTrack.hh to facilitate this task:
 //
 //   CdfTrack * pTrack = new CdfTrack;
 //   CdfTrackColl * pColl = new CdfTrackColl;
 //   pColl->contents().push_back( CdfTrack_lnk( pTrack ) );
 //
 // Note that the collection assumes ownership of the CdfTrack upon
 // insertion. See Edm/Link.hh for details of other ways to initialize
 // Link's.
 //
 // NOTE: The user should never delete the pointer to a CdfTrack that 
 //       is contained in a CdfTrackColl.
 //
 // The set also manages track ID numbers: every track added to the set
 // will be assigned an ID value that is unique among all other tracks in all
 // CdfTrackColls ever defined within a particular event. Tracks are
 // automatically assigned ID's by the assignTrackIds() method. This can
 // be called by the user, but is also called by the set immediately prior
 // writing the set to persistent storage. Note that tracks with pre-existing 
 // ID values that were not assigned by the set may result in corrupted, 
 // missing or non-unique ID values. Users should not assign ID's to tracks.
 // 
 //
 // How to use standard algorithms to filter a set of tracks
 // --------------------------------------------------------
 // Since the underlying container is an STL class, the generic algorithms
 // in the standard library can be used to manipulate the contents of the
 // set. A common need is to select a set of tracks satisfying some criterion.
 // Commonly used criteria can be found in TrackingObjects/Tracks/track_cut.hh.
 // Others can be derived from the base class CdfTrackCut in 
 // TrackingObjects/Tracks/CdfTrackCutBase.hh. Note that any class that
 // has a member function 'bool operator () (const  CdfTrack_lnk &)' can be 
 // used as a filter in the generic algorithm. Given such a class Selector, one
 // can find all tracks in the set satisfying Selector( track ) == true 
 // with the following loop:
 //
 //      CdfTrackColl::const_iterator i;
 //      for ( i = find_if( trackSet.contents().begin(),
 //                         trackSet.contents().end(),
 //                         Selector() )
 //            ; i != trackSet.contents().end()
 //            ; i = find_if( ++i, trackSet.contents().end(), Selector() ) )
 //      {
 //        ...
 //      } 
 //
 //
 // Note on constructiong a *new* set for tracks with silicon hits
 // --------------------------------------------------------------
 // Since there are potentially many independent sets of 
 // silicon clusters in an event, the source of silicon hits used for the 
 // tracks in a newly constructed set must be specified before the links 
 // to the silicon hits can be properly written out with the event. 
 // Specify a SiHitSet in the constructor for the track
 // set to establish this source. This is necessary only 
 // if the set is written out, and then only if the silicon hit links are 
 // to be stored. 
 //
 // COT hits are assumed to come from whatever (single) CT_HitSet is in 
 // the event.
 //
 // Author:
 // R. Snider
 //  1-Oct-1999
 // 12-Nov-1999: Design 2.
 //============================================================================
 #ifndef CDFTRACKCOLL_HH_
 #define CDFTRACKCOLL_HH_ 1
 
 #include <algorithm>
 #include <iosfwd>
 #include <string>
 #include <vector>
 
 #include "TrackingObjects/Tracks/CdfTrack.hh"
 #include "Edm/ConstHandle.hh"
 #include "Edm/Link.hh"
 #include "Edm/StorableObject.hh"
 #include "StorableContainers/RefVector.hh"
 #include "StorableContainers/StrRefVector.hh"
 
 //=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=
 // Forward declarations
 //=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=
 
 class CdfTrack;
 class CdfTrackCollNtuplizer;
 class CdfTrackIdManager;
 class EventRecord;
 class SiHitSet;
 class TBuffer;
 
 //=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=
 // Global typedefs for EDM handles
 //=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=
 
 class CdfTrackColl;
 typedef Handle<CdfTrackColl>         CdfTrackColl_h;
 typedef ConstHandle<CdfTrackColl>    CdfTrackColl_ch;
 
 //=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=
 // Class definition
 //=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=
 
 class CdfTrackColl : public StorableObject
 {
 
   // The clone pseudo constructor has been automatically
   // inserted by a batch process.  A unique identifier
   // was not found so it was placed at the very beginning
   // of the class definition.
 
 public:
   virtual CdfTrackColl* clone(void); // Pseudo-constructor
 
 public:
 
   //--------------------------------------------------------------------------
   // Typedefs
   //--------------------------------------------------------------------------
   
   typedef CdfTrack *                                    value_type;
   typedef std::vector<value_type>::iterator             iterator;
   typedef std::vector<value_type>::const_iterator       const_iterator;
   typedef value_type &                                  reference;
   typedef const value_type &                            const_reference;
   typedef value_type *                                  pointer;
   typedef const value_type *                            const_pointer;
   typedef std::vector<value_type>::difference_type      difference_type;
   typedef std::vector<value_type>::size_type            size_type;
   
   typedef std::vector<value_type>                       CollType;
   typedef CollType                                      collection_type;
   
   //--------------------------------------------------------------------------
   // Function to retrieve set from the event
   //--------------------------------------------------------------------------
   
   enum Error
   {
     OK,
     ERROR
   };
   
   static Error find( CdfTrackColl_ch & setHandle );
   static Error find( CdfTrackColl_ch & setHandle,
                      const StorableObject::Selector & selector ); 
   
   //--------------------------------------------------------------------------
   // Constructors
   //--------------------------------------------------------------------------
   
   // Create an empty collection for tracks with NO silicon hits.
   //
   CdfTrackColl();
   
   // Create an empty collection for tracks WITH silicon hits.
   //
   CdfTrackColl( const ConstHandle<SiHitSet> & );
   
   // Copy from 'first' to 'last'. If the tracks are to contain silicon 
   // hits, then a ConstHandle<SiHitSet> must be provided.
   //
   template<class InputIterator>
   CdfTrackColl( InputIterator first, InputIterator last,
                 const ConstHandle<SiHitSet> &  
                       = ConstHandle<SiHitSet>() );
   
   //--------------------------------------------------------------------------
   // Allow owner of track collection to assign ID's to tracks
   //--------------------------------------------------------------------------
   
   void assignTrackIds( EventRecord * pEvent );
   
   //--------------------------------------------------------------------------
   // Access to the underlying set of tracks.
   //--------------------------------------------------------------------------
   
   // Non-const access
   collection_type & contents();
   
   // Const access
   const collection_type & contents() const;
 
   //--------------------------------------------------------------------------
   // EDM:  functions required by StorableObject
   //--------------------------------------------------------------------------
   
   // Classification
   //
   // class_version = current version of this class
   //
   virtual std::string class_name() const ;
   virtual Version_t   class_version() const;
 
   // EDM I/O functions
   //  
   // I/O modes:
   // 1) CdfTrack is a StorableObject:  
   //    Tracks are streamed independently of collection. No compression
   //    possible. Tracks are streamed in and out in exactly the same way,
   //    although the streamer version number will change to the current
   //    version on output.  (Streamer version 1.)
   // 2) CdfTrack is streamable, collection is not compressed: 
   //    Contents of collection are streamed during event I/O. 
   //    (Streamer version 2, isCompressed() = false.)
   // 3) CdfTrack is streamable, collection is compressed.
   //    Only the number of tracks is streamed during event I/O, not any
   //    information contained within the tracks. Transient state
   //    of the collection is restored/compressed during a "puffing"
   //    stage. (Streamer version 2, isCompressed() = true.)
   //
   bool isCompressed() const;
   void setIsCompressed( bool isCompressed ); 
   //
   // Streamer declared in ClassDef macro:
   // virtual void Streamer( TBuffer & iobuffer );
   void ReadVersion1( TBuffer &iobuffer );
   void ReadVersion2( TBuffer &iobuffer );
   void ReadVersion3( TBuffer &iobuffer );
   void WriteVersion1( TBuffer &iobuffer );
   void WriteVersion2( TBuffer &iobuffer );
   void WriteVersion3( TBuffer &iobuffer );
 
   virtual bool postread( EventRecord * pRecord );
   virtual bool prewrite( EventRecord * pRecord );
   
   virtual bool activate( EventRecord * pRecord );
   virtual bool deactivate( EventRecord * pRecord );
 
   // Pseudo-destructors for EDM
   //
   virtual void destroy();
   virtual void deallocate();
   
   // I/O
   //  
   virtual void print( std::ostream & os = std::cout ) const;
 
   //--------------------------------------------------------------------------
   // Ntuplizer methods
   //--------------------------------------------------------------------------
   
   static  void attach_ntuplizer( CdfTrackCollNtuplizer * pNtuplizer );
   virtual void ntuplize() const;
 
 protected:
 
   virtual ~CdfTrackColl();
   
 private:
 
   //--------------------------------------------------------------------------
   // Private utilities
   //--------------------------------------------------------------------------
   
   // Initialize ID manager
   void _initIdManager( EventRecord * pRecord );
   
   // Assign ID's to all tracks in the set
   void _assignId();
   
   // Initialize tracks from the event on first access
   void _initTracks() const;
   void _setHitSets() const;
   void _setMCMatches( EventRecord * pRecord ) const;
   
   //--------------------------------------------------------------------------
   // Private data
   //--------------------------------------------------------------------------
 
   // Data stored in persistent representation
   //
   StrRefVector<CdfTrack>   _trackSet;
   RefVector<CdfTrack>      _tempTrackSet;       // needed for backward compat.
   Link<SiHitSet>           _pHitSet;
   
   // Transient state information
   //
   ConstHandle<CdfTrackIdManager> _pIdManager;
   mutable bool                   _assignIdsOnOutput;    // the set can grow
   
   // _readStreamerVersion:
   // 1 => CdfTrack is StorableObject.
   //      Input via ReadVersion1
   //      Output:
   //        Streamer version set to 2,
   //        _privateStreamerVersion written with value 1,
   //        _isCompressed written with value false,
   //        tracks stored using WriteVersion1.
   // 2 => CdfTrack is Streamable
   //      Input:
   //        If restored _privateStreamerVersion == 1, then:
   //           tracks read using ReadVersion1
   //        If restored _privateStreamerVersion == 2 && restored
   //        _isCompressed == false, then:
   //           tracks read using ReadVersion2
   //        If restored _privateStreamerVersion == 2 && restored
   //        _isCompressed == true, then:
   //           only number of tracks read
   //      Output:
   //        Streamed out in exactly the same way as it was streamed in.
   //
   Version_t     _privateStreamerVersion;
   mutable bool  _isCompressed;
   
   // For n-tuplizing
   //
   static CdfTrackCollNtuplizer * _pNtuplizer;
   
   //--------------------------------------------------------------------------
   // Not implemented
   //
   CdfTrackColl( const CdfTrackColl & );
   CdfTrackColl & operator = ( const CdfTrackColl & );
   //--------------------------------------------------------------------------
   
 
   //--------------------------------------------------------------------------
   // Root I/O hooks. 
   // ClassDef macro defined in root/include/Rtypes.h
   // ClassDef( CdfTrackColl, 1 )        // CdfTracks are StorableObjects
   // 
   // ClassDef( CdfTrackColl, 2 )        // CdfTracks are StreamableObjects
   //
   ClassDef( CdfTrackColl, 3 )   // bug fixes in compressed streaming
   //--------------------------------------------------------------------------
 
 };
 
 inline ostream & operator << ( std::ostream & os, 
                                const CdfTrackColl & trackSet );
 
 #ifndef __CINT__
 #include "TrackingObjects/Storable/CdfTrackColl.icc"
 #endif // !__CINT__
 
 #endif // CDFTRACKCOLL_HH_
 

This page was automatically generated by the LXR engine. The LXR team