CDF KITS Project:/ include/ TrackingObjects/ Storable/ CdfTrackView.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 ]

 //============================================================================
 // CdfTrackView.hh
 // ---------------
 // Collection of references to CdfTrack objects that can be stored and 
 // retrieved from the event record. The collection uses the ConstStrViewVector
 // class, and provides direct access to the underlying container, 
 // std::vector< CdfTrack_clnk >, where CdfTrack_clnk is a typedef to 
 // ConstStrRefVectorLink<CdfTrackColl,CdfTrack>. The view is a sub-class
 // of StorableObject, and can therefore be appended to the event record,
 // and stored and restored from a data file. The view, unlike the CdfTrackColl,
 // does not own tracks -- it just points to them.
 // 
 // The references in the view (the CdfTrack_clnk objects) behave like 
 // pointers for most purposes:
 //
 //      Given a CdfTrack_clnk, 'link':
 //      1)  *link returns CdfTrack &
 //      2)  link-> allows access to methods of CdfTrack
 //      3)  if ( link )  return true if the link is non-null, and false if null
 //
 // Since a  CdfTrack_clnk is a small object and simple to initialize, creating
 // a view is very fast. The view is therefore ideal for holding the result
 // of track selection or sorting operations. 
 //
 // To add a track to the view, one must add a properly initialized
 // link object to the underlying vector. The typedef 'CdfTrack_clnk' has 
 // been provided in CdfTrack.hh to simplify this task. Note that a link
 // must be initialized with a link to the CdfTrackColl in which the track 
 // lives (see note on backward compatibility):
 //
 //   Let 'pColl' = CdfTrackColl *, and 'pView' = CdfTrackView *. Then:
 //
 //      CdfTrackColl::collection_type & tracks = pColl->contents();
 //      CdfTrackView::collection_type & view = pView->contents();       
 //      for ( int i = 0 ; i < tracks.size() ; ++i )
 //      {
 //        view.push_back(  CdfTrack_clnk( Link<CdfTrackColl>(pColl), i )  );
 //      }
 //
 // In most cases, a CdfTrack_clnk will already be available, so that 
 // 'view.push_back( link )' will work. See the header file for 
 // ConstStrRefVectorLink for alternative constructors.
 //
 // Several constructors have been provided to simplify the task of adding
 // tracks subject to an arbitrary filter function. The standard library 
 // algorithms can also be used for this purpose.
 //
 // Standard views
 // --------------
 // There are currently two static functions that apply pre-defined 
 // selection criteria to the tracks in the event, and return a view filled
 // with only those tracks. The selection is defined by the tracking group, 
 // and cannot be altered except as provided by the tracking group.
 // The functions include:
 //
 // 1) CdfTrackView::allTracks( CdfTrackView_h & handle, 
 //                             const std::string & procName)
 //  
 //    Fill a view with all tracks in the event record that belong to a 
 //    CdfTrackColl with the process name 'procName'. A null string
 //    matches all process names. The default is a null string.
 //
 // 2) CdfTrackView::defTracks( CdfTrackView_h & handle,
 //                             const std::string & procName )
 //
 //    Fill a view with all tracks in the event that (a) pass the default
 //    track selection, and (b) belong to a CdfTrackColl with the process
 //    name 'procName'. A null string matches all process names. The 
 //    default process name is "PROD". 
 //
 // 3) CdfTrackView::defTracksUnCut( CdfTrackView_h & handle,
 //                             const std::string & procName )
 //
 //    Fill a view with all tracks in the event that (a) pass the default
 //    track selection, and (b) belong to a CdfTrackColl with the process
 //    name 'procName'. A null string matches all process names. The 
 //    default process name is "PROD". 
 //
 //    An error is returned if no collections with the specified process
 //    name are found, if the appropriate track collection is not found
 //    among those with the correct process name, or if more than one
 //    "appropriate" collection is found. In the last case, all tracks
 //    from the matching collections will be included in the output view.
 //
 // 4) CdfTrackView::defTracksL3( CdfTrackView_h & handle,
 //                             const std::string & procName )
 //
 //    Fill a view with all tracks in the event that (a) pass the l3 default
 //    track selection(COT parents are taken instead of OI children, and 
 //    (b) belong to a CdfTrackColl with the process
 //    name 'procName'. A null string matches all process names. The 
 //    default process name is "PROD". 
 //
 //    An error is returned if no collections with the specified process
 //    name are found, if the appropriate track collection is not found
 //    among those with the correct process name, or if more than one
 //    "appropriate" collection is found. In the last case, all tracks
 //    from the matching collections will be included in the output view.
 //
 // Another static function, CdfTrackView::selectTracks, fills a view
 // with all tracks that pass a user-specified selector, and that live in a 
 // CdfTrackColl that passes a separate user-specified selector.
 //
 // Note that all three of the above functions, allTracks, defTracks and 
 // selectTracks, work correctly regardless of whether the view handle points 
 // to a pre-existing view or is null. In the former case, the functions clear
 // the view and fill it with the result. In the latter case, the functions
 // will create a new view, fill it with the results and set the description 
 // string (allTracks and defTracks only) to a standard value.
 //
 // Note on backwards compatibility
 // -------------------------------
 // The view will work normally for tracks created prior to V4.1.0 of
 // cdfsoft2 (i.e., CdfTracks that are derived from StorableObject and
 // that live in the event record), provided that the tracks are referenced
 // by a CdfTrackColl, and the links in the view are initialized as specified 
 // above. 
 // 
 // For backward compatibility, the view can also be used for tracks for which
 // no reference to a CdfTrackColl is available. (This information is not
 // always available for tracks treated as StorableObjects.) Such a view 
 // cannot be saved and restored in the event record, and cannot simultaneously 
 // contain fully initialized links. 
 //
 // Author:
 // R. Snider
 // 12-Nov-1999
 // Aug-2001: (RS) Re-written to accommodate streamable CdfTrack
 //============================================================================
 #ifndef CDFTRACKVIEW_HH_
 #define CDFTRACKVIEW_HH_ 1
 
 #include <algorithm>
 #include <iosfwd>
 #include <string>
 #include <vector>
 
 #include "Edm/ConstHandle.hh"
 #include "Edm/ConstLink.hh"
 #include "Edm/StorableObject.hh"
 #include "StorableContainers/ConstStrViewVector.hh"
 #include "StorableContainers/ViewVector.hh"
 #include "TrackingObjects/Storable/CdfTrackColl.hh"
 #include "TrackingObjects/Tracks/CdfTrack.hh"
 #include "TrackingObjects/Tracks/track_cut.hh"
 
 //=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=
 // Forward declarations
 //=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=
 
 class CdfTrack;
 // class CdfTrackColl;
 class CdfTrackViewNtuplizer;
 class CdfTrackIdManager;
 class EventRecord;
 class StorableSiClusterData;
 class TBuffer;
 
 //=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=
 // Global typedefs for EDM handles
 //=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=
 
 class CdfTrackView;
 typedef Handle<CdfTrackView>         CdfTrackView_h;
 typedef ConstHandle<CdfTrackView>    CdfTrackView_ch;
 
 //=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=
 // Class definition
 //=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=
 
 class CdfTrackView : 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 CdfTrackView* clone(void); // Pseudo-constructor
 
 public:
 
   //--------------------------------------------------------------------------
   // Typedefs
   //--------------------------------------------------------------------------
   
   typedef CdfTrack_clnk                                 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;
   
   //--------------------------------------------------------------------------
   // Functions to retrieve views from the event, or create standard views
   //--------------------------------------------------------------------------
   
   enum Error
   {
     OK,
     
     //  Returned by 'find' methods
     //
     VIEW_NOT_FOUND,
     
     // Returned by allTracks, defTracks, defTrackUnCut, defTracksL3
     //
     PROC_NAME_NOT_FOUND,        // No CdfTrackColl's with requested process name
     
     // Returned by defTracks and defTracksUnCut:
     //   No global tracking results found (=> collections with the process
     //   name were found, but none with the results needed by defTracks)
     //
     GLOB_TRKNG_NOT_FOUND,
     //
     //   More than one collection with the appropriate global tracking
     //   results was found. 
     //
     MULTIPLE_COLL_FOUND,
     
     // Returned by selectTracks
     //
     MATCHING_COLL_NOT_FOUND
     
   };
   
   static Error find( CdfTrackView_ch & viewHandle );
   static Error find( CdfTrackView_ch & viewHandle,
                      const StorableObject::Selector & selector ); 
   
   // Find a view identified by a description string
   //
   static Error find( CdfTrackView_ch & viewHandle, std::string description );
   
   // Description strings used by standard views:
   //
   static const std::string ALL_TRACK_DESCR;     // allTracks
   static const std::string DEF_TRACK_DESCR;     // defTracks
   static const std::string DEF_TRACK_UNCUT_DESCR;       // defTracksUnCut
   static const std::string DEF_TRACK_L3_DESCR;  // defTracksL3
  
   // Standard views:
   //   NOTE:  a view passed into these functions will be cleared
   //          and filled with the result. If no view is assigned 
   //          to the handle argument, the functions will create a new 
   //          view and assign a standard description string to it.
   // 
   static Error allTracks( CdfTrackView_h & viewHandle, 
                           const std::string & processName = "" );
   static Error defTracks( CdfTrackView_h & viewHandle, 
                           const std::string & processName = "PROD" );
   static Error defTracksUnCut( CdfTrackView_h & viewHandle, 
                           const std::string & processName = "PROD" );
   static Error defTracksL3( CdfTrackView_h & viewHandle, 
                           const std::string & processName = "PROD" );
                           
   // Select tracks with independent selectors for the CdfTrackColl's
   // scanned, and for the tracks within the collection.
   //   NOTE:  same as note for allTracks and defTracks, except that
   //          no description string is ever assigned.
   //
   template<class TrackSelector>
   static Error selectTracks( CdfTrackView_h & viewHandle,
                              const StorableObject::Selector & collSelector =
                                    StorableObject::SelectAll(),
                              const TrackSelector & trackSelector =
                                    track_cut::SelectAll() );
                            
   //--------------------------------------------------------------------------
   // Constructors, assignment
   //--------------------------------------------------------------------------
   
   CdfTrackView();
   CdfTrackView( const CdfTrackView & view );
   
   // Copy from 'first' to 'last'. Iterators assumed to point
   // to  CdfTrack_lnk
   //
 #ifndef __CINT__
   CdfTrackView( const_iterator first, const_iterator last );
   CdfTrackView( const ConstLink<CdfTrackColl> & sourceColl,
                 CdfTrackColl::const_iterator first,
                 CdfTrackColl::const_iterator last );
 #endif // !__CINT__  
   
 #ifndef __CINT__
   // Copy from 'first' to 'last' subject to some
   // selection cut. 
   //
   template<class CdfTrackCut>
   CdfTrackView( const_iterator first, const_iterator last, 
                 CdfTrackCut selector );
   
   template<class CdfTrackCut>
   CdfTrackView( const ConstLink<CdfTrackColl> & collLink,
                 CdfTrackColl::const_iterator first,
                 CdfTrackColl::const_iterator last,
                 CdfTrackCut selector );
 #endif // !__CINT__  
 
   CdfTrackView & operator = ( const CdfTrackView & view );
 
   //--------------------------------------------------------------------------
   // Access to the underlying set of tracks.
   //--------------------------------------------------------------------------
   
   // Non-const access
   collection_type & contents();
   
   // Const access
   const collection_type & contents() const;
 
   // Construct track ID lookup table. 
   //   Fills 'vector<int> & table' such that
   //   table[id] = index into vector returned by 'contents()' for 
   //               the track with ID = 'id' (i.e., 
   //               view.contents()[table[id]] = CdfTrack_clnk & for the
   //               desired track)
   //             = -1 if no track in the view has the specified ID
   //   Note that the user must guard against out-of-range ID's
   //
   void idLookupTable( std::vector<int> & table ) 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
   //  
   virtual bool postread( EventRecord * pRecord );
   // Streamer declared in ClassDef macro:
   // virtual void Streamer( TBuffer & iobuffer );
   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( CdfTrackViewNtuplizer * pNtuplizer );
   virtual void ntuplize() const;
 
 
 protected:
 
   virtual ~CdfTrackView();
   
 private:
 
   //--------------------------------------------------------------------------
   // Private utilities
   //
   void _fillViewFromTemp();
   bool _checkAndFillTempFromView();
   
   //--------------------------------------------------------------------------
   // Private data
   //--------------------------------------------------------------------------
 
   // Data stored in persistent representation
   //
   ConstStrViewVector<CdfTrackColl,CdfTrack> _trackView;
   ViewVector<CdfTrack>                      _tempTrackView;
   
   // The streamer version used to read this instance
   // => need to write accordingly:
   //    1:  view read in uses Link<CdfTrack>
   //    2:  view read in uses ConstStrRefVectorLink<CdfTrackColl,CdfTrack>
   //
   Version_t                                 _readStreamerVersion;
   
   // If true, check view for storage mode, and fill temp if needed.
   // Allowed storage modes:
   // 1) All links in view point to a collection
   //    => stream normally, do not fill temp
   // 2) No links in view point to a collection and all tracks
   //    in the view are stored in the event
   //    => fill and stream the temp
   // Illegal storage mode:
   // 3) Some links in view point to tracks stored in the event, but not
   //    to a collection, while others point to tracks not stored in 
   //    the event
   // So, if one links does not point at a collection, then all links
   // must point to tracks stored in the event.
   //
   bool _checkStorageMode;
 
   // For n-tuplizing
   //
   static CdfTrackViewNtuplizer * _pNtuplizer;
 
 
 
   //--------------------------------------------------------------------------
   // Root I/O hooks. 
   // ClassDef macro defined in root/include/Rtypes.h
   //  
   ClassDef( CdfTrackView, 2 )   // class name, current version
   //
   //--------------------------------------------------------------------------
 
 };
 
 inline ostream & operator << ( std::ostream & os, 
                                const CdfTrackView & trackSet );
 
 #ifndef __CINT__
 #include "TrackingObjects/Storable/CdfTrackView.icc"
 #endif // !__CINT__
 
 #endif // CDFTRACKCOLL_HH_
 

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