//_HADES_CLASS_DESCRIPTION 
//_HADES_CLASS_DESCRIPTION 
////////////////////////////////////////////////////////////////////////////////
//
//  HParticleConstants
//
//  util class for displaying defined constants
//
////////////////////////////////////////////////////////////////////////////////

#include "hparticleconstants.h"

#include "hparticledef.h"
#include "walldef.h"
#include "tofdef.h"
#include "hstartdef.h"
#include "rpcdef.h"
#include "richdef.h"
#include "hpiontrackerdef.h"
#include "hmdctrackgdef.h"
#include "hmdctrackddef.h"
#include "hkaldef.h"
#include "hmdcdef.h"
#include "showerdef.h"
#include "emcdef.h"
#include "hgeantdef.h"
#include "haddef.h"
#include "htrbnetdef.h"

#include "TError.h"

#include <string.h>
#include <iostream>
#include <iomanip>
using namespace std;
using namespace Particle;

ClassImp(HParticleConstants)
// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------
Bool_t HParticleConstants::addConstant(Long_t id, TString name, Int_t form,TString space,TString descr)
{
    if(nameToProp.find(name) == nameToProp.end() ){ // name was not used before
	constantproperties prop;
	prop.fill(id,name,form,space,descr);
	nameToProp[name] = prop;
        vnames.push_back(name);
	return kTRUE;
    } else {
	::Error("HParticleConstants::addConstant()","name was used already before!");
	return kFALSE;
    }
}

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

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

void HParticleConstants::clearConstants()
{
    // clear all particles in data base
    nameToProp.clear();
    vnames.clear();
}

// -----------------------------------------------------------------------------
vector<TString> HParticleConstants::initConstantNamesV(){
    vector<TString> n;
    return n;
}

map<TString,constantproperties> HParticleConstants::initConstantNames()
{
    // to be called only for init of static vectors

    //clearConstants();
    map<TString ,constantproperties> nameToPropL;


    //start categories
    addConstant(catStart2Raw ,"catStart2Raw",0,"libStart","");
    addConstant(catStart2Cal ,"catStart2Cal",0,"libStart","");
    addConstant(catStart2Hit ,"catStart2Hit",0,"libStart","");
    addConstant(catTBoxChan  ,"catTBoxChan" ,0,"libStart","");

    //rich categories
    addConstant(catRichRaw    ,"catRichRaw"    ,0,"libRich","");
    addConstant(catRichCal    ,"catRichCal"    ,0,"libRich","");
    addConstant(catRichHit    ,"catRichHit"    ,0,"libRich","");
    addConstant(catRichHitHdr ,"catRichHitHdr" ,0,"libRich","");
    addConstant(catRichDirClus,"catRichDirClus",0,"libRich","");
    addConstant(catRichTrack  ,"catRichTrack"  ,0,"libRich","");
    addConstant(catRich700Raw ,"catRich700Raw" ,0,"libRich","");

    //mdc categories
    addConstant(catMdcRaw           ,"catMdcRaw"           ,0,"libMdc","");
    addConstant(catMdcHit           ,"catMdcHit"           ,0,"libMdc","");
    addConstant(catMdcCal1          ,"catMdcCal1"          ,0,"libMdc","");
    addConstant(catMdcCal2          ,"catMdcCal2"          ,0,"libMdc","");
    addConstant(catMdcGeantCell     ,"catMdcGeantCell"     ,0,"libMdc","");
    addConstant(catMdcSeg           ,"catMdcSeg"           ,0,"libMdc","");
    addConstant(catMdcTrack         ,"catMdcTrack"         ,0,"libMdc","");
    addConstant(catMdcRawEventHeader,"catMdcRawEventHeader",0,"libMdc","");
    addConstant(catMdcTrkCand       ,"catMdcTrkCand"       ,0,"libMdc","");
    addConstant(catMdcDataWord      ,"catMdcDataWord"      ,0,"libMdc","");
    addConstant(catMdcSlope         ,"catMdcSlope"         ,0,"libMdc","");
    addConstant(catMdcRawCor        ,"catMdcRawCor"        ,0,"libMdc","");
    addConstant(catMdcHitIdeal      ,"catMdcHitIdeal"      ,0,"libMdc","");
    addConstant(catMdcSegIdeal      ,"catMdcSegIdeal"      ,0,"libMdc","");
    addConstant(catMdcTrkCandIdeal  ,"catMdcTrkCandIdeal"  ,0,"libMdc","");
    addConstant(catMdcOepStatus     ,"catMdcOepStatus"     ,0,"libMdc","");

    //mdctrackd categories
    addConstant(catMdcClus    ,"catMdcClus"   ,0,"libMdcTrackD","");
    addConstant(catMdcClusFit ,"catMdcClusFit",0,"libMdcTrackD","");
    addConstant(catMdcWireFit ,"catMdcWireFit",0,"libMdcTrackD","");
    addConstant(catMdcClusInf ,"catMdcClusInf",0,"libMdcTrackD","");

    //mdctrackg categories
    addConstant(catBaseTrack     ,"catBaseTrack"    ,0,"libMdcTrackG","");
    addConstant(catSplineTrack   ,"catSplineTrack"  ,0,"libMdcTrackG","");
    addConstant(catMetaMatch     ,"catMetaMatch"    ,0,"libMdcTrackG","");
    addConstant(catKickTrack123B ,"catKickTrack123B",0,"libMdcTrackG","");
    addConstant(catRKTrackB      ,"catRKTrackB"     ,0,"libMdcTrackG","");
    addConstant(catSplinePar     ,"catSplinePar"    ,0,"libMdcTrackG","");
    addConstant(catKalTrack      ,"catKalTrack"     ,0,"libMdcTrackG","");
    addConstant(catKalSite       ,"catKalSite"      ,0,"libMdcTrackG","");
    addConstant(catKalHitWire    ,"catKalHitWire"   ,0,"libMdcTrackG","");
    addConstant(catKalHit2d      ,"catKalHit2d"     ,0,"libMdcTrackG","");


    //tof categories
    addConstant(catTofRaw     ,"catTofRaw"    ,0,"libTof","");
    addConstant(catTofHit     ,"catTofHit"    ,0,"libTof","");
    addConstant(catTofCal     ,"catTofCal"    ,0,"libTof","");
    addConstant(catTofCluster ,"catTofCluster",0,"libTof","");
    addConstant(catTofRawTmp  ,"catTofRawTmp" ,0,"libTof","");
    addConstant(catTofHitTmp  ,"catTofHitTmp" ,0,"libTof","");

    //rpc categories
    addConstant(catRpcRaw     ,"catRpcRaw"    ,0,"libRpc","");
    addConstant(catRpcCal     ,"catRpcCal"    ,0,"libRpc","");
    addConstant(catRpcHit     ,"catRpcHit"    ,0,"libRpc","");
    addConstant(catRpcCluster ,"catRpcCluster",0,"libRpc","");
    addConstant(catRpcCalTmp  ,"catRpcCalTmp" ,0,"libRpc","");

    //shower categories
    addConstant(catShowerRaw         ,"catShowerRaw"        ,0,"libShower","");
    addConstant(catShowerHit         ,"catShowerHit"        ,0,"libShower","");
    addConstant(catShowerCal         ,"catShowerCal"        ,0,"libShower","");
    addConstant(catShowerGeantWire   ,"catShowerGeantWire"  ,0,"libShower","");
    addConstant(catShowerPID         ,"catShowerPID"        ,0,"libShower","");
    addConstant(catShowerTrack       ,"catShowerTrack"      ,0,"libShower","");
    addConstant(catShowerRawMatr     ,"catShowerRawMatr"    ,0,"libShower","");
    addConstant(catShowerHitHdr      ,"catShowerHitHdr"     ,0,"libShower","");
    addConstant(catShowerPIDTrack    ,"catShowerPIDTrack"   ,0,"libShower","");
    addConstant(catShowerHitTof      ,"catShowerHitTof"     ,0,"libShower","");
    addConstant(catShowerHitTofTrack ,"catShowerHitTofTrack",0,"libShower","");


    //emc categories
    addConstant(catEmcRaw     ,"catEmcRaw"    ,0,"libEmc","");
    addConstant(catEmcCal     ,"catEmcCal"    ,0,"libEmc","");
    addConstant(catEmcCalQA   ,"catEmcCalQA"  ,0,"libEmc","");
    addConstant(catEmcCluster ,"catEmcCluster",0,"libEmc","");


    //wall catergories
    addConstant(catWallRaw        ,"catWallRaw"       ,0,"libWall","");
    addConstant(catWallCal        ,"catWallCal"       ,0,"libWall","");
    addConstant(catWallOneHit     ,"catWallOneHit"    ,0,"libWall","");
    addConstant(catWallHit        ,"catWallHit"       ,0,"libWall","");
    addConstant(catWallEventPlane ,"catWallEventPlane",0,"libWall","");

    //piontracker categories
    addConstant(catPionTrackerRaw   ,"catPionTrackerRaw"  ,0,"libPionTracker","");
    addConstant(catPionTrackerCal   ,"catPionTrackerCal"  ,0,"libPionTracker","");
    addConstant(catPionTrackerHit   ,"catPionTrackerHit"  ,0,"libPionTracker","");
    addConstant(catPionTrackerTrack ,"catPionTrackerTrack",0,"libPionTracker","");

    //geant categories
    addConstant(catGeantHeader    ,"catGeantHeader"   ,0,"libHydra","");
    addConstant(catGeantKine      ,"catGeantKine"     ,0,"libHydra","");
    addConstant(catMdcGeantRaw    ,"catMdcGeantRaw"   ,0,"libHydra","");
    addConstant(catRichGeantRaw   ,"catRichGeantRaw"  ,0,"libHydra","");
    addConstant(catShowerGeantRaw ,"catShowerGeantRaw",0,"libHydra","");
    addConstant(catTofGeantRaw    ,"catTofGeantRaw"   ,0,"libHydra","");
    addConstant(catStartGeantRaw  ,"catStartGeantRaw" ,0,"libHydra","");
    addConstant(catWallGeantRaw   ,"catWallGeantRaw"  ,0,"libHydra","");
    addConstant(catRpcGeantRaw    ,"catRpcGeantRaw"   ,0,"libHydra","");
    addConstant(catEmcGeantRaw    ,"catEmcGeantRaw"   ,0,"libHydra","");

    addConstant(catMdc         ,"catMdc"        ,0,"libHydra","");
    addConstant(catRich        ,"catRich"       ,0,"libHydra","");
    addConstant(catShower      ,"catShower"     ,0,"libHydra","");
    addConstant(catTof         ,"catTof"        ,0,"libHydra","");
    addConstant(catStart       ,"catStart"      ,0,"libHydra","");
    addConstant(catTofino      ,"catTofino"     ,0,"libHydra","");
    addConstant(catWall        ,"catWall"       ,0,"libHydra","");
    addConstant(catHodo        ,"catHodo"       ,0,"libHydra","");
    addConstant(catSimul       ,"catSimul"      ,0,"libHydra","");
    addConstant(catRpc         ,"catRpc"        ,0,"libHydra","");
    addConstant(catEmc         ,"catEmc"        ,0,"libHydra","");
    addConstant(catPionTracker ,"catPionTracker",0,"libHydra","");
    addConstant(catMatchU      ,"catMatchU"     ,0,"libHydra","");
    addConstant(catTracks      ,"catTracks"     ,0,"libHydra","");
    addConstant(catPhyAna      ,"catPhyAna"     ,0,"libHydra","");
    addConstant(catPairs       ,"catPairs"      ,0,"libHydra","");
    addConstant(catParticle    ,"catParticle"   ,0,"libHydra","");
    addConstant(catTrbNet      ,"catTrbNet"     ,0,"libHydra","");
    addConstant(catFlex        ,"catFlex"       ,0,"libHydra","");
    addConstant(catTrack       ,"catTrack"      ,0,"libHydra","");
    addConstant(catInvalid     ,"catInvalid"    ,0,"libHydra","");


    addConstant(catParticleEvtInfo   ,"catParticleEvtInfo"   ,0,"libParticle","");
    addConstant(catParticleCal       ,"catParticleCal"       ,0,"libParticle","");
    addConstant(catParticlePair      ,"catParticlePair"      ,0,"libParticle","");
    addConstant(catParticleMdc       ,"catParticleMdc"       ,0,"libParticle","");
    addConstant(catParticleBtRing    ,"catParticleBtRing"    ,0,"libParticle","");
    addConstant(catParticleBtRingInfo,"catParticleBtRingInfo",0,"libParticle","");




    // hydra
    addConstant(kSkipEvent     ,"kSkipEvent"    ,0,"libHydra","Return value for HTask to signal skipping full event");

    //kalman
    addConstant(Kalman::kSecCoord        ,"kSecCoord"       ,0,"Kalman::coordSys","Sector coordinate system");
    addConstant(Kalman::kLayCoord        ,"kLayCoord"       ,0,"Kalman::coordSys","Virtual layer coordinate system");
    addConstant(Kalman::kKalConv         ,"kKalConv"        ,0,"Kalman::filtMethod","Math methods for matrix opererations");
    addConstant(Kalman::kKalJoseph       ,"kKalJoseph"      ,0,"Kalman::filtMethod","Math methods for matrix opererations");
    addConstant(Kalman::kKalUD           ,"kKalUD"          ,0,"Kalman::filtMethod","Math methods for matrix opererations");
    addConstant(Kalman::kKalSeq          ,"kKalSeq"         ,0,"Kalman::filtMethod","Math methods for matrix opererations");
    addConstant(Kalman::kKalSwer         ,"kKalSwer"        ,0,"Kalman::filtMethod","Math methods for matrix opererations");

    addConstant(Kalman::kWireHit         ,"kWireHit"        ,0,"Kalman::kalHitTypes","Work with drift chamber hits");
    addConstant(Kalman::kSegHit          ,"kSegHit"         ,0,"Kalman::kalHitTypes","Work with 2D segment hits");

    addConstant(Kalman::kPredicted       ,"kPredicted"      ,0,"Kalman::kalFilterTypes","Kalman state");
    addConstant(Kalman::kFiltered        ,"kFiltered"       ,0,"Kalman::kalFilterTypes","Kalman state");
    addConstant(Kalman::kSmoothed        ,"kSmoothed"       ,0,"Kalman::kalFilterTypes","Kalman state");
    addConstant(Kalman::kInvFiltered     ,"kInvFiltered"    ,0,"Kalman::kalFilterTypes","Kalman state");

    addConstant(Kalman::kIdxX0           ,"kIdxX0"          ,0,"Kalman::kalStateIdx","TrackState variables");
    addConstant(Kalman::kIdxY0           ,"kIdxY0"          ,0,"Kalman::kalStateIdx","TrackState variables");
    addConstant(Kalman::kIdxTanPhi       ,"kIdxTanPhi"      ,0,"Kalman::kalStateIdx","TrackState variables");
    addConstant(Kalman::kIdxTanTheta     ,"kIdxTanTheta"    ,0,"Kalman::kalStateIdx","TrackState variables");
    addConstant(Kalman::kIdxQP           ,"kIdxQP"          ,0,"Kalman::kalStateIdx","TrackState variables");
    addConstant(Kalman::kIdxZ0           ,"kIdxZ0"          ,0,"Kalman::kalStateIdx","TrackState variables");

    addConstant(Kalman::kNoRot           ,"kNoRot"          ,0,"Kalman::kalRotateOptions","Do not Rotate coordinate so that it points in inital track direction");
    addConstant(Kalman::kVarRot          ,"kVarRot"         ,0,"Kalman::kalRotateOptions","Rotate coordinate so that it points in inital track direction");

    addConstant(Kalman::kMatIdxA         ,"kMatIdxA"        ,0,"Kalman::matIdx","Material property");
    addConstant(Kalman::kMatIdxZ         ,"kMatIdxZ"        ,0,"Kalman::matIdx","Material property");
    addConstant(Kalman::kMatIdxDensity   ,"kMatIdxDensity"  ,0,"Kalman::matIdx","Material property");
    addConstant(Kalman::kMatIdxExEner    ,"kMatIdxExEner"   ,0,"Kalman::matIdx","Material property");
    addConstant(Kalman::kMatIdxRadLength ,"kMatIdxRadLength",0,"Kalman::matIdx","Material property");


    //Particle::eSelMeta
    addConstant(kNoUse    ,"kNoUse"    ,0,"Particle::eSelMeta","Selected META hit type in HParticleCand");
    addConstant(kTofClst  ,"kTofClst"  ,0,"Particle::eSelMeta","Selected META hit type in HParticleCand");
    addConstant(kTofHit1  ,"kTofHit1"  ,0,"Particle::eSelMeta","Selected META hit type in HParticleCand");
    addConstant(kTofHit2  ,"kTofHit2"  ,0,"Particle::eSelMeta","Selected META hit type in HParticleCand");
    addConstant(kRpcClst  ,"kRpcClst"  ,0,"Particle::eSelMeta","Selected META hit type in HParticleCand");
    addConstant(kShowerHit,"kShowerHit",0,"Particle::eSelMeta","Selected META hit type in HParticleCand");
    addConstant(kEmcClst  ,"kEmcClst"  ,0,"Particle::eSelMeta","Selected META hit type in HParticleCand");


    //Particle::eDetBits
    addConstant(kIsNotSet     ,"kIsNotSet"    ,1,"Particle::eDetBits","This object does not contain valid data");
    addConstant(kIsInRICHIPU  ,"kIsInRICHIPU" ,1,"Particle::eDetBits","1    RICH IPU has seen this trackid");
    addConstant(kIsInOuterMDC ,"kIsInOuterMDC",1,"Particle::eDetBits","2    Outer Mdc has seen this trackid");
    addConstant(kIsInRICH     ,"kIsInRICH"    ,1,"Particle::eDetBits","4    RICH has seen this trackid");
    addConstant(kIsInInnerMDC ,"kIsInInnerMDC",1,"Particle::eDetBits","8    Inner Mdc has seen this trackid");
    addConstant(kIsInSHOWER   ,"kIsInSHOWER"  ,1,"Particle::eDetBits","16   Shower has seen this trackid");
    addConstant(kIsInEMC      ,"kIsInEMC"     ,1,"Particle::eDetBits","16   EMC has seen this trackid (SHOWER and EMC will not be used together)");
    addConstant(kIsInTOF      ,"kIsInTOF"     ,1,"Particle::eDetBits","32   TOF has seen this trackid");
    addConstant(kIsInRPC      ,"kIsInRPC"     ,1,"Particle::eDetBits","64   Rpc has seen this trackid");
    addConstant(kIsInMETA     ,"kIsInMETA"    ,1,"Particle::eDetBits","128  One of the Meta dets has seen this trackid");
    addConstant(kIsGhost      ,"kIsGhost"     ,1,"Particle::eDetBits","256  Tracking Ghost");
    addConstant(kIsInnerGhost ,"kIsInnerGhost",1,"Particle::eDetBits","512  Tracking Ghost in inner MDC");
    addConstant(kIsOuterGhost ,"kIsOuterGhost",1,"Particle::eDetBits","1024 Tracking Ghost in outer MDC");

    //Particle::eMatching
    addConstant(kIsNoMatch ,"kIsNoMatch",1,"Particle::eMatching","This object does not contain valid data");
    addConstant(kIsRICHMDC ,"kIsRICHMDC",1,"Particle::eMatching","1 RICH MDC matching");
    addConstant(kIsRICHRK  ,"kIsRICHRK" ,1,"Particle::eMatching","2 RICH RK matching");

    //Particle::eVertex
    addConstant(kVertexCluster  ,"kVertexCluster"  ,0,"Particle::eVertex","vertex from cluster finder");
    addConstant(kVertexSegment  ,"kVertexSegment"  ,0,"Particle::eVertex","vertex from fitted inner segments");
    addConstant(kVertexParticle ,"kVertexParticle" ,0,"Particle::eVertex","vertex from reconstructed particle candidates");
    addConstant(kVertexUser     ,"kVertexUser"     ,0,"Particle::eVertex","vertex provided by user");


    //Particle::eMomReco
    addConstant(kMomSpline ,"kMomSpline",0,"Particle::eMomReco","from spline");
    addConstant(kMomRK     ,"kMomRK"    ,0,"Particle::eMomReco","from runge kutta");
    addConstant(kMomKalman ,"kMomKalman",0,"Particle::eMomReco","from kalman");

    //Particle::ePair
    addConstant(kIsUS    ,"kIsUS"   ,0,"Particle::ePair","This pair is unlike sign");
    addConstant(kIsLSPos ,"kIsLSPos",0,"Particle::ePair","This pair is like sign, both positive");
    addConstant(kIsLSNeg ,"kIsLSNeg",0,"Particle::ePair","This pair is like sign, both negative");


    //Particle::eFlagBits
    addConstant(kIsDoubleHitRICH          ,"kIsDoubleHitRICH"          ,0,"Particle::eFlagBits","RICH hit has been used more than once in event");
    addConstant(kIsDoubleHitInnerMDC      ,"kIsDoubleHitInnerMDC"      ,0,"Particle::eFlagBits","Inner MDC seg has been used more than once in event");
    addConstant(kIsDoubleHitOuterMDC      ,"kIsDoubleHitOuterMDC"      ,0,"Particle::eFlagBits","Outer MDC seg has been used more than once in event");
    addConstant(kIsDoubleHitMETA          ,"kIsDoubleHitMETA"          ,0,"Particle::eFlagBits","META HIT has been used more than once in event");
    addConstant(kIsBestHitRICH            ,"kIsBestHitRICH"            ,0,"Particle::eFlagBits","Hit exists");
    addConstant(kIsBestHitInnerMDC        ,"kIsBestHitInnerMDC"        ,0,"Particle::eFlagBits","(by chi2,  chi2 >= 0 )");
    addConstant(kIsBestHitOuterMDC        ,"kIsBestHitOuterMDC"        ,0,"Particle::eFlagBits","(by chi2 , chi2 >= 0 )");
    addConstant(kIsBestHitMETA            ,"kIsBestHitMETA"            ,0,"Particle::eFlagBits","(by RKMETA match quality)");
    addConstant(kIsBestRK                 ,"kIsBestRK"                 ,0,"Particle::eFlagBits","(by RK chi2, none fitted outer segments with lower priority)");
    addConstant(kIsBestRKRKMETA           ,"kIsBestRKRKMETA"           ,0,"Particle::eFlagBits","(by RK chi2 * RK META match quality)");
    addConstant(kIsBestRKRKMETARadius     ,"kIsBestRKRKMETARadius"     ,0,"Particle::eFlagBits","(by RK chi2 * RK META match radius)");
    addConstant(kIsBestUser               ,"kIsBestUser"               ,0,"Particle::eFlagBits","(user function)");
    addConstant(kIsAcceptedHitRICH        ,"kIsAcceptedHitRICH"        ,0,"Particle::eFlagBits","Hit exists");
    addConstant(kIsAcceptedHitRICHMDC     ,"kIsAcceptedHitRICHMDC"     ,0,"Particle::eFlagBits","RICH hit + ring correlation segment");
    addConstant(kIsAcceptedHitInnerMDC    ,"kIsAcceptedHitInnerMDC"    ,0,"Particle::eFlagBits","needs inner MDC chi2 >= 0");
    addConstant(kIsAcceptedHitOuterMDC    ,"kIsAcceptedHitOuterMDC"    ,0,"Particle::eFlagBits","needs outer MDC chi2 >= 0");
    addConstant(kIsAcceptedHitMETA        ,"kIsAcceptedHitMETA"        ,0,"Particle::eFlagBits","needs Meta Hit");
    addConstant(kIsAcceptedRKMETA         ,"kIsAcceptedRKMETA"         ,0,"Particle::eFlagBits","needs RK chi2 >= 0 + Meta hit");
    addConstant(kIsAcceptedRKRICH         ,"kIsAcceptedRKRICH"         ,0,"Particle::eFlagBits","needs RK chi2 >= 0 + RICH hit + ring correlation after RK");
    addConstant(kIsAcceptedRK             ,"kIsAcceptedRK"             ,0,"Particle::eFlagBits","needs RK chi2 >= 0");
    addConstant(kIsAcceptedRKRKMETA       ,"kIsAcceptedRKRKMETA"       ,0,"Particle::eFlagBits","needs RK chi2 >= 0 + Meta hit");
    addConstant(kIsAcceptedRKRKMETARadius ,"kIsAcceptedRKRKMETARadius" ,0,"Particle::eFlagBits","needs RK chi2 >= 0 + Meta hit");
    addConstant(kIsAcceptedUser           ,"kIsAcceptedUser"           ,0,"Particle::eFlagBits","needs RK chi2 >= 0 + Meta hit");
    addConstant(kIsLepton                 ,"kIsLepton"                 ,0,"Particle::eFlagBits","mark the selected leptons");
    addConstant(kIsUsed                   ,"kIsUsed"                   ,0,"Particle::eFlagBits","mark the object as arleady used");
    addConstant(kIsRejected               ,"kIsRejected"               ,0,"Particle::eFlagBits","mark the object as rejected");

    //Particle::ERichMatch
    addConstant(kUseRICHIndexSorter         ,"kUseRICHIndexSorter"         ,0,"Particle::ERichMatch","require RICH valid index");
    addConstant(kUseRKRICHCorrelationSorter ,"kUseRKRICHCorrelationSorter" ,0,"Particle::ERichMatch","require RK-RICH correlation (from HPidTrackCand)");
    addConstant(kUseRKRICHWindowSorter      ,"kUseRKRICHWindowSorter"      ,0,"Particle::ERichMatch","require RK-RICH matching inside +- window");

    //Particle::ESelect
    addConstant(kIsLeptonSorter ,"kIsLeptonSorter" ,0,"Particle::ESelect","run from selectLepton()");
    addConstant(kIsHadronSorter ,"kIsHadronSorter" ,0,"Particle::ESelect","run from selectHadron()");

    //Particle::ESwitch
    addConstant(kIsIndexRICHSorter          ,"kIsIndexRICHSorter"          ,0,"Particle::ESwitch","");
    addConstant(kIsIndexInnerMDCSorter      ,"kIsIndexInnerMDCSorter"      ,0,"Particle::ESwitch","");
    addConstant(kIsIndexOuterMDCSorter      ,"kIsIndexOuterMDCSorter"      ,0,"Particle::ESwitch","");
    addConstant(kIsIndexTOFSorter           ,"kIsIndexTOFSorter"           ,0,"Particle::ESwitch","");
    addConstant(kIsIndexSHOWERSorter        ,"kIsIndexSHOWERSorter"        ,0,"Particle::ESwitch","");
    addConstant(kIsIndexRPCSorter           ,"kIsIndexRPCSorter"           ,0,"Particle::ESwitch","");
    addConstant(kIsIndexMETASorter          ,"kIsIndexMETASorter"          ,0,"Particle::ESwitch","");
    addConstant(kIsBestHitRICHSorter        ,"kIsBestHitRICHSorter"        ,0,"Particle::ESwitch","");
    addConstant(kIsBestHitInnerMDCSorter    ,"kIsBestHitInnerMDCSorter"    ,0,"Particle::ESwitch","(by chi2)");
    addConstant(kIsBestHitOuterMDCSorter    ,"kIsBestHitOuterMDCSorter"    ,0,"Particle::ESwitch","(by chi2)");
    addConstant(kIsBestHitMETASorter        ,"kIsBestHitMETASorter"        ,0,"Particle::ESwitch","(by RK META match quality)");
    addConstant(kIsBestRKRKMETASorter       ,"kIsBestRKRKMETASorter"       ,0,"Particle::ESwitch","(by RK chi2 * RK META match quality)");
    addConstant(kIsBestRKRKMETARadiusSorter ,"kIsBestRKRKMETARadiusSorter" ,0,"Particle::ESwitch","(by RK chi2 * RK META match radius)");
    addConstant(kIsBestUserSorter           ,"kIsBestUserSorter"           ,0,"Particle::ESwitch","(by userFunction)");


    //Particle::eClosePairSelect
    addConstant(kSameRICH          ,"kSameRICH"          ,1,"Particle::eClosePairSelect","candidates share same RICH hit");
    addConstant(kSameInnerMDC      ,"kSameInnerMDC"      ,1,"Particle::eClosePairSelect","candidates share innerMDC seg");
    addConstant(kSameOuterMDC      ,"kSameOuterMDC"      ,1,"Particle::eClosePairSelect","candidates share outerMDC seg");
    addConstant(kSameMETA          ,"kSameMETA"          ,1,"Particle::eClosePairSelect","candidates share META hit (used META)");
    addConstant(kSamePosPolarity   ,"kSamePosPolarity"   ,1,"Particle::eClosePairSelect","candidates share have same positive polarity (polarity has to be defined)");
    addConstant(kSameNegPolarity   ,"kSameNegPolarity"   ,1,"Particle::eClosePairSelect","candidates share have same negative polarity (polarity has to be defined)");
    addConstant(kSamePolarity      ,"kSamePolarity"      ,1,"Particle::eClosePairSelect","candidates share have same polarity (polarity has to be defined)");
    addConstant(kRICH2             ,"kRICH2"             ,1,"Particle::eClosePairSelect","candidate2 has RICH");
    addConstant(kFittedInnerMDC2   ,"kFittedInnerMDC2"   ,1,"Particle::eClosePairSelect","candidate2 has fitted inner MDC seg");
    addConstant(kFittedOuterMDC2   ,"kFittedOuterMDC2"   ,1,"Particle::eClosePairSelect","candidate2 has fitted outer MDC seg");
    addConstant(kOuterMDC2         ,"kOuterMDC2"         ,1,"Particle::eClosePairSelect","candidate2 has outer MDC seg");
    addConstant(kRK2               ,"kRK2"               ,1,"Particle::eClosePairSelect","candidate2 has fitted momentum");
    addConstant(kMETA2             ,"kMETA2"             ,1,"Particle::eClosePairSelect","candidate2 has META hit");
    addConstant(kIsLepton2         ,"kIsLepton2"         ,1,"Particle::eClosePairSelect","candidate2 has kIsLepton");
    addConstant(kIsUsed2           ,"kIsUsed2"           ,1,"Particle::eClosePairSelect","candidate2 has kIsUsed");
    addConstant(kNoSameRICH        ,"kNoSameRICH"        ,1,"Particle::eClosePairSelect","candidates do not share RICH hit");
    addConstant(kNoSameInnerMDC    ,"kNoSameInnerMDC"    ,1,"Particle::eClosePairSelect","candidates do not share innerMDC seg");
    addConstant(kNoSameOuterMDC    ,"kNoSameOuterMDC"    ,1,"Particle::eClosePairSelect","candidates do not share outerMDC seg");
    addConstant(kNoSameMETA        ,"kNoSameMETA"        ,1,"Particle::eClosePairSelect","candidates do not share META hit");
    addConstant(kNoSamePosPolarity ,"kNoSamePosPolarity" ,1,"Particle::eClosePairSelect","candidates have not same pos polarity");
    addConstant(kNoSameNegPolarity ,"kNoSameNegPolarity" ,1,"Particle::eClosePairSelect","candidates have not same neg polarity");
    addConstant(kNoSamePolarity    ,"kNoSamePolarity"    ,1,"Particle::eClosePairSelect","candidates have not same polarity");
    addConstant(kNoRICH2           ,"kNoRICH2"           ,1,"Particle::eClosePairSelect","candidate2 has no RICH");
    addConstant(kNoFittedInnerMDC2 ,"kNoFittedInnerMDC2" ,1,"Particle::eClosePairSelect","candidate2 has no fitted inner MDC seg");
    addConstant(kNoFittedOuterMDC2 ,"kNoFittedOuterMDC2" ,1,"Particle::eClosePairSelect","candidate2 has no fitted outer MDC seg");
    addConstant(kNoOuterMDC2       ,"kNoOuterMDC2"       ,1,"Particle::eClosePairSelect","candidate2 has no outer MDC seg");
    addConstant(kNoRK2             ,"kNoRK2"             ,1,"Particle::eClosePairSelect","candidate2 has no fitted momentum");
    addConstant(kNoMETA2           ,"kNoMETA2"           ,1,"Particle::eClosePairSelect","candidate2 has no META hit");
    addConstant(kNoIsLepton2       ,"kNoIsLepton2"       ,1,"Particle::eClosePairSelect","candidate2 has no kIsLepton");
    addConstant(kNoIsUsed2         ,"kNoIsUsed2"         ,1,"Particle::eClosePairSelect","candidate2 has no kIsUsed");
    addConstant(kNoUseRICH         ,"kNoUseRICH"         ,1,"Particle::eClosePairSelect","do not take RICH into account");

    //Particle::eEventSelect
    addConstant(kPairCase1 ,"kPairCase1"  ,1,"Particle::ePairCase","LEPTON: kNoSameRICH|kNoSameInnerMDC|kNoSameOuterMDC|kNoSameMETA|kRICH2|kOuterMDC2|kMETA2");
    addConstant(kPairCase2 ,"kPairCase2"  ,1,"Particle::ePairCase","LEPTON: kNoSameRICH|kNoSameInnerMDC|kNoSameOuterMDC|kSameMETA  |kRICH2|kOuterMDC2|kMETA2");
    addConstant(kPairCase3 ,"kPairCase3"  ,1,"Particle::ePairCase","LEPTON: kNoSameRICH|kNoSameInnerMDC|kSameOuterMDC  |kSameMETA  |kRICH2|kOuterMDC2|kMETA2");
    addConstant(kPairCase4 ,"kPairCase4"  ,1,"Particle::ePairCase","LEPTON: kNoSameRICH|kNoSameInnerMDC|kSameOuterMDC  |kNoSameMETA|kRICH2|kOuterMDC2|kMETA2");
    addConstant(kPairCase5 ,"kPairCase5"  ,1,"Particle::ePairCase","LEPTON: kNoSameRICH|kSameInnerMDC  |kNoSameOuterMDC|kNoSameMETA|kRICH2|kOuterMDC2|kMETA2");
    addConstant(kPairCase6 ,"kPairCase6"  ,1,"Particle::ePairCase","LEPTON: kSameRICH  |kSameInnerMDC  |kNoSameOuterMDC|kNoSameMETA|kRICH2|kOuterMDC2|kMETA2");
    addConstant(kPairCase7 ,"kPairCase7"  ,1,"Particle::ePairCase","LEPTON: kSameRICH  |kNoSameInnerMDC|kNoSameOuterMDC|kNoSameMETA|kRICH2|kOuterMDC2|kMETA2");
    addConstant(kPairCase8 ,"kPairCase8"  ,1,"Particle::ePairCase","LEPTON: kSameRICH  |kNoSameInnerMDC|kNoSameOuterMDC|kSameMETA  |kRICH2|kOuterMDC2|kMETA2");
    addConstant(kPairCase9 ,"kPairCase9"  ,1,"Particle::ePairCase","LEPTON: kSameRICH  |kSameInnerMDC  |kNoSameOuterMDC|kSameMETA  |kRICH2|kOuterMDC2|kMETA2");
    addConstant(kPairCase10,"kPairCase10" ,1,"Particle::ePairCase","LEPTON: kSameRICH  |kSameInnerMDC  |kSameOuterMDC  |kNoSameMETA|kRICH2|kOuterMDC2|kMETA2");
    addConstant(kPairCase11,"kPairCase11" ,1,"Particle::ePairCase","LEPTON: kNoSameRICH|kNoSameInnerMDC|kNoSameOuterMDC            |kRICH2|kOuterMDC2|kNoMETA2");
    addConstant(kPairCase12,"kPairCase12" ,1,"Particle::ePairCase","LEPTON: kSameRICH  |kNoSameInnerMDC|kNoSameOuterMDC            |kRICH2|kOuterMDC2|kNoMETA2");
    addConstant(kPairCase13,"kPairCase13" ,1,"Particle::ePairCase","LEPTON: kSameRICH  |kSameInnerMDC  |kNoSameOuterMDC            |kRICH2|kOuterMDC2|kNoMETA2");
    addConstant(kPairCase14,"kPairCase14" ,1,"Particle::ePairCase","LEPTON: kNoSameRICH|kNoSameInnerMDC                            |kRICH2|kNoOuterMDC2|kNoMETA2");
    addConstant(kPairCase15,"kPairCase15" ,1,"Particle::ePairCase","LEPTON: kSameRICH  |kNoSameInnerMDC                            |kRICH2|kNoOuterMDC2|kNoMETA2");
    addConstant(kPairCase16 ,"kPairCase16",1,"Particle::ePairCase","HADRON: kNoUseRICH |kNoSameInnerMDC|kNoSameOuterMDC|kNoSameMETA|kOuterMDC2|kMETA2");
    addConstant(kPairCase17 ,"kPairCase17",1,"Particle::ePairCase","HADRON: kNoUseRICH |kNoSameInnerMDC|kNoSameOuterMDC|kSameMETA  |kOuterMDC2|kMETA2");
    addConstant(kPairCase18 ,"kPairCase18",1,"Particle::ePairCase","HADRON: kNoUseRICH |kNoSameInnerMDC|kSameOuterMDC  |kSameMETA  |kOuterMDC2|kMETA2");
    addConstant(kPairCase19 ,"kPairCase19",1,"Particle::ePairCase","HADRON: kNoUseRICH |kNoSameInnerMDC|kSameOuterMDC  |kNoSameMETA|kOuterMDC2|kMETA2");
    addConstant(kPairCase20 ,"kPairCase20",1,"Particle::ePairCase","HADRON: kNoUseRICH |kSameInnerMDC  |kNoSameOuterMDC|kSameMETA  |kOuterMDC2|kMETA2");
    addConstant(kPairCase21 ,"kPairCase21",1,"Particle::ePairCase","HADRON: kNoUseRICH |kSameInnerMDC  |kSameOuterMDC  |kNoSameMETA|kOuterMDC2|kMETA2");
    addConstant(kPairCase22 ,"kPairCase22",1,"Particle::ePairCase","HADRON: kNoUseRICH |kSameInnerMDC  |kNoSameOuterMDC|kNoSameMETA|kOuterMDC2|kMETA2");
    addConstant(kPairCase23 ,"kPairCase23",1,"Particle::ePairCase","HADRON: kNoUseRICH |kNoSameInnerMDC|kNoSameOuterMDC            |kOuterMDC2|kNoMETA2");
    addConstant(kPairCase24 ,"kPairCase24",1,"Particle::ePairCase","HADRON: kNoUseRICH |kSameInnerMDC  |kNoSameOuterMDC            |kOuterMDC2|kNoMETA2");
    addConstant(kPairCase25 ,"kPairCase25",1,"Particle::ePairCase","HADRON: kNoUseRICH |kNoSameInnerMDC                            |kNoOuterMDC2|kNoMETA2");
    addConstant(kPairCase26 ,"kPairCase26",1,"Particle::ePairCase","LEP+HADRON: kNoSameRICH|kNoSameInnerMDC|kNoSameOuterMDC|kNoSameMETA|kNoRICH2|kOuterMDC2|kMETA2");
    addConstant(kPairCase27 ,"kPairCase27",1,"Particle::ePairCase","LEP+HADRON: kNoSameRICH|kNoSameInnerMDC|kNoSameOuterMDC|kSameMETA  |kNoRICH2|kOuterMDC2|kMETA2");
    addConstant(kPairCase28 ,"kPairCase28",1,"Particle::ePairCase","LEP+HADRON: kNoSameRICH|kNoSameInnerMDC|kSameOuterMDC  |kSameMETA  |kNoRICH2|kOuterMDC2|kMETA2");
    addConstant(kPairCase29 ,"kPairCase29",1,"Particle::ePairCase","LEP+HADRON: kNoSameRICH|kNoSameInnerMDC|kSameOuterMDC  |kNoSameMETA|kNoRICH2|kOuterMDC2|kMETA2");
    addConstant(kPairCase30 ,"kPairCase30",1,"Particle::ePairCase","LEP+HADRON: kNoSameRICH|kSameInnerMDC  |kNoSameOuterMDC|kNoSameMETA|kNoRICH2|kOuterMDC2|kMETA2");
    addConstant(kPairCase31 ,"kPairCase31",1,"Particle::ePairCase","LEP+HADRON: kNoSameRICH|kNoSameInnerMDC|kNoSameOuterMDC            |kNoRICH2|kOuterMDC2|kNoMETA2");
    addConstant(kPairCase32 ,"kPairCase32",1,"Particle::ePairCase","LEP+HADRON: kNoSameRICH|kNoSameInnerMDC                            |kNoRICH2|kNoOuterMDC2|kNoMETA2");

    //Particle::eEventSelect
    addConstant(kGoodVertexClust ,"kGoodVertexClust" ,1,"Particle::eEventSelect","1     good cluster vertex   (chi2>0, z > -65 (apr12), -160 (Jul14+aug14), >-70 (mar19)) (requires 1 track)");
    addConstant(kGoodVertexCand  ,"kGoodVertexCand"  ,1,"Particle::eEventSelect","2     good candidate vertex (chi2>0, z > -65 (apr12), -160 (Jul14+aug14), >-70 (mar19)) (requires at least 2 reconstructed particles)");
    addConstant(kGoodSTART       ,"kGoodSTART"       ,1,"Particle::eEventSelect","4     good StartHit         (object exists (+ corrflag > -1 if HParticleStart2HitF was used)");
    addConstant(kNoPileUpSTART   ,"kNoPileUpSTART"   ,1,"Particle::eEventSelect","8     no pileup in START (object exists + no second cluster)");
    addConstant(kNoPileUpMETA    ,"kNoPileUpMETA"    ,1,"Particle::eEventSelect","16    no pileup in META  (no objects tof<0 or tof>60, threshold 0 (pionbeam)  5 apr12");
    addConstant(kNoPileUpMDC     ,"kNoPileUpMDC"     ,1,"Particle::eEventSelect","32    no pileup in MDC   (objects t1>200 (inner or t1>400 (outer)), threshold 7 (pionbeam) 35 (apr12))");
    addConstant(kNoFlashMDC      ,"kNoFlashMDC"      ,1,"Particle::eEventSelect","64    no flash event in MDC");
    addConstant(kGoodMDCMult     ,"kGoodMDCMult"     ,1,"Particle::eEventSelect","128   good sectors inside normal mult");
    addConstant(kGoodMDCMIPSMult ,"kGoodMDCMIPSMult" ,1,"Particle::eEventSelect","256   good sectors inside normal mult for MIPS");
    addConstant(kGoodLepMult     ,"kGoodLepMult"     ,1,"Particle::eEventSelect","512   good sectors inside normal lepton mult");
    addConstant(kGoodTRIGGER     ,"kGoodTRIGGER"     ,1,"Particle::eEventSelect","1024  phys trigger (pt1 jul14/aug14, pt3 apr12,mar19)");
    addConstant(kGoodSTART2      ,"kGoodSTART2"      ,1,"Particle::eEventSelect","2048  good StartHit (object exists (+ corrflag ==2 if HParticleStart2HitF was used");
    addConstant(kNoVETO          ,"kNoVETO"          ,1,"Particle::eEventSelect","4096  no VETO hit +- 15ns arround START");
    addConstant(kGoodSTARTVETO   ,"kGoodSTARTVETO"   ,1,"Particle::eEventSelect","8192  no starthit >15ns <350ns uncorrelated with veto");
    addConstant(kGoodSTARTMETA   ,"kGoodSTARTMETA"   ,1,"Particle::eEventSelect","16384 no starthit >80ns <350ns  correlated with metahits");
    addConstant(kNoDeltaElectron ,"kNoDeltaElectron" ,1,"Particle::eEventSelect","32768 no DeltaElect event in MDC");
    addConstant(kNoSTART         ,"kNoSTART"         ,1,"Particle::eEventSelect","65536 no second START in +-15ns from START hit");
    addConstant(kNoEventPileUp   ,"kNoEventPileUp"   ,1,"Particle::eEventSelect","131072 no Event pile up detected from Clusterfinder");

    //Particle::eBeamTime
    addConstant(kUnknownBeam ,"kUnknownBeam" ,0,"Particle::eBeamTime","");
    addConstant(kApr12       ,"kApr12"       ,0,"Particle::eBeamTime","");
    addConstant(kJul14       ,"kJul14"       ,0,"Particle::eBeamTime","");
    addConstant(kAug14       ,"kAug14"       ,0,"Particle::eBeamTime","");
    addConstant(kMar19       ,"kMar19"       ,0,"Particle::eBeamTime","");


    return nameToPropL;
}

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


void HParticleConstants::print(Bool_t sort){

    ::Info("HParticleConstants::print()","Printing table of all known particle constants:");

    if(sort){
	map<TString,constantproperties>::iterator iter;
	for( iter = nameToProp.begin(); iter != nameToProp.end(); ++iter ) {
	    iter->second.print();
	}
	cout<<endl;
    } else {
	for(UInt_t i=0;i<vnames.size();i++){
	    map<TString,constantproperties>::iterator iter = nameToProp.find(vnames[i]);
	    if(iter != nameToProp.end()) iter->second.print();
	    else {
		::Error("HParticleConstants::getValue", "No constant with name=%s", vnames[i].Data());
	    }
	}
    }
}

// -----------------------------------------------------------------------------
void HParticleConstants::printValue(TString name)
{
    // print value given a constants name

    map<TString,constantproperties>::iterator iter = nameToProp.find(name);
    if(iter != nameToProp.end()) iter->second.print();
    else {
	::Error("HParticleConstants::getValue", "No constant with name=%s", name.Data());
    }
}

void HParticleConstants::printValueMatch(TString name)
{
    // print constants value given a containing  name

    for (std::map<TString,constantproperties>::iterator it = nameToProp.begin(); it != nameToProp.end(); ++it)
    {
        if(it->second.fName.Contains(name)) it->second.print();
    }
}

void HParticleConstants::printSpace(TString space)
{
    // print all constant belonging to space space

    for (std::map<TString,constantproperties>::iterator it = nameToProp.begin(); it != nameToProp.end(); ++it)
    {
        if(it->second.fSpace.Contains(space)) it->second.print();
    }
}

Int_t HParticleConstants::getValue(TString name)
{
    // Return integer value given a constants name

    map<TString,constantproperties>::iterator iter = nameToProp.find(name);
    if(iter != nameToProp.end()) return iter->second.fId;
    else {
	::Error("HParticleConstants::getValue", "No constant with name=%s", name.Data());
    }
    return 0;
}

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

vector<TString> HParticleConstants::vnames = HParticleConstants::initConstantNamesV();
map<TString,constantproperties> HParticleConstants::nameToProp = HParticleConstants::initConstantNames();