//_HADES_CLASS_DESCRIPTION
/////////////////////////////////////////////////////////////////////////////
// HParticleEvtInfoFiller
//
// Reconstructor calculates detector hit multiplicity, track (hparticlecand)
// multiplicity and raction plane informations for each event.
// At the moment Forward Wall and Reaction Plane information is not calculated.
//
// These variables are stored in the HParticleEvtInfo output category.
//
////////////////////////////////////////////////////////////////////////////

#include "TString.h"
#include "TIterator.h"
#include "TArrayI.h"

#include "hparticleevtinfo.h"
#include "hparticleevtinfofiller.h"
#include "hcategorymanager.h"

#include "richdef.h"
#include "walldef.h"
#include "tofdef.h"
#include "showerdef.h"
#include "rpcdef.h"
#include "hmdcdef.h"
#include "hmdctrackddef.h"
#include "hgeantdef.h"

#include "hades.h"
#include "hcategory.h"
#include "hevent.h"
#include "hlocation.h"
#include "hlinearcategory.h"

#include "hshowerhitsim.h"
#include "hrichdirclus.h"
#include "hrichhit.h"
#include "hmdcclus.h"
#include "hmdcseg.h"
#include "hparticlecand.h"
#include "htofhit.h"
#include "hrpccluster.h"
#include "hrpchit.h"
#include "hwallhit.h"


ClassImp(HParticleEvtInfoFiller)

    //-----------------------------------------------------------------------------
    HParticleEvtInfoFiller::HParticleEvtInfoFiller() : HReconstructor()
{
    clearMembers();
}


//-----------------------------------------------------------------------------
HParticleEvtInfoFiller::HParticleEvtInfoFiller(const Text_t* name,const Text_t* title)
: HReconstructor(name, title)
{
    clearMembers();
}

HParticleEvtInfoFiller::~HParticleEvtInfoFiller()
{
    delete pWallHitIter;
    delete pRichHitIter;
    delete pRichClusIter;
    delete pMdcClusIter;
    delete pMdcSegIter;
    delete pTofHitIter;
    delete pRpcClusterIter;
    delete pRpcHitIter;
    delete pShowerHitIter;
    delete pParticleCandIter;

    clearMembers();
}
// ---------------------------------------------------------------------------
void HParticleEvtInfoFiller::clearMembers()
{
    zeroLoc.set( 0 );

    pWallHitIter      = 0;
    pRichHitIter      = 0;
    pRichClusIter     = 0;
    pMdcClusIter      = 0;
    pMdcSegIter       = 0;
    pTofHitIter       = 0;
    pRpcClusterIter   = 0;
    pRpcHitIter       = 0;
    pShowerHitIter    = 0;
    pParticleCandIter = 0;


    pParticleEvtInfoCat = 0;
}


// ---------------------------------------------------------------------------
Bool_t HParticleEvtInfoFiller::finalize(void)
{
    return kTRUE;
}


// ---------------------------------------------------------------------------
Bool_t HParticleEvtInfoFiller::init(void)
{
    HCategory* cat   = 0;

    // create iterators to input categories

    Int_t doErrorMessage = 0 ; // 0=warning, 1=Error , -1 silent

    cat = HCategoryManager::getCategory(catWallHit     ,doErrorMessage,"catWallHit, from HParticleEvtInfoFiller::init()");
    if (cat) pWallHitIter      = cat->MakeIterator("native");


    cat = HCategoryManager::getCategory(catRichHit     ,doErrorMessage,"catRichHit, from HParticleEvtInfoFiller::init()");
    if (cat) pRichHitIter      = cat->MakeIterator("native");

    cat = HCategoryManager::getCategory(catRichDirClus ,doErrorMessage,"catRichDirClus, from HParticleEvtInfoFiller::init()");
    if (cat) pRichClusIter     = cat->MakeIterator("native");

    cat = HCategoryManager::getCategory(catMdcClus     ,doErrorMessage,"catMdcClus, from HParticleEvtInfoFiller::init()");
    if (cat) pMdcClusIter      = cat->MakeIterator("native");


    cat = HCategoryManager::getCategory(catMdcSeg      ,doErrorMessage,"catMdcSeg, from HParticleEvtInfoFiller::init()");
    if (cat) pMdcSegIter       = cat->MakeIterator("native");

    cat = HCategoryManager::getCategory(catTofHit      ,doErrorMessage,"catTofHit, from HParticleEvtInfoFiller::init()");
    if (cat) pTofHitIter       = cat->MakeIterator("native");

    cat = HCategoryManager::getCategory(catRpcCluster  ,doErrorMessage,"catRpcCluster, from HParticleEvtInfoFiller::init()");
    if (cat)  pRpcClusterIter  = cat->MakeIterator("native");

    cat = HCategoryManager::getCategory(catRpcHit      ,doErrorMessage,"catRpcHit, from HParticleEvtInfoFiller::init()");
    if (cat)  pRpcHitIter  = cat->MakeIterator("native");

    cat = HCategoryManager::getCategory(catParticleCand,doErrorMessage,"catParticleCand, from HParticleEvtInfoFiller::init()");
    if (cat) pParticleCandIter = cat->MakeIterator("native");

    cat = HCategoryManager::getCategory(catShowerHit,doErrorMessage,"catShowerHit, from HParticleEvtInfoFiller::init()");
    if (cat) pShowerHitIter  = cat->MakeIterator("native");

    // make output category
    pParticleEvtInfoCat = HCategoryManager::getCategory(catParticleEvtInfo,-1,"catParticleEvtInfo" );
    if(!pParticleEvtInfoCat) pParticleEvtInfoCat = HCategoryManager::addCategory(catParticleEvtInfo,"HParticleEvtInfo",1,"Particle");

    if(!pParticleEvtInfoCat) {
	Error( "init", "Cannot make catParticleEvtInfo category" );
	return kFALSE;
    }

    return kTRUE;
}


// ---------------------------------------------------------------------------
Int_t HParticleEvtInfoFiller::execute(void)
{
    HWallHit           *wall_hit         = 0;
    HRichHit           *rich_hit         = 0;
    HRichDirClus       *rich_clus        = 0;
    HMdcClus           *mdc_clus         = 0;
    HMdcSeg            *mdc_seg          = 0;
    HShowerHit         *shower_hit       = 0;
    HTofHit            *tof_hit          = 0;
    HRpcCluster        *rpc_cluster      = 0;
    HRpcHit            *rpc_hit          = 0;
    HParticleCand      *particle_cand    = 0;
    HParticleEvtInfo   *pParticleEvtInfo = 0;

    Int_t wall_hits                                     = 0;
    Int_t rings                                         = 0;
    Int_t rich_rings             [MAXSECTOR]            = { 0 };
    Int_t rich_corr_rings        [MAXSECTOR]            = { 0 };
    Int_t rich_clusters          [MAXSECTOR]            = { 0 };
    Int_t mdc_clusters           [MAXSECTOR][MAXIOSEG]  = { { 0 }, { 0 } };
    Int_t mdc_segments_fitted    [MAXSECTOR][MAXIOSEG]  = { { 0 }, { 0 } };
    Int_t mdc_segments_unfitted  [MAXSECTOR][MAXIOSEG]  = { { 0 }, { 0 } };
    Int_t tof_hits               [MAXSECTOR]            = { 0 };
    Int_t rpc_clst               [MAXSECTOR]            = { 0 };
    Int_t rpc_hits               [MAXSECTOR]            = { 0 };
    Int_t shower_hits            [MAXSECTOR]            = { 0 };
    Int_t particle_cands         [MAXSECTOR]            = { 0 };
    Int_t selected_particle_cands[MAXSECTOR]            = { 0 };

    TArrayI  pUsedRichHit;
    Int_t    idxRich;

    // fill counters
    if (pWallHitIter) {
	pWallHitIter->Reset();
	while ((wall_hit = (HWallHit*)pWallHitIter->Next())) { ++ wall_hits; }
    }

    if (pRichHitIter) {
	pRichHitIter->Reset();
	while ((rich_hit = (HRichHit*)pRichHitIter->Next())) {
	    ++ rings;
	    ++ rich_rings[rich_hit->getSector()];
	}
    }

    if (pRichClusIter) {
	pRichClusIter->Reset();
	while ((rich_clus = (HRichDirClus*)pRichClusIter->Next())){
	    ++ rich_clusters[rich_clus->getSector()];
	}
    }

    if (pMdcClusIter) {
	pMdcClusIter->Reset();
	while ((mdc_clus = (HMdcClus*)pMdcClusIter->Next())) {
	    ++ mdc_clusters[mdc_clus->getSec()][mdc_clus->getIOSeg()];
	}
    }

    if (pMdcSegIter) {
	pMdcSegIter->Reset();
	while ((mdc_seg = (HMdcSeg*)pMdcSegIter->Next())) {
	    if (mdc_seg->getChi2() == -1) ++ mdc_segments_unfitted[mdc_seg->getSec()][mdc_seg->getIOSeg()];
	    else	                  ++ mdc_segments_fitted  [mdc_seg->getSec()][mdc_seg->getIOSeg()];
	}
    }

    if (pTofHitIter) {
	pTofHitIter->Reset();
	while ((tof_hit = (HTofHit*)pTofHitIter->Next())) {
	    ++ tof_hits[(Int_t)tof_hit->getSector()];
	}
    }

    if (pRpcClusterIter) {
	pRpcClusterIter->Reset();
	while ((rpc_cluster = (HRpcCluster*)pRpcClusterIter->Next())) {
	    ++ rpc_clst[(Int_t)rpc_cluster->getSector()];
	}
    }

    if (pRpcHitIter) {
	pRpcHitIter->Reset();
	while ((rpc_hit = (HRpcHit*)pRpcHitIter->Next())) {
	    ++ rpc_hits[(Int_t)rpc_hit->getSector()];
	}
    }

    if (pShowerHitIter) {
	pShowerHitIter->Reset();
	while ((shower_hit = (HShowerHit*) pShowerHitIter->Next())) {
	    if(shower_hit->getModule() == 0) ++ shower_hits[(Int_t)shower_hit->getSector()];
	}
    }

    pUsedRichHit.Set(rings);
    pUsedRichHit.Reset();

    if (pParticleCandIter)
    {
	pParticleCandIter->Reset();
	while ((particle_cand = (HParticleCand*)pParticleCandIter->Next()))
	{
	    ++ particle_cands[particle_cand->getSector()];
	    if(particle_cand->isFlagBit(Particle::kIsUsed))
	    {
		++ selected_particle_cands[particle_cand->getSector()];
	    }
	    if ( (idxRich = particle_cand->getRichInd()) > -1 &&
		 (particle_cand->getRingCorr() == Particle::kIsRICHRK || particle_cand->getRingCorr() == (Particle::kIsRICHRK|Particle::kIsRICHMDC) )  &&
		pUsedRichHit.At(idxRich) == 0 )
	    {
		pUsedRichHit.AddAt(1, idxRich);
		++ rich_corr_rings[particle_cand->getSector()];
	    }
	}
    }


    // fill output category
    Int_t index = -1;
    if((pParticleEvtInfo = HCategoryManager::newObject(pParticleEvtInfo,pParticleEvtInfoCat,index)) != 0 )
    {
	pParticleEvtInfo = new (pParticleEvtInfo) HParticleEvtInfo;
	pParticleEvtInfo->setFWallMult               ( wall_hits );
	pParticleEvtInfo->setRichMult                ( rich_rings );
	pParticleEvtInfo->setRichCorrMult            ( rich_corr_rings );
	pParticleEvtInfo->setRichClusMult            ( rich_clusters );
	pParticleEvtInfo->setTofMult                 ( tof_hits );
	pParticleEvtInfo->setRpcMult                 ( rpc_clst );
	pParticleEvtInfo->setRpcMultHit              ( rpc_hits );
	pParticleEvtInfo->setShowerMult              ( shower_hits );
	pParticleEvtInfo->setParticleCandMult        ( particle_cands );
	pParticleEvtInfo->setSelectedParticleCandMult( selected_particle_cands );
	pParticleEvtInfo->setMdcClusMult             ( mdc_clusters );
	pParticleEvtInfo->setMdcSegFittedMult        ( mdc_segments_fitted );
	pParticleEvtInfo->setMdcSegUnfittedMult      ( mdc_segments_unfitted );
    }
    else
    {
	Error( "execute", "Couldn't get a new slot from 'catParticleEvtInfo'!" );
	exit( 2 );
    }

    return 0;
}