#ifndef __HPARTICLESTRUCTS_H__
#define __HPARTICLESTRUCTS_H__


#include "hmetamatch2.h"
#include "htofcluster.h"
#include "htofclustersim.h"
#include "htofhit.h"
#include "htofhitsim.h"
#include "hrpccluster.h"
#include "hrpcclustersim.h"
#include "hshowerhit.h"
#include "hshowerhitsim.h"
#include "hrichhit.h"
#include "hrichhitsim.h"
#include "hmdctrkcand.h"
#include "hmdcseg.h"
#include "hmdcsegsim.h"
#include "hsplinetrack.h"
#include "hrktrackB.h"
#include "hkaltrack.h"
#include "hparticlecand.h"
#include "hparticlecandsim.h"
#include "hgeantkine.h"

#include "hcategory.h"

#include "hparticledef.h"
#include "hparticletool.h"
#include "hcategorymanager.h"
#include "hstltool.h"

#include "TObject.h"

#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <cstdio>

using namespace std;
using namespace Particle;

//---------------------------------------------------------------------------------
// some helper objects
//
//  HParticleCandFiller

class closetrack : public TObject {
public:
    closetrack(){;}
    ~closetrack(){;}
    Int_t ind;        // index of candidate
    Float_t oAngle;   // opening angle to candidate
    void print(Int_t ind=-1){
	printf("index %5i angle %8.5f\n",ind,oAngle);
    }
    ClassDef(closetrack,1)
};

class closeVec : public TObject {
public:
    vector < closetrack > tracks;  // vector of closetrack objects (index,oAngle)

    closeVec(){ ; }
    ~closeVec(){ ; }

    Int_t findTrack(Int_t ind){
	// return -1 if track does not exist, otherwise index
	for(UInt_t i = 0; i < tracks.size(); i++){
	    if((tracks[i].ind) == ind) return i;
	}
	return -1;
    }
    void addTrack(Int_t index,Float_t oAngle){
	// add track if does not exist
	Int_t ind = findTrack(index);
	if( ind < 0){
	    closetrack track;
	    track.ind    = index;
	    track.oAngle = oAngle;
	    tracks.push_back(track);
	}
    }
    void reset(){
	tracks.clear();
    }
    Bool_t static cmpAngle(const closetrack& a,const closetrack& b) { // sort tracks by opening angle
	return a.oAngle < b.oAngle;
    }
    void sortAngle(void) {
	std::sort(tracks.begin(),tracks.end(),closeVec::cmpAngle);
    }
    ClassDef(closeVec,1)
};

class trackinfo : public TObject {
public:
    trackinfo(){;}
    ~trackinfo(){;}
    Int_t tr;         // GEANT tr number
    Int_t n;          // n-times contributing to hit
    Int_t flag;       // flag in which detectors the track has been seen
    Float_t weight;   // weight of tr in hit
    Float_t scale;    // scale the weight by this factor
    Int_t ndet;       // number of detectors for this track
    Int_t isGhostTrack()             { return ((flag&Particle::kIsGhost) > 0)? 1 : 0;}
    Int_t isInDetector(eDetBits det) { return ((flag&det) > 0)? 1 : 0;}
    void print(Int_t ind=-1){
	Int_t prec = cout.precision();
	ios_base::fmtflags flg = cout.flags();
	cout<<"i "     <<setw(3)<<ind
            <<" tr "   <<setw(5)<<tr
            <<" n "    <<setw(3)<<n
            <<" ndet " <<setw(3)<<ndet
            <<" w "    <<fixed<<setw(9)<<weight
            <<" s "    <<fixed<<setw(3)<<setprecision(1)<<scale
            <<" fl "   <<setw(5)<<flag
            <<" R "    <<isInDetector(Particle::kIsInRICH)
	    <<" iM "   <<isInDetector(Particle::kIsInInnerMDC)
	    <<" oM "   <<isInDetector(Particle::kIsInOuterMDC)
	    <<" RPC "  <<isInDetector(Particle::kIsInRPC)
	    <<" S "    <<isInDetector(Particle::kIsInSHOWER)
	    <<" T "    <<isInDetector(Particle::kIsInTOF)
	    <<" iGhost "<<isInDetector(Particle::kIsInnerGhost)
	    <<" oGhost "<<isInDetector(Particle::kIsOuterGhost)
	    <<" Ghost "<<isGhostTrack()<<endl;
	cout.precision(prec);  // set to old precision
        cout.flags(flg);       // set to old format
    }
    ClassDef(trackinfo,1)
};



class tracksVec : public TObject {
public:
    vector < trackinfo* > tracks;  // vector of trackinfo pointer (tr number, n times, flag)
    Float_t sum;                   // sum of n

    tracksVec(){
	sum = 0;
    }
    tracksVec(const tracksVec& v){ // special copy constructor needed because of aliasing
	for(UInt_t i = 0; i < v.tracks.size(); i++){
                tracks.push_back(new trackinfo(*(v.tracks[i]) ));
	}
	sum = v.sum;
    }
    ~tracksVec(){
	reset();
    }
    void reset(){
	for(UInt_t i = 0; i < tracks.size(); i++){
                delete tracks[i];
	}
	tracks.clear();
	sum = 0;
    }
    Int_t findTrack(Int_t tr){
	// return -1 if track does not exist, otherwise index
	for(UInt_t i = 0; i < tracks.size(); i++){
	    if((tracks[i]->tr) == tr) return i;
	}
	return -1;
    }
    void addTrack(Int_t tr,Int_t n, Int_t flag = 0,Float_t scale = 1.){
	// add track if does not exist
	Int_t ind = findTrack(tr);
	if( ind < 0){
	    trackinfo* info = new trackinfo;
	    info->tr     = tr;
	    info->n      = n;
	    info->flag   = flag;
	    info->weight = 0;
	    info->ndet   = 0;
	    info->scale  = scale;
	    sum += n;
	    tracks.push_back(info);
	} else {
	    trackinfo* info = tracks[ind];
	    info->n  += n;
	    sum      += n;
	}
    }
    void calcWeights(void){
	// loop existing tracks and calc n/sum = weight
	if(sum > 0){
	    for(UInt_t i = 0; i < tracks.size(); i ++){
		trackinfo* info = tracks[i];
		info-> weight = (info->n * info->scale) / sum;
	    }
	}
    }
    void addTrackWeight(trackinfo* inf){
	// add track if does not exist
	Int_t ind = findTrack(inf->tr);
	if( ind < 0){
	    trackinfo* info = new trackinfo;
	    info->tr     = inf->tr;
	    info->n      = inf->n;
	    info->flag   = inf->flag;
	    info->weight = inf->weight;
	    info->ndet   = 1;
	    info->scale  = 0;
	    sum += inf->n;
	    tracks.push_back(info);
	} else {
	    trackinfo* info = tracks[ind];
	    info->n      += inf->n;
	    info->flag    = info->flag | inf->flag; // add flag bits
	    info->weight += inf->weight;
	    info->ndet   += 1;
	    sum          += inf->n;
	}
    }
    void addTrackWeight(tracksVec& v){
	// add all tracks if they do not exist
	for(UInt_t i = 0; i < v.tracks.size(); i ++){
	    trackinfo* inf = v.tracks[i];
	    addTrackWeight(inf);
	}
    }
    //-------------------------------------------------------------------
    //  sorting of registered tracks

    //---------------------------------------------------------------
    // tripple sort
    Bool_t static cmpNdetWeightFlag(trackinfo* a, trackinfo* b) { // sort tracks by ndet ,then weight then by flag
	if( a->ndet == b->ndet ) {
	    if( a->weight == b->weight )  return a->flag   > b->flag;
	    else                          return a->weight > b->weight;
	}
	else                              return a->ndet   > b->ndet;
    }
    // double sort
    Bool_t static cmpWeightNdet(trackinfo* a, trackinfo* b) { // sort tracks by weight ,then ndet
	if( a->weight == b->weight ) { return a->ndet > b->ndet; }
	else                           return a->weight > b->weight;
    }
    void sortNdetWeightFlag(void) {
	std::sort(tracks.begin(),tracks.end(),tracksVec::cmpNdetWeightFlag);
    }
    void sortWeightNdet(void) {
	std::sort(tracks.begin(),tracks.end(),tracksVec::cmpWeightNdet);
    }

    void print(){
	cout<<"---------------------------------"<<endl;
	for(UInt_t i = 0; i < tracks.size(); i ++){
	    trackinfo* inf = tracks[i];
	    inf->print(i);
	}

    }
    ClassDef(tracksVec,1)
};


class mdc_trk : public TObject {
public:
    mdc_trk(){;}
    ~mdc_trk(){;}

    Int_t   ind;       // index of HMdcTrkCand
    Float_t dedx;      // Mdc dE/dx for inner + outer segment
    Float_t dedx0;     // Mdc dE/dx for inner segment
    Float_t dedx1;     // Mdc dE/dx for outer segment

    void reset(void){
	ind  = -1;
	dedx = -1;
	dedx0 = -1;
	dedx1 = -1;
    }

    void fillMeta(HMetaMatch2* meta){
	if(meta){
	    ind = meta->getTrkCandInd();
	}
    }
    void fill(HMdcTrkCand* trk){
	if(trk){
	    dedx = trk->getdedxCombinedSeg();
	    dedx0 = trk->getdedxInnerSeg();
	    dedx1 = trk->getdedxOuterSeg();
	}
    }

    ClassDef(mdc_trk,1)
};

class mdc_seg : public TObject {
public:
    mdc_seg(){;}
    ~mdc_seg(){;}

    Int_t   ind;       // index of seg
    Float_t chi2;      // chi2 of segment fitter
    Float_t phi;       // track's phi in cave coordinates (0..360 deg)
    Float_t theta;     // track's theta in cave coordinates (0..90 deg)
    Float_t r;         // distance of closest point to beamline [mm]
    Float_t z;         // z coordinate of closest point to beamline [mm]

    void reset(void){
	ind   = -1;
	chi2  = -1;
	phi   = -1;
	theta = -1;
	r     = -1000;
	z     = -1000;
    }

    void fill(HMdcSeg* seg){
	if(seg){
	    chi2  = seg->getChi2();
	    phi   = HParticleTool::phiSecToLabDeg(seg->getSec(),seg->getPhi());
	    theta = HParticleTool::thetaToLabDeg (seg->getTheta());
	    r     = seg->getR();
	    z     = seg->getZ();
	}
    }
    ClassDef(mdc_seg,1)
};

class rpc_clst : public TObject {
public:
    rpc_clst(){;}
    ~rpc_clst(){;}

    Int_t   ind;       // Index of HRpcCluster object
    Float_t quality;   // Matching quality
    Float_t dx;        // Deviation in X-coordinate
    Float_t dy;        // Deviation in Y-coordinate
    Float_t tof;       // particle time of flight
    Int_t nhits;       // number of cells hit (1 or 2)

    void reset(void){
	ind     = -1;
	quality = -1;
	dx      = -1;
	dy      = -1;
	tof     = -1;
	nhits   = -1;
    }
    void fillMeta(HMetaMatch2* meta,Int_t n = 0){
	if(meta){
	    ind     = meta->getRpcClstInd(n);
	    quality = meta->getRpcClstQuality(n);
	    dx      = meta->getRpcClstDX(n);
	    dy      = meta->getRpcClstDY(n);
	}
    }
    void fill(HRpcCluster* clst){
	if(clst){
	    tof   = clst->getTof();
	    nhits = clst->getClusterType();
	}
    }
    ClassDef(rpc_clst,1)
};


class tof_hit : public TObject {
public:
    tof_hit(){;}
    ~tof_hit(){;}

    Int_t   ind;       // Index of HTofHit object
    Float_t quality;   // Matching quality
    Float_t dx;        // Deviation in X-coordinate
    Float_t dy;        // Deviation in Y-coordinate
    Float_t dedx;      // Tof dE/dx
    Float_t tof;       // particle time of flight

    void reset(void){
	ind     = -1;
	quality = -1;
	dx      = -1;
	dy      = -1;
	dedx    = -1;
	tof     = -1;
    }
    void fillMeta(HMetaMatch2* meta,Int_t n = 0,Int_t hit = 0){
	if(meta){
	    if(hit == kTofClst) {
		ind     = meta->getTofClstInd(n);
		quality = meta->getTofClstQuality(n);
		dx      = meta->getTofClstDX(n);
		dy      = meta->getTofClstDY(n);
	    }
	    else if(hit == kTofHit1) {
		ind     = meta->getTofHit1Ind(n);
		quality = meta->getTofHit1Quality(n);
		dx      = meta->getTofHit1DX(n);
		dy      = meta->getTofHit1DY(n);
	    }
	    else if(hit == kTofHit2){
		ind     = meta->getTofHit2Ind(n);
		quality = meta->getTofHit2Quality(n);
		dx      = meta->getTofHit2DX(n);
		dy      = meta->getTofHit2DY(n);
	    } else {
		std::cout<<"tof_hit:fillMeta(): Illegal hit number!"<<endl;
	    }
	}
    }
    void fill(HTofHit* hit){
	if(hit){
	    dedx = hit->getEdep();
	    tof  = hit->getTof();
	}
    }
    ClassDef(tof_hit,1)
};

class shower_hit : public TObject {
public:
    shower_hit(){;}
    ~shower_hit(){;}

    Int_t   ind;         // Index of HShowerHit object
    Float_t quality;     // Matching quality
    Float_t dx;          // Deviation in X-coordinate
    Float_t dy;          // Deviation in Y-coordinate
    Float_t showerSum0;  // charge sum of PreShower cluster (0)
    Float_t showerSum1;  // charge sum of PreShower cluster (1)
    Float_t showerSum2;  // charge sum of PreShower cluster (2)

    void reset(void){
	ind        = -1;
	quality    = -1;
	dx         = -1;
	dy         = -1;
	showerSum0 = -1;
	showerSum1 = -1;
	showerSum2 = -1;
    }
    void fillMeta(HMetaMatch2* meta,Int_t n = 0){
	if(meta){
	    ind     = meta->getShowerHitInd(n);
	    quality = meta->getShowerHitQuality(n);
	    dx      = meta->getShowerHitDX(n);
	    dy      = meta->getShowerHitDY(n);
	}
    }
    void fill(HShowerHit* hit){
	if(hit){
	    showerSum0 = hit->getSum(0);
	    showerSum1 = hit->getSum(1);
	    showerSum2 = hit->getSum(2);
	}
    }
    ClassDef(shower_hit,1)
};

class rich_hit : public TObject {
public:
    rich_hit(){;}
    ~rich_hit(){;}

    Int_t    ind;           // Index of HRichHit object
    Short_t  numPads;       // number of fired pads typ. (-1 - 100)
    Short_t  amplitude;     // typ. (-1 - 4000)
    Short_t  houTra;        // typ. (-1 - 5000)
    Short_t  patternMatrix; // pattern matrix of ring
    Float_t  centroid;      // ring centroid
    Float_t  phi;           // rich phi   0-360 deg
    Float_t  theta;         // rich theta 0-90 deg

    void reset(void){
	ind           = -1;
	numPads       = -1;
	amplitude     = -1;
	houTra        = -1;
	patternMatrix = -1;
	centroid      = -1;
	phi           = -1;
	theta         = -1;
    }

    void fillMeta(HMetaMatch2* meta,Int_t n = 0){
	if(meta && n > -1){
	    ind = meta->getARichInd(n); // 0 = best match
	}
    }
    void fill(HRichHit* hit){
	if(hit){
	    numPads       = hit->getRingPadNr();
	    amplitude     = hit->getRingAmplitude();
	    houTra        = hit->getRingHouTra();
	    patternMatrix = hit->getRingPatMat();
	    centroid      = hit->getCentroid();
	    phi           = hit->getPhi();
	    theta         = hit->getTheta();
	}
    }
    ClassDef(rich_hit,1)
};

class spline_track : public TObject {
public:
    spline_track(){;}
    ~spline_track(){;}

    Int_t   ind;        // Index of HSplineTrack object
    Float_t p;          // particle's momentum [MeV]

    void reset(void){
	ind = -1;
	p   = -1;
    }
    void fillMeta(HMetaMatch2* meta){
	if(meta){
	    ind = meta->getSplineInd();
	}
    }
    void fill(HSplineTrack* trk){
	if(trk){
	    p = trk->getP();
	}
    }
    ClassDef(spline_track,1)
};



class rk_track : public TObject {
public:
    rk_track(){;}
    ~rk_track(){;}

    //-------------------------------
    // to be set by hand
    Int_t usedMeta;     // see enum selMeta
    Int_t selectTof;    // see enum selMeta
    //-------------------------------
    Int_t   ind;        // Index of HRKBaseTrack object
    Float_t beta;       // particle's beta
    Float_t p;          // particle's momentum [MeV]
    Float_t mass;       // particle's mass [MeV]
    Float_t path;       // length of particle trajetory [mm]
    Float_t chi2;       // chi2 of fit
    Float_t phi;        // track's phi in cave coordinates (0..360 deg)
    Float_t theta;      // track's theta in cave coordinates (0..90 deg)
    Float_t r;          // distance of closest point to beamline [mm]
    Float_t z;          // z coordinate of closest point to beamline [mm]
    Int_t   pol;        // polarity
    Float_t quality;    // quality rk -Meta matching

    void reset(void){
	usedMeta  = -1;
	selectTof = -1;
	ind       = -1;
	beta      = -1;
	p         = -1;
	mass      = -1;
	path      = -1;
        chi2      = -1;
	phi       = -1;
	theta     = -1;
	r         = -1;
	z         = -1;
	pol       =  0;
	quality   = -1;
    }
    void fillInd(Int_t n = 0){
	ind = n;
    }
    void fill(HRKTrackB* rk){
	if(rk){
	    beta  = rk->getBeta();
	    p     = rk->getP();
	    mass  = rk->getMass2();
	    path  = rk->getTofDist();
	    chi2  = rk->getChiq();
	    phi   = HParticleTool::phiSecToLabDeg(rk->getSector(),rk->getPhiSeg1RK());
	    theta = HParticleTool::thetaToLabDeg (rk->getThetaSeg1RK());
	    r     = rk->getRSeg1RK();
	    z     = rk->getZSeg1RK();
	    pol   = rk->getPolarity();
	    if     (usedMeta >= 0 && usedMeta < 3) quality = rk->getQualityTof();
	    else if(usedMeta == kRpcClst )         quality = rk->getQualityRpc();
	    else if(usedMeta == kShowerHit )       quality = rk->getQualityShower();
	    else                                   quality = -1;
	}
    }
    ClassDef(rk_track,1)
};

class kal_track : public TObject {
public:
    kal_track(){;}
    ~kal_track(){;}

    //-------------------------------
    // to be set by hand
    Int_t usedMeta;     // see enum selMeta
    Int_t selectTof;    // see enum selMeta
    //-------------------------------
    Int_t   ind;        // Index of HRKBaseTrack object
    Float_t beta;       // particle's beta
    Float_t p;          // particle's momentum [MeV]
    Float_t mass;       // particle's mass [MeV]
    Float_t path;       // length of particle trajetory [mm]
    Float_t chi2;       // chi2 of fit
    Float_t phi;        // track's phi in cave coordinates (0..360 deg)
    Float_t theta;      // track's theta in cave coordinates (0..90 deg)
    Float_t r;          // distance of closest point to beamline [mm]
    Float_t z;          // z coordinate of closest point to beamline [mm]
    Int_t   pol;        // polarity
    Float_t quality;    // quality rk -Meta matching

    void reset(void){
	usedMeta  = -1;
	selectTof = -1;
	ind       = -1;
	beta      = -1;
	p         = -1;
	mass      = -1;
	path      = -1;
        chi2      = -1;
	phi       = -1;
	theta     = -1;
	r         = -1;
	z         = -1;
	pol       =  0;
	quality   = -1;
    }
    void fillInd(Int_t n = 0){
	ind = n;
    }
    void fill(HKalTrack* trk){
	if(trk){
	    beta  = trk->getBeta();
	    p     = trk->getP();
	    mass  = trk->getMass2();
	    path  = trk->getTofDist();
	    chi2  = trk->getChi2();
	    phi   = HParticleTool::phiSecToLabDeg(trk->getSector(),trk->getPhi());
	    theta = HParticleTool::thetaToLabDeg (trk->getTheta());
	    r     = trk->getR();
	    z     = trk->getZ();
	    pol   = trk->getPolarity();
	    if     (usedMeta >= 0 && usedMeta < 3) quality = trk->getQualityTof();
	    else if(usedMeta == kRpcClst )         quality = trk->getQualityRpc();
	    else if(usedMeta == kShowerHit )       quality = trk->getQualityShower();
	    else                                   quality = -1;
	}
    }
    ClassDef(kal_track,1)
};


class candidate : public TObject {
public:
    candidate(){ reset(); }
    ~candidate(){ ;}

    //---------------------------
    // to be set by hand
    Int_t   used;               // should this candidate be used ?
    Int_t   system;             // detector system
    Bool_t  rkSuccess;          // fitted ?
    Int_t   usedMeta;           // noUse = -1, 0 =TOFclst, 1 = TOHHIT1, 2 = TOFHIT2, 3 =RPC 4=SHR
    Int_t   selectTof;          // noUse = -1, 0 =TOFclst, 1 = TOHHIT1, 2 = TOFHIT2
    Int_t   nCand;              // number of candidate in metamatch objects
    Int_t   hasRingCorrelation; // pass MDC-RICH correlation cut ?
    Float_t corrThetaRich;      // z pos theta correction for Rich (to be added to theta)
    Float_t alignThetaRich;     // align theta correction for Rich (to be added to theta)
    Float_t alignPhiRich;       // align phi   correction for Rich (to be added to theta)
    Float_t richMdcQuality;     // match RICH inner Segment quality sqrt( dThetaSeg1 * dThetaSeg1 + dPhiSeg1 * dPhiSeg1)
    Float_t richRkQuality;      // match RICH RK quality
    //---------------------------

    //---------------------------
    // simulation
    tracksVec commonTracks; //  collected GEANT track number for all detector hits
    tracksVec richTracks;   //  collected GEANT track number for RICH detector hit
    tracksVec mdc1Tracks;   //  collected GEANT track number for inner MDC segment
    tracksVec mdc2Tracks;   //  collected GEANT track number for outer MDC segment
    tracksVec tofTracks;    //  collected GEANT track number for TOF detector hit
    tracksVec rpcTracks;    //  collected GEANT track number for RPC detector hit
    tracksVec showerTracks; //  collected GEANT track number for SHOWER detector hit
    //---------------------------

    //---------------------------
    // close tracks
    closeVec closeTracks;    // keep index and opening angle to close tracks
    Float_t  oAFitted   ;    // neg angle = hadron, pos angle lepton , -99 nothing
    Float_t  oANoFitted ;    // neg angle = hadron, pos angle lepton , -99 nothing
    //---------------------------


    //---------------------------
    Int_t        ind;        // metamatch index
    Int_t        sector;     // sector number

    mdc_trk      mdctrk;
    mdc_seg      seg1;
    mdc_seg      seg2;
    tof_hit      tof[3];
    rpc_clst     rpcclst;
    shower_hit   showerhit;
    rich_hit     richhit;
    spline_track spline;
    rk_track     rk;
    kal_track    kal;

    void reset(void){

	commonTracks.reset();
	richTracks  .reset();
	mdc1Tracks  .reset();
	mdc2Tracks  .reset();
	tofTracks   .reset();
	rpcTracks   .reset();
	showerTracks.reset();

	closeTracks .reset();
	oAFitted           = -99;
        oANoFitted         = -99;
	used               =   1;
	system             =  -1;
	rkSuccess          =   kFALSE;
	usedMeta           =  -1;
	selectTof          =  -1;
	nCand              =  -1;
	hasRingCorrelation =   0;
	corrThetaRich      =   0;
	alignThetaRich     =   0;
	alignPhiRich       =   0;
	richMdcQuality     =  -1;
	richRkQuality      =  -1;

	ind        = -1;
	sector     = -1;
	mdctrk    .reset();
	seg1      .reset();
	seg2      .reset();
	for(Int_t i=0;i<3;i++) tof[i].reset();
	rpcclst   .reset();
	showerhit .reset();
	richhit   .reset();
	spline    .reset();
	rk        .reset();
	kal       .reset();
    }
    void fillMeta(HMetaMatch2* meta){
	if(meta){
	    ind    = meta->getOwnIndex();
	    sector = meta->getSector();
	}
    }
    void fillParticleCand(HParticleCand* part,Int_t index,Int_t momSwitch=Particle::kMomRK){
	if(part){

	    Int_t selMeta = -1;
            Int_t selTof  = -1;

	    part->setIndex(index);
	    part->setSector(sector);
	    part->setSystem(system) ;
	    part->setRingCorr(hasRingCorrelation); //
	    part->setTofRec(0);                    // later filled by starttime reconstructor
	    part->setMdcdEdx(mdctrk.dedx);

	    //########################################################
            // MOM SELECTION
	    //------------------------------------------
	    if(momSwitch == Particle::kMomRK)
	    {
		if(rk.chi2 >= 0){
		    selMeta = rk.usedMeta;
		    selTof  = rk.selectTof;
		} else {
		    selMeta = usedMeta;
		    selTof  = selectTof;
		}

		part->setCharge  (rk.pol);
		part->setBeta    (rk.beta);
		part->setMomentum(rk.p);
		part->setMass2   (rk.mass);

		//------------------------------------------
		if(rk.chi2 >= 0){
		    part->setPhi  (rk.phi);
		    part->setTheta(rk.theta);
		    part->setR    (rk.r);
		    part->setZ    (rk.z);
		} else {  // if no RK take segment info
		    part->setPhi  (seg1.phi);
		    part->setTheta(seg1.theta);
		    part->setR    (seg1.r);
		    part->setZ    (seg1.z);
		}
		//------------------------------------------

		part->setChi2             (rk.chi2);
		part->setDistanceToMetaHit(rk.path);

		//------------------------------------------
		if(rk.chi2 >= 0){
		    part->setMetaMatchQuality (rk.quality);
		} else { // if no RK take MetaMatch info instead
		    if     (selMeta >= 0 && selMeta < 3)  part-> setMetaMatchQuality(tof[selMeta].quality);
		    else if(selMeta == kRpcClst )         part-> setMetaMatchQuality(rpcclst.quality);
		    else if(selMeta == kShowerHit)        part-> setMetaMatchQuality(showerhit.quality);
		    else                                  part-> setMetaMatchQuality(-1);
		}
		//------------------------------------------

	    } else if (momSwitch == Particle::kMomKalman){

		if(kal.chi2 >= 0){
		    selMeta = kal.usedMeta;
		    selTof  = kal.selectTof;
		} else {
		    selMeta = usedMeta;
		    selTof  = selectTof;
		}

		part->setCharge  (kal.pol);
		part->setBeta    (kal.beta);
		part->setMomentum(kal.p);
		part->setMass2   (kal.mass);

		//------------------------------------------
		if(rk.chi2 >= 0){
		    part->setPhi  (kal.phi);
		    part->setTheta(kal.theta);
		    part->setR    (kal.r);
		    part->setZ    (kal.z);
		} else {  // if no RK take segment info
		    part->setPhi  (seg1.phi);
		    part->setTheta(seg1.theta);
		    part->setR    (seg1.r);
		    part->setZ    (seg1.z);
		}
		//------------------------------------------

		part->setChi2             (kal.chi2);
		part->setDistanceToMetaHit(kal.path);

		//------------------------------------------
		if(kal.chi2 >= 0){
		    part->setMetaMatchQuality (kal.quality);
		} else { // if no Kalman take MetaMatch info instead
		    if     (selMeta >= 0 && selMeta < 3)  part-> setMetaMatchQuality(tof[selMeta].quality);
		    else if(selMeta == kRpcClst )         part-> setMetaMatchQuality(rpcclst.quality);
		    else if(selMeta == kShowerHit)        part-> setMetaMatchQuality(showerhit.quality);
		    else                                  part-> setMetaMatchQuality(-1);
		}
		//------------------------------------------

	    } else {

               Error("fillParticleCand","momentum reco option %i not know!",momSwitch);

	    }
	    //------------------------------------------
	    //########################################################
 

	    //------------------------------------------
	    if(selTof >= 0 && selTof < 3) part-> setTofdEdx(tof[selTof].dedx);
	    //------------------------------------------



	    part->setInnerSegmentChi2 (seg1.chi2);
	    part->setOuterSegmentChi2 (seg2.chi2);


	    part->setAngleToNearbyFittedInner  (oAFitted)  ;
	    part->setAngleToNearbyUnfittedInner(oANoFitted);


	    part->setRingNumPads      (richhit.numPads);
	    part->setRingAmplitude    (richhit.amplitude);
	    part->setRingHouTra       (richhit.houTra);
	    part->setRingPatternMatrix(richhit.patternMatrix);
	    part->setRingCentroid     (richhit.centroid);
	    part->setRichPhi          (richhit.phi) ;
	    part->setRichTheta        (richhit.theta);


	    part->setShowerSum0       (showerhit.showerSum0);
	    part->setShowerSum1       (showerhit.showerSum1);
	    part->setShowerSum2       (showerhit.showerSum2);
            part->setMetaMatchQualityShower(showerhit.quality);

	    //------------------------------------------
	    // set only indices of used META hits
	    part->setMetaInd    (ind);
	    part->setRichInd    (richhit.ind);
            part->setInnerSegInd(seg1.ind);
            part->setOuterSegInd(seg2.ind);

            part->setShowerInd (showerhit.ind);
            part->setRpcInd    (rpcclst.ind);

	    if     (selMeta == kTofClst )  part->setTofClstInd(tof[kTofClst].ind);
	    else if(selMeta == kTofHit1 ||
		    selMeta == kTofHit2  ) part->setTofHitInd (tof[selMeta].ind);

	    if(system == 2 && selMeta == kRpcClst){
                // set in addition tofhit/tofclstind
		part->setTofClstInd(tof[kTofClst].ind);

                // for the tofhits we have to check if the exist
		if     (tof[kTofHit1].ind != -1 && tof[kTofHit2].ind == -1) part->setTofHitInd ( tof[kTofHit1].ind );
		else if(tof[kTofHit1].ind == -1 && tof[kTofHit2].ind != -1) part->setTofHitInd ( tof[kTofHit2].ind );
		else if(tof[kTofHit1].ind != -1 && tof[kTofHit2].ind != -1) {
                    // if both exist take the better matched
		    if(tof[kTofHit1].quality < tof[kTofHit2].quality )  part->setTofHitInd ( tof[kTofHit1].ind );
                    else                                                part->setTofHitInd ( tof[kTofHit2].ind );
		}
	    }

	    //------------------------------------------

            part->setSelectedMeta( selMeta );


	}
    }

    void fillParticleCandSim(HParticleCandSim* part,HCategory* kineCat = 0){
	if(part && kineCat){

	    if(commonTracks.tracks.size() > 0){
		HGeantKine* kine = 0;
		Int_t tr = commonTracks.tracks[0]->tr;
		if(tr > 0) { // GEANT track
		    kine     = HCategoryManager::getObject(kine,kineCat,tr-1);
		    Float_t px,py,pz;
		    Float_t vx,vy,vz;
		    Float_t geninfo,geninfo1,geninfo2,genweight;
		    Int_t   parentTr,medium,mechanism,pid,parentPid=-1,grandparentTr=0,grandparentPid=-1;
		    pid = kine->getID();
		    kine->getMomentum (px,py,pz);
		    kine->getVertex   (vx,vy,vz);
		    kine->getCreator  (parentTr,medium,mechanism);
		    kine->getGenerator(geninfo,genweight);
		    kine->getGenerator(geninfo,geninfo1,geninfo2);
		    if(parentTr > 0){
			kine          = HCategoryManager::getObject(kine,kineCat,parentTr-1);
			parentPid     = kine->getID();
			grandparentTr = kine->getParentTrack();
			if(grandparentTr > 0){
			    kine           = HCategoryManager::getObject(kine,kineCat,grandparentTr-1);
			    grandparentPid = kine->getID();
			}
		    }

		    part->setGeantPID(pid);
		    part->setGeantTrack(tr);
		    part->setGeantCorrTrackIds(commonTracks.tracks[0]->flag);
		    part->setGeantxMom(px);
		    part->setGeantyMom(py);
		    part->setGeantzMom(pz);
		    part->setGeantxVertex(vx);
		    part->setGeantyVertex(vy);
		    part->setGeantzVertex(vz);
		    part->setGeantParentTrackNum(parentTr);
		    part->setGeantParentPID(parentPid);
		    part->setGeantGrandParentTrackNum(grandparentTr);
		    part->setGeantGrandParentPID(grandparentPid);
		    part->setGeantCreationMechanism(mechanism);
		    part->setGeantMediumNumber(medium);
		    part->setGeantGeninfo  (geninfo);
		    part->setGeantGeninfo1 (geninfo1);
		    part->setGeantGeninfo2 (geninfo2);
		    part->setGeantGenweight(genweight);
		} else if (tr == gHades->getEmbeddingRealTrackId()){ // REAL data track
                    part->setGeantTrack(tr);
		}
	    }
	}
    }
    Float_t deltaThetaSeg1(){ return   richhit.theta - seg1.theta; } // delta theta Rich-MDC
    Float_t deltaPhiSeg1()  { return ( richhit.phi - seg1.phi ) * TMath::Sin(TMath::DegToRad() * seg1.theta);} // delta phi Rich-MDC
    Float_t deltaThetaRk()  { return   richhit.theta - rk.theta; }   // delta theta Rich-MDC
    Float_t deltaPhiRk()    { return ( richhit.phi - rk.phi ) * TMath::Sin(TMath::DegToRad() * rk.theta);}     // delta phi Rich-MDC


    ClassDef(candidate,1);
};

struct pointers {

    //---------------------------
    // Object pointers simulation
    HMdcTrkCand*      pMdcTrk;    //
    HMdcSegSim*       pSeg1;      //
    HMdcSegSim*       pSeg2;      //
    HRichHitSim*      pRichHit;   //
    HTofClusterSim*   pTofClst;   //
    HTofHitSim*       pTofHit1;   //
    HTofHitSim*       pTofHit2;   //
    HRpcClusterSim*   pRpcClst;   //
    HShowerHitSim*    pShowerHit; //
    HRKTrackB*        pRk;        //
    HSplineTrack*     pSpline;    //
    HKalTrack*        pKalman;    //
    //---------------------------

    void reset(void){
	pMdcTrk      = NULL;
	pSeg1        = NULL;
	pSeg2        = NULL;
	pRichHit     = NULL;
	pTofClst     = NULL;
	pTofHit1     = NULL;
	pTofHit2     = NULL;
	pRpcClst     = NULL;
	pShowerHit   = NULL;
	pRk          = NULL;
	pSpline      = NULL;
	pKalman      = NULL;
    }
};


//---------------------------------------------------------------------------------


#endif // __HPARTICLESTRUCTS_H__