HPartialEvent

class HPartialEvent : public HEvent

    public:

                         HPartialEvent()
                         HPartialEvent(const Text_t* aName, const Text_t* aTitle, Cat_t aBaseCat)
                         HPartialEvent(const HPartialEvent&)
                         ~HPartialEvent()
            virtual void activateBranch(TTree* tree, Int_t splitLevel)
                    void addCategory(Cat_t aCat, HCategory* category)
          virtual Bool_t addCategory(Cat_t aCat, HCategory* cat, Option_t* opt)
            virtual void Browse(TBrowser* b)
          static TClass* Class()
            virtual void Clear(Option_t* opt)
            virtual void clearAll(Int_t level)
                   Cat_t getBaseCat()
              TObjArray* getCategories()
      virtual HCategory* getCategory(Cat_t aCat)
                   Int_t getRecLevel()
                TObject* getSubHeader()
                  Bool_t hasExpandedStreamer()
         virtual TClass* IsA() const
                  Bool_t isEmpty()
          virtual Bool_t IsFolder() const
            virtual void makeBranch(TBranch* parent)
          HPartialEvent& operator=(const HPartialEvent&)
          virtual Bool_t removeCategory(Cat_t aCat)
                    void setExpandedStreamer(Bool_t t)
                    void setPersistency(Bool_t fPersistency)
                    void setRecLevel(Int_t aRecLevel)
                    void setSubHeader(TObject* header)
            virtual void ShowMembers(TMemberInspector& insp, char* parent)
            virtual void Streamer(TBuffer& b)
                    void StreamerNVirtual(TBuffer& b)

Data Members

    protected:

           Int_t fRecLevel      Reconstruction level of the event
           Cat_t fBaseCategory  Identifier for the first category stored in this partial event
        TObject* fHeader        Sub event's header.
      TObjArray* fCategories    ! Categories 

Class Description

HPartialEvent 

   Each partial events holds the data (i.e. the HDataObjects) corresponding
 to each main detection system; like Mdcs, Rich...

   These data in a partial event are organized in categories, which stand
 for the different types of data in the partial event. For example, in the
 partial event for the Mdcs there will be a category holding the objects with
 raw data (i.e. the objects instatiating a HMdcRaw). So conceptually the
 categories are "kind of data" and they hold the objects of a particular
 kind (instatiating a particular class).

   The categories are the responsible of giving access to the objects they
 hold (see HCategory), but a partial event must also allow the user to
 access the data stored into it; that's done using the function getCategory()
 which returns a particular category, so the user can ask that category for
 the data object he wants. For example, let's say we have a HLocation object
 loc pointing to any location, and a HPartialEvent par with the Mdc's data;
 if we want to get the raw data object pointed by loc we should use:

    par->getCategory(catMdcRaw)->getObject(loc);

    And this function will return the pursued data object.

Default constructor

Allocates a new HPartial event with name aName and title aTitle

 aBaseCat is the identifier of the lower category that will be stored in
 this partial event, for example: if the user wants to allocate a partial
 event holding the Mdc data, then aBaseCat should be: catMdc; which is a
 constant defined in HadDef.h

Clears the event

 Activates those branches in the TTree tree whose names are equal to those
of the branches that would be generated with the current event structure if
the function makeBranch() is called, being the split level=splitLevel

 This way if we have a TTree with a lot of branches and we only need some
of them to fill data in the event structure we are using at a given moment,
then we only activate those branches and the others are not read

 Makes branches for each category in the partial event and for the split
tree, then those branches are added to the list of subbranches of "parent"

 This method is called by Hades::makeTree()

 Adds the category "cat", identified by "aCat" to the partial event.

 Adds the category "category", which is identified by aCat, to the partial
event

 Before using this function the user should setup the HCategory "category"

Removes the category aCat from this partial event and deletes it.

 Returns an array with all the categories held by this event

 To add categories to the partial event use HPartialEvent::addCategory()

 Returns a pointer to the category identified by "aCat"

 Clears the partial event,i.e. deletes all objects in the partial event
but keeping its structure.

 After the reconstruction of each event, the HEvent::Clear function must
be called in order to make place for the new data.

See HEvent

 Sets the reconstruction level of the event, this is useful to know which
categories in the event are already reconstructed.

 Returns the reconstruction level of the partial event.

 Method used to browse a partial event with a Root browser.

 This function will be called by a Root browser, not by the user

 Stream an object of class HPartialEvent.

Inline Functions

                 Cat_t getBaseCat()
                  void setSubHeader(TObject* header)
              TObject* getSubHeader()
                Bool_t isEmpty()
                Bool_t IsFolder() const
                  void setExpandedStreamer(Bool_t t)
                Bool_t hasExpandedStreamer()
               TClass* Class()
               TClass* IsA() const
                  void ShowMembers(TMemberInspector& insp, char* parent)
                  void StreamerNVirtual(TBuffer& b)
         HPartialEvent HPartialEvent(const HPartialEvent&)
        HPartialEvent& operator=(const HPartialEvent&)