class HLoop: public TObject

_HADES_CLASS_DESCRIPTION


 HLoop is a helper class to allow for fast looping of HADES dsts.
 The categories are maped directly from the Tree and allow partical
 reading to speed up. If Hades object exists, the current event structure
 will be replaced by the one defined by HLoop. If Hades not exists, it
 can be created by HLoop constructor. The Hades eventstructure is important
 if one wants to access the data via gHades->getCurrentEvent()->getCategory(cattype)
 or implicit by Classes like HParticleTrackSorter. See the example below for
 further explanation.



    HEventHeader* getEventHeader()  // retrieve the pointer to the HADES HEventHeader
    TTree*        getTree       ()  // retrieve the pointer to the HADES tree
    TChain*       getChain      ()  // retrieve TChain pointer
    Long64_t      getEntries    ()  // get Number of events in the chain


 example:

 #include "hloop.h"
 #include "hcategory.h"
 #include "hzip.h"
 #include "heventheader.h"
 #include "hgeantmedia.h"
 #include "hparticlecand.h"
 #include "hparticletracksorter.h"

 #include "TIterator.h"

 #include <iostream>
 using namespace std;
 void myLoop()
 {

    //---------------LOOP CONFIG----------------------------------------------------------------
    Bool_t createHades = kTRUE;  // kTRUE = create HADES new
    HLoop* loop = new HLoop(createHades); // create HADES (needed if one wants to use gHades)
    loop.setTreeCacheSize(8000000);//8MB (default is 8MB, values <= 0 will disable the cache)
    //--------------------------------------------------------------------------------------------
    loop->readSectorFileList("selection.list",kFALSE,kTRUE);  // hldname_without_evtbuilder 1 1 1 1 1 1
                                                              // a map of all files to active sector is filled
                                                              // see functions HLoop::getSectors(Int_t*), Bool_t HLoop::goodSector(Int_t sector),HSectorSelector& getSectorSelector()
                                                              // for file format description see HSectorSelector
                                                              // parmeters: default value for files not inside the list (kTRUE all sectors on, kFALSE all sectors off)
                                                              //            print the filelist during read
                                                              // If no list is read, all sectors are on by default
                                                              // reading the files list is optional
                                                              // lines which uses the feature are marked ##SECTOR_SELECTION## in the following example
    //--------------------------------------------------------------------------------------------

    // add files : Input sources may be combined
    loop->addFile ("myFile1.root");
    loop->addFile ("myFile2.root");  // ....
    loop->addFilesList("list.txt");  // add all files in ascii file list. list contains 1 root file per line (including path)
    loop->addFiles("myFiles*.root"); // add all files matching this expression
    loop->addMultFiles("file1.root,file2.root,file3.root");  add files as comma separated list
    HZip::makeChain("all_files.zip",loop->getChain()); // add all root files contained in zip file (this file has to be produced by hzip)

    if(!loop->setInput("-*,+HParticleCand")) // global disable "-*" has to be first in the list
    {                                        // read only one category from file (HEventHeader is allways on)
        exit(1);
    }
    loop->printCategories(); // print status from all categories in event
    //------------------------------------------------------------------------------------------

    TIterator* iterCand = 0;
    if (loop->getCategory("HParticleCand")) iterCand = loop->getCategory("HParticleCand")->MakeIterator();
    HEventHeader* header = loop->getEventHeader();
    HGeantMedia* media = loop->getGeantMedia();
    if(media){  // NULL for real data or if not in sim input
       media->print();
    }

    //--------------------------CONFIGURATION---------------------------------------------------
    //At begin of the program (outside the event loop)

    HParticleTrackSorter sorter;
    //sorter.setDebug();                                            // for debug
    //sorter.setPrintLevel(3);                                      // max prints
    //sorter.setRICHMatching(HParticleTrackSorter::kUseRKRICHWindow,4.); // select matching RICH-MDC for selectLeptons() function
    //sorter.setUseYMatching(kTRUE);                                // use meta cell build in select functions
    //sorter.setMetaBoundary(3.);                                   // match in 3 mm to meta cell
    //sorter.setUseBeta(kTRUE);                                     // require beta >0 in build in select functions
    //sorter.setBetaLeptonCut(0.9);                                 // lower beta cut for lepton select
    //sorter.setUseFakeRejection(kTRUE);                            // reject fakes in  build in select functions (default kTRUE)
    //sorter.setIgnoreInnerMDC();                                   // do not reject Double_t inner MDC hits
    //sorter.setIgnoreOuterMDC();                                   // do not reject Double_t outer MDC hits
    //sorter.setIgnoreMETA();                                       // do not reject Double_t META hits
    //sorter.setIgnorePreviousIndex();                              // do not reject indices from previous selctions
    sorter.init();                                                  // get catgegory pointers etc...
    //--------------------------------------------------------------------------------------------
    Int_t nFile = 0;

    //--------------------------------------------------------------------------------------------
    ##SECTOR_SELECTION##
    Int_t sectors[6];  // array of active sector  (1 active, 0 off) will be retrive inside loop for each event
    //--------------------------------------------------------------------------------------------

    for (Int_t i = 0; i < 10; i++) {
        if(loop->nextEvent(i) <= 0) break;  // get next event. categories will be cleared before
                                            // if 0 (entry not found) or -1 (Io error) is returned stop the loop
        //--------------------------------------------------------------------------------------------
        ##SECTOR_SELECTION##
        loop->getSectors(sectors);  // get active sectors for current event (somethime arrays are useful)
        //--------------------------------------------------------------------------------------------

        cout<<i<<"----------------------------------- "<<endl;
        cout<<"sequence Nr = "<<header->getEventSeqNumber()<<endl; // retrieve full header infos
        TString filename;
        if(loop->isNewFile(filename)){ // new file opened from chain ?
            cout<<"new File found "<<filename.Data()<<endl;
            nFile++;
	  }

        sorter.cleanUp();
        sorter.resetFlags(kTRUE,kTRUE,kTRUE,kTRUE);     // reset all flags for flags (0-28) ,reject,used,lepton
        Int_t nCandLep     = sorter.fill(HParticleTrackSorter::selectLeptons);   // fill only good leptons
        Int_t nCandLepBest = sorter.selectBest(HParticleTrackSorter::kIsBestRKRKMETA,HParticleTrackSorter::kIsLepton);
        Int_t nCandHad     = sorter.fill(HParticleTrackSorter::selectHadrons);   // fill only good hadrons (already marked good leptons will be skipped)
        Int_t nCandHadBest = sorter.selectBest(HParticleTrackSorter::kIsBestRKRKMETA,HParticleTrackSorter::kIsHadron);

        if(iterCand){
           iterCand->Reset();

           HParticleCand* cand;
           while ( (cand = (HParticleCand*)iterCand->Next()) != 0 ){
              // do some work  ....
              //--------------------------------------------------------------------------------------------
              ##SECTOR_SELECTION##
              if(!loop->goodSector(cand->getSector())) continue;  // skipp all candidates from inactive sectors
              //--------------------------------------------------------------------------------------------
          }
       }
    }
    sorter.finalize(); // clean up stuff

   if(createHades) delete gHades; // delete Hades or call destructor of HLoop.
 }



 A second example running a task with hloop.
 The task can use parameter containers if HSpectrometer
 and parameterio are specified. The task will be executed
 inside nextEvent() function.

 void hloopDst()
{
    Bool_t createHades=kTRUE;
    HLoop* loop = new HLoop(createHades);  // kTRUE : create Hades  (needed to work with standard eventstructure)
    loop.setTreeCacheSize(8000000);//8MB (default is 8MB, values <= 0 will disable the cache)

    TString asciiParFile = "/misc/kempter/projects/plot_dedx/param_31oct11.txt";
    TString rootParFile = "";

    Int_t mdcMods[6][4]={
	{0,0,0,0},
	{0,0,0,0},
	{1,1,1,1},
	{0,0,0,0},
	{1,1,1,1},
	{1,1,1,1} };

    HDst::setupSpectrometer    ("aug11_3sec",mdcMods,"rich,mdc,tof,rpc,shower,wall,tbox,start");
    HDst::setupParameterSources("ascii,oracle",asciiParFile,rootParFile,"now");

    loop->addFile("be1122719211201.hld_dst_aug11.root");

    if(!loop->setInput("")) { exit(1); } // read all categories

    HEventHeader* header = loop->getEventHeader();
    HGeantMedia* media   = loop->getGeantMedia();    // NULL if not in input file ()
    if(media){ // NULL if not in input file
        media->print();
    }


    loop->printCategories();
    loop->printChain();

    HTaskSet *masterTaskSet = gHades->getTaskSet("real");
    masterTaskSet->add(new HMdcPlotDeDx()); // some task derived from HReconstructor

    HCategory* catCand = HCategoryManager::getCategory(catParticleCand);
    if(!catCand) { exit(1); }

    Int_t entries=loop->getEntries();
    for (Int_t i=0; i < entries; i++) {
	Int_t nbytes =  loop->nextEvent(i);            // get next event. categories will be cleared before
	if(nbytes <= 0) { cout<<nbytes<<endl; break; } // last event reached

	if(catCand){
	    HParticleCand* cand=0;
	    for(Int_t j=0; j<catCand->getEntries();j++){
		cand = HCategoryManager::getObject(cand,catCand,j);
                // do something  ....
	    } // end loop cand
	} //catCand

    }// end event loop
    if(gHades)gHades->finalizeTasks();
    if(createHades) delete gHades; // delete Hades or call destructor of HLoop.
}