class HParticleTree: public HReconstructor

_HADES_CLASS_DESCRIPTION



 HParticleTree

 Reconstructor to create an filtered root output.
 The output is generated independend for each HParticleTree
 reconstructor and das not affect Hades. The purpose
 is to create different output files with different event
 structure in parallel and allow to reduce the data volume
 for special analysis tasks (for example rare dilepton decays
 in Au+Au collisions).
 The filtering starts from HParticleCand. Only objects
 which are flagged kIsUsed are copied to the output.
 The user can specify selectLeptons() and selectHadrons()
 functions. By default the functions of HParticleTracksorter
 are used (for the documentation of the selection functions see
 HParticleTrackSorter). In addition the user can specify a selectEvent()
 function function which allows to check the full event.

 The program works the following way:

 I.    The original flags of the HParticleCand objects and HParticleSorter
       are backupted. This alows to run the task without affecting other tasks.
 II.   In the input HParticleCand objects are flagged using the user specified
       selection functions or default functions.
 III.  If the user provides a Bool_t selectEvent(TObjArray*) function the
       properties of the full event can be evaluated. If the function returns
       kFALSE an empty event ist stored to preserve the 1 to 1 correlation
       with the dst file.
       With setSkipEmptyEvents (kTRUE) skipping of not selected events can be forced
 III.  From HParticleCand objects which are flagged kIsUsed the selection
       procedure starts. Only flagged objects are considered and the detector
       hits belonging to the candidates are stored in the output too if enabled.
       With setSkipTracks(kFALSE) all tracks will forced to the output.
       HParticleEvtInfo, HStart2Cal, HStartHit and HWallHit are fully copied
       if enabled (see list below).
       Alternatively (not at the same time!) to using flagged candidates as
       selection the user can provide a function to select the kept particles by
       setUserkeepTrack(Bool_t (*function)(HParticleCand* )). The function
       has to return kTRUE for selected candidates.
       All indices are resorted. The new event will look like the old one,
       but containing only "good" candidates. The full features of the analysis
       of the DSTs are preserved.

       SUPPORTED CATEGORIES:

       catParticleCand
       catParticleMdc           (extracted from HParticleCand only)
       catParticleEvtInfo       (fullcopy only)
       catStart2Hit             (fullcopy only)
       catStart2Cal             (fullcopy only)
       catTBoxChan              (fullcopy only)
       catWallHit               (fullcopy only)
       catWallEventPlane        (fullcopy only)
       catPionTrackerRaw        (fullcopy only)
       catPionTrackerCal        (fullcopy only)
       catPionTrackerHit        (fullcopy only)
       catPionTrackerTrack      (fullcopy only)
       catTofHit                (fullcopy or extracted from HParticleCand)
       catTofCluster            (fullcopy or extracted from HParticleCand)
       catRpcCluster            (fullcopy or extracted from HParticleCand)
       catShowerHit             (fullcopy or extracted from HParticleCand)
       catEmcCluster            (fullcopy only)
       catEmcCal                (fullcopy only)
       catRichHit               (fullcopy or extracted from HParticleCand)
       catRichDirClus           (fullcopy only)
       catRichCal               (fullcopy only)
       catMdcSeg                (extracted from HParticleCand only)
       catMdcHit                (extracted from HParticleCand only)
       catMdcCal1               (extracted from HParticleCand only)
       catMdcClus               (extracted from HParticleCand only)
       catMdcClusInf            (extracted from HParticleCand only)
       catMdcClusFit            (extracted from HParticleCand only)
       catMdcWireFit            (extracted from HParticleCand only)
       catGeantKine             (fullcopy only)
       catMdcGeantRaw           (fullcopy only)
       catTofGeantRaw           (fullcopy only)
       catRpcGeantRaw           (fullcopy only)
       catShowerGeantRaw        (fullcopy only)
       catEmcGeantRaw           (fullcopy only)
       catWallGeantRaw          (fullcopy only)
       catRichGeantRaw (+1,+2)  (fullcopy only)


 create output:
 by
 1. set outputfilename       ( full name including path, dir or suffix not used)
 2. by hades output name     ( dir / file stem + suffix + _cyclecount.root)
 3. by datasource input name ( dir / file stem + suffix + _cyclecount.root)

 Example: Filter dilepton events :

 I.   use the standard selectLeptons() from HParticleTrackSorter
 II.  ignore hadrons : take simple user defined function below
 III. select events which have at least 1 positron and 1 electron candidate
 IV.  create the event structure you need

  //------------------------------------------------------
  Bool_t selectLeptons(HParticleCand* pcand){

    //  selection function for lepton candidates.
    Bool_t select = kFALSE;
    if(pcand->isFlagAND(5,
			Particle::kIsAcceptedHitRICH,
			Particle::kIsAcceptedHitInnerMDC,
			Particle::kIsAcceptedHitOuterMDC,
			Particle::kIsAcceptedHitMETA,
			Particle::kIsAcceptedRK)
       &&
       pcand->getInnerSegmentChi2() > 0
       &&
       pcand->getChi2() < 1000
       &&
       pcand->getBeta() > 0.9
    ) select = kTRUE;

   return select;
  }
  //------------------------------------------------------
  //------------------------------------------------------
  Bool_t selectNoHadron(HParticleCand*){
      // do not use this selection
      return kFALSE;
  }

  //------------------------------------------------------
  Bool_t selectEvent(TObjArray* ar){
    // select events which have at least
    // one lepton canddate pair . TObjArray* can
    // be used to pas parameters into the function

    HCategory* catCand = gHades->getCurrentEvent()->getCategory(catParticleCand);
    if(catCand){
    Int_t n=catCand->getEntries();
    HParticleCand* cand=0;
    Int_t nEle = 0;
    Int_t nPos = 0;
        for(Int_t i = 0; i < n; i ++){
    	cand = HCategoryManager::getObject(cand,catCand,i);
    	if(cand){
    	    if(cand->isFlagBit(kIsLepton)){
    		if      (cand->getCharge() == -1 ) nEle++;
    		else if (cand->getCharge() ==  1 ) nPos++;
    	    }
    	}
        }
        if( (nPos < 1 && nEle < 2) || (nPos < 2 && nEle < 1) ) return kFALSE; // accept 2likesign or 1 unlikesign pair
     } else return kFALSE;
     return kTRUE;
  }
  //------------------------------------------------------

  HParticleTree* parttree = new HParticleTree("leptontree","leptontree");
  // 1. set outputfilename       ( full name including path, dir or suffix not used)
  // 2. by hades output name     ( dir / file stem + suffix + _cyclecount.root)
  // 3. by datasource input name ( dir / file stem + suffix + _cyclecount.root)

  // case 1:
  // parttree->setOutputFile ("/lustre/hades/filter_tree.root","Filter","RECREATE",2 ); // set outfile by hand
  // case 2+3:
  partree->setOutputFileSuffix("filter_tree"); // take outfile name from Hades output or data input and add _filter_tree at the end
  parttree->setOutputDir("/lustre/hades");     // take outfile name from Hades output or data input and change the dir

  parttree->setSkipEmptyEvents(kTRUE);   (default kFALSE)
  parttree->setSkipTracks(kTRUE);        (default kTRUE)

  //-------CONFIGURE HParticleTrackSorter-----------------
  parttree->setIgnoreRICH         (kTRUE);
  parttree->setIgnoreInnerMDC     (kTRUE);
  parttree->setIgnoreOuterMDC     (kTRUE);
  parttree->setIgnoreMETA         (kTRUE);
  parttree->setIgnorePreviousIndex(kTRUE);
  parttree->setRICHMatching(Particle::kUseRKRICHWindowSorter, 4.); // matching type and window
  //------------------------------------------------------

  //-------CONFIGURE EventStructure-----------------------
  Cat_t PersistentCat[] = {
    catParticleCand,
    catParticleMdc,
    catParticleEvtInfo,
    catStart2Hit,
    catStart2Cal,
    catTBoxChan,
    catWallHit,
    catPionTrackerTrack,
    //catPionTrackerRaw,
    //catPionTrackerCal,
    //catPionTrackerHit,
    //-----------------------------
    // NO OPTION FULL COPY : ONLY OBJECTS USED BY HParticleCand WILL BE COPIED!
    // IF YOU WANT A FULL COPY SET THE FULL COPY IN ADDIION!
    //catTofHit,
    //catTofCluster,
    //catRpcCluster,
    //catEmcCluster,
    //catShowerHit,
    //catRichHit,
    //-----------------------------
    catEmcCluster,
    //catRichDirClus,
    //catRichCal,
    //catMdcSeg,
    //catMdcHit,
    //catMdcCal1,
    //catMdcClus,
    //catMdcClusInf,
    //catMdcClusFit,
    //catMdcWireFit
    //-----------------------------
    // GEANT
    //catGeantKine,
    //catMdcGeantRaw,
    //catTofGeantRaw,
    //catRpcGeantRaw,
    //catShowerGeantRaw,
    //catEmcGeantRaw,
    //catWallGeantRaw,
    //catRichGeantRaw,
    //catRichGeantRaw+1,
    //catRichGeantRaw+2,
    //catEmcGeantRaw,
    //catStartGeantRaw
    //-----------------------------
   };

  // list of categories which should be fully copied
  // (only these contained in HParticleCand as Hit Index)

    //-----------------------------
    // OPTION FULL COPY : ONLY FOR OBJECTS USED BY HParticleCand!
    // IF THE CAT IS SELECTED ALREADY, YOU CAN SWITCH IT TO FULL COPY HERE!
    Cat_t PersistentCatFullCopy[] = {
    //catTofHit,
    //catTofCluster,
    //catRpcCluster,
    //catShowerHit,
    //catRichHit
   };
    //-----------------------------

  parttree->setEventStructure(sizeof(PersistentCat)        /sizeof(Cat_t),PersistentCat,kFALSE); // filter these cats
  parttree->setEventStructure(sizeof(PersistentCatFullCopy)/sizeof(Cat_t),PersistentCat,kTRUE);  // copy these cats witt all entries
  //------------------------------------------------------
  //-------CONFIGURE SELECTIONS-----------------------
  parttree->setUserSelectionLeptons(selectLeptons);   // use own lepton selector
  parttree->setUserSelectionHadrons(selectNoHadron); // use only standard leptons from HParticlesorter
  parttree->setUserSelectionEvent(selectEvent,NULL); // no params used
  //------------------------------------------------------