class HParticleTool: public TObject

 Convert phi (rad) angle from sec to Lab phi in deg

 Convert theta angle (rad) to the coordinate lab system

 Convert phi angle (deg,lab: 0-360) to the coordinate sector system (60,120)

 return -1 if fails.

 return -1 if fails. richTheta and richPhi in deg in lab system

 phi and theta angles of particle 1 and 2 in lab coordinates [deg]
 returns opening angle [deg]

 returns opening angle [deg]

 returns opening angle [deg]

 returns opening angle [deg]

 loops over HParticleCand category and finds the closest partners of each candidate. set
 setAngleToNearbyFittedInner() and setAngleToNearbyUnfittedInner() of the candidates
 convention :  oAngle is positive if the closest partner had a ring match otherwise negative.
 Only opening Angles smaller oACut [Deg] are taken into account. Default opening Angles
 are set to -99. if sameSector = kTRUE (default) closest partners are searched in the
 same sector only. if skipSameSeg = kTRUE (default) candidates which share the same
 inner segment are ignored.

 loops over HParticleCand category and finds the closest partners of cand
 and fill them to vcand. the opening angles are filled in same order to vopeningAngles.
 Only opening Angles smaller oACut [Deg] are taken into account.
 if sameSector = kTRUE (default) closest partners are searched in the
 same sector only. if skipSameSeg = kTRUE (default) candidates which share the same
 inner segment are ignored. The candidates are sorted by inreasing opening angle.

 loops over HParticleCand category and finds the closest partners of cand
 and fill the inner seg Ind to vSeg.
 Only opening Angles smaller oACut [Deg] are taken into account.
 if sameSector = kTRUE (default) closest partners are searched in the
 same sector only. if skipSameSeg = kTRUE (default) candidates which share the same
 inner segment are ignored.
 The seg ind are sorted by inreasing opening angle.

 fills TLorentzVector vec from HGeantKine (if no id is provide id from
 kine will be used).
 CAUTION : vec.Phi() will be -pi to  pi  (-180 to +180 deg)
           To be compatibel with the HADES lab system phi (0-360 deg)
           one has to use
           HParticleTool::getLabPhiDeg(TLorentzVector& vec)

 fill v from cand. cand will be unmodified.
 user has to provide the mass. if the candidate has
 no reconstructed momentum the vector will be filled
 by angles only (enough for opening angle calculation, but invMass
 for such vectors will be wrong). FOR PARTICLES WITH CHARGE != 1
 USE fillTLorentzVector(TLorentzVector& v,HParticleCand* cand,Int_t pid,Bool_t correctMom=kTRUE)

 fill v from cand. cand will be unmodified.
 user has to provide the PID. if the candidate has
 no reconstructed momentum the vector will be filled
 by angles only (enough for opening angle calculation, but invMass
 for such vectors will be wrong). correctMom will
 switch to correction of momentum (HEnergylossCorrPar needed)
 The function takes care about particle charge != 1 when
 fill the momenta.

 CAUTION : vec.Phi() will be -pi to  pi  (-180 to +180 deg)
           To be compatibel with the HADES lab system phi (0-360 deg)
           one has to use shift negative values by 360deg

  return the global vertex position
  v can be Particle::kVertexCluster, Particle::kVertexSegment,
  Particle::kVertexParticle. In case of Particle::kVertexSegment
  and Particle::kVertexParticle the chi2 of the vertex fit is
  checked. If the the fit Particle::kVertexSegment failed the position of
  Particle::kVertexCluster is returned instead. If Particle::kVertexParticle
  fails Particle::kVertexSegment is used if possible otherwise fallback
  is Particle::kVertexCluster.

 scaling function for dy METAMATCH cut with 1/p  [GeV/c]
 par[0] a : dy at 1/p=0;
 par[1] slope per 1/p unit
 par[2] part2 : open window for very slow particles
 par[3] gain  : slope = slope*gain for 1/p > part2

 scaling function for dy METAMATCH cut with 1/p  [GeV/c]
 par[0] a : dy at 1/p=0    [mm];
 par[1] slope per 1/p unit
 par[2] part2 : open window for very slow particles
 par[3] gain  : slope = slope*gain for 1/p > part2
 TF1 is created with initial parameters HParticleTool::scaleDyPars[4] at
 first call of the function, dyCut [mm] will be used instead of scaleDyPars[0]
 if dyCut is positive.

 returns the half cell width for rpc cell in column col
 return -1 if out of bounds (col 0-5,cell 0-31)

 returns the half cell width for tof cell in module mod (addressing like data, not geom!)
 return -1 if out of bounds (mod 0-7, cell 0-7)

 returns kTRUE is the candidate matches in dy to the meta cell.
 returns kFALSE if the candidate has no meta. If the candidate has shower
 only it returns alway kTRUE. If doScaling = kTRUE a scaling with 1/p
 of bound is applied to account for multiple scattering of slow particles

 This function changes
 c->setMetaMatchQuality(metaDxnorm) (quality for dx only, dx unchanged);
 RK dx values will be normalized by correct width to alow
 for general treatment of cuts (RPC (clustersize 1 and 2, TOF and SIM)).
 supported beamtime = apr12 (default)

 This function does not change the candidate.
 it returns normalized RK dx value (including sign) to alow
 for general treatment of cuts (RPC (clustersize 1 and 2, TOF and SIM)).
 supported beamtime = apr12 (default)

 This function does not change the candidate.
 it returns sigma RK dx value to alow
 for general treatment of cuts (RPC (clustersize 1 and 2, TOF and SIM)).
 supported beamtime = apr12 (default)

 This function changes
 c->setMetaMatchQuality(metaDxnorm) (quality for dx only, dx unchanged);
 RK dx values will be normalized by correct width to alow
 for general treatment of cuts (RPC (clustersize 1 and 2, TOF and SIM)).

 This function does not change the candidate.
 it returns normalized RK dx value (including sign) to alow
 for general treatment of cuts (RPC (clustersize 1 and 2, TOF and SIM)).

 This function does not change the candidate.
 it returns sigma RK dx value to alow
 for general treatment of cuts (RPC (clustersize 1 and 2, TOF and SIM)).

 returns the corrected momenta (not changing the candidate)
 corrections: 1. systematic deviation for high momenta (obtained
 from simulation, applied for SIM+REAL) 2. correction for field map
 (obtained from apr12 data applied for REAL only).
 REMARK: NO ENERGYLOSS CORRECTION HERE!

 returns the corrected momenta (candidate is changed)
 corrections: 1. systematic deviation for high momenta (obtained
 from simulation, applied for SIM+REAL) 2. correction for field map
 (obtained from apr12 data applied for REAL only).
 REMARK: NO ENERGYLOSS CORRECTION HERE!

 return the delta eloss and sigma of particle assuming PID from
 the calibrated Mdc dedx vs beta curve. The functions takes
 into account the dependency of beta from energyloss (as function
 of theta .charge =1 and charge =2 are treated correct.
 The function makes use of HEnergyLossPar. You have to init
 the container before. Params are taken from apr12.

 this function checks for particle kine (and his decayed charged daughter it it exist)
 if the track is in the croped area of the layer. if the track has a hit
 but not in the layers to check (0 or 5, depending on first or last module in segment)
 it will be counted as croped if checkHit=kFALSE(default = kTRUE) otherwise not.
 The function returns true if any of the mdcs  was croped.
 if an pointer to Bool_t croped[4] is provided the crop results
 per module will be returned to the array.

 Id : see HPysicsConstants
 p [MeV/c]
 return beta

 Id : see HPysicsConstants
 return p [MeV/c]

 Id : see HPysicsConstants
 p [MeV/c]
 return gamma

 Id : see HPysicsConstants
 return beta

 Id : see HPysicsConstants
 return p [MeV/c]

 Id : see HPysicsConstants
 p [MeV/c]
 return beta*gamma

 Id : see HPysicsConstants
 return  p [MeV/c]

 Id : see HPysicsConstants input kinetic energy
 return  p [MeV/c]

 Id : see HPysicsConstants
 return  kinetic energy [MeV]

 function of MdcDedx used in TF1
 par[0] Id : see HPysicsConstants
 par[1] scale return val
 par[2] shift x (after scaling)
 par[3] scale x
 par[4] option:   0:p,1:beta,2:gamma,3:betagamma
 par[5] theta [deg]: do dedx corr for fixed theta .if <=0 don't do anything
 par[6]; frac of dedx corr
 return MDC dEdx

 function of beta / gamma  used in TF1
 par[0] Id : see HPysicsConstants
 par[1] scale return val
 par[2] shift x (after scaling)
 par[3] scale x
 par[4] option:   0:beta,1:gamma,2:betagamma
 par[5] theta [deg]: do dedx corr for fixed theta .if <=0 don't do anything
 par[6]; frac of dedx corr
 return beta or gamma or betagamma

 creates TCutG from upper and lower TF1 in range xlow to xup
 the x interval is splitted into npoints. User has to delete
 the TCutG objects

 return pt as function of y
 for fix theta or momenta of a particle

 calculates the intersection point of f1 and f2 in interval xlow,xup
 to vars xout, yout
 return kFALSE if no intersection was found (xout=yout=-10000)
 higher number of points n give better precision at the higher
 calculation time

 MdcDedx TF1
 name :  name of TF1 (default dedx, the id of the paricle will be appended)
 opt  :  p beta gamma betagamma

 par[0] Id : see HPysicsConstants
 par[1] scale return val
 par[2] shift x (after scaling)
 par[3] scale x
 par[4] option:   0:p,1:beta,2:gamma,3:betagamma
 par[5] theta [deg]: do dedx corr for fixed theta .if <=0 don't do anything
 par[6] fraction of dedx corr
 return TF1
 The user has to delete the TF1 object

 beta  / gamma  TF1
 name :  name of TF1 (default equals opt, the id of the paricle will be appended)
 opt  :  beta gamma betagamma

 par[0] Id : see HPysicsConstants
 par[1] scale return val
 par[2] shift x (after scaling)
 par[3] scale x
 par[4] option:   0:p,1:beta,2:gamma,3:betagamma
 par[5] theta [deg]: do dedx corr for fixed theta .if <=0 don't do anything
 par[6] fraction of dedx corr
 return TF1
 The user has to delete the TF1 object

 ptY TF1
 name :  name of TF1 (default opt, the d of the paricle will be appended)
 opt  :  theta momentum

 par[0] Id : see HPysicsConstants
 par[1] val
 par[2] midRap (default 0)
 par[3] option:   0:theta,1:momentum
 return TF1
 The user has to delete the TF1 object

 draws a pt -y grid for a give particle at given list of theta and momenta
 opt : draw drawcopy
 range xmin to xmax
 The created TF1 objects are return in a vector. The use has to delet them.

 Draw pt - y grid for particle id: lines for constant #theta and constant momentum

 setup:
 theta     :  format string "@theta:8,0,10"              : draw 8 lines starting from 0 deg with stepsize 10 deg
                            "@theta:-1,10,20,45,60,75"   : draw lines at list values (first entry has to be -1)
 momentum  :  format string "@momentum:8,100,200"        : draw 8 lines starting from 100 MeV/c with stepsize 200 MeV/c
                            "@momentum:-1,500,1000,1500" : draw lines at list values (first entry has to be -1)

 name      :  optional string for the name construction of TF1
 opt       :  ""            no draw
              "draw"        draw in current canvas
              "drawcopy"    draw a copy in current canvas
 xmin,xmax : rapidity range (default 0 - 2)
 midRap    : midRapidity    (default 0)
 linecolorTheta,lienstyleTheta : line attributes of theta    (default black,dashed)
 linecolorMom  ,lienstyleMom   : line attributes of momentum (default black,dashed)


 labels="@theta:draw=yes,format=%5.1f#circ,textsize=0.021,angle=0,align=-1@momentum:draw=yes,format=%5.1f MeV/c,textsize=0.023,angle=0,align=-1,yoff=0,02,xoff=0.01
      draw : yes (default)
     format: print format
   textsize: 0.021
     angle : 0
     align : -1(default: build in) sum of TTextAtributes:  kHAlignLeft   = 10, kHAlignCenter = 20, kHAlignRight = 30 ,kVAlignBottom = 1,  kVAlignCenter = 2,  kVAlignTop   = 3
      yoff : 0.02   offset from yaxis
      xoff : 0.01   offset from xaxis

 draws an already existing pt-y grid (see HParticleTool::ptyGrif())
 opt : draw drawcopy

 Calculates RMS of valNum numbers in valArr using the Mean of the values

 calculating the Determinant of a 3 x 3 Matrix
 with the column vectors [v1, v2, v3]
 using the RULE of SARRUS

 | v1(0)   v2(0)   v3(0) |      | v1(0) v2(0) v3(0)|v1(0) v2(0)  .
 |                       |      |  \\     \\     X   |  /     /    .
 |                       |      |   \\     \\   / \\  | /     /     .
 |                       |      |    \\     \\ /   \\ |/     /      .
 |                       |      |     \\     X     \\/     /       .
 |                       |      |      \\   / \\    /\\    /        .
 |                       |      |       \\ /   \\  / |\\  /         .
 | v1(1)   v2(1)   v3(1) |   =  | v1(1) v2(1) v3(1)|v1(1) v2(1)  .
 |                       |      |       / \\    /\\  | /\\          .
 |                       |      |      /   \\  /  \\ |/  \\         .
 |                       |      |     /     \\/    \\/    \\        .
 |                       |      |    /      /\\    /\\     \\       .
 |                       |      |   /      /  \\  / |\\     \\      .
 |                       |      |  /      /    \\/  | \\     \\     .
 | v1(2)   v2(2)   v3(2) |      | v1(2) v2(2) v3(2)| v1(2) v2(2) .
                                 /      /     /  \\     \\     \\   .

                                -      -     -    +     +     +  .

calculates the minimum distance of a point to a straight
given as parametric straight x = base + n * dir

calculates the point of minimum distance of a point to a straight
given as parametric straight x = base + n * dir

 calculates the minimum distance of two tracks given
 as parametric straights x = base + n * dir

  calculating point of closest approach

        from the equations of the straight lines of g and h
        g: x1 = base1 + l * dir1
        h: x2 = base2 + m * dir2

        you can construct the following planes:

        E1: e1 = base1  +  a * dir1  +  b * (dir1 x dir2)
        E2: e2 = base2  +  s * dir2  +  t * (dir1 x dir2)

        now the intersection point of E1 with g2 = {P1}
        and the intersection point of E2 with g1 = {P2}

        form the base points of the perpendicular to both straight lines.

        The point of closest approach is the middle point between P1 and P2:

        vertex = (p2 - p1)/2

        E1 ^ g2:

           e1 = x2
    -->    base1  +  a * dir1  +  b * (dir1 x dir2) = base2 + m * dir2
    -->    base1 - base2 = m * dir2  -  a * dir1  -  b * (dir1 x dir2)
                                          (m)
    -->    [ dir2, -dir1, -(dir1 x dir2)] (a) = base1 - base2
                                          (b)

           using CRAMER's RULE you can find the solution for m (a,b, not used)

           using the rules for converting determinants:

           D12 = det [dir2, -dir1, -(dir1 x dir2)]
               = det [dir2,  dir1,  (dir1 x dir2)]

           Dm  = det [base1 - base2, -dir1, -(dir1 x dir2)]
               = det [base1 - base2,  dir1,  (dir1 x dir2)]

            m  = Dm/D12

           P1: p1 = x2(m)
                  = base2 + Dm/D12 * dir2

        E2 ^ g1:

           e2 = x1
    -->    base2  +  s * dir2  +  t * (dir1 x dir2) = base1 + l * dir1
    -->    base2 - base1 = l * dir1  -  s * dir2  -  t * (dir1 x dir2)
                                          (l)
    -->    [ dir1, -dir2, -(dir1 x dir2)] (s) = base2 - base1
                                          (t)

           again using CRAMER's RULE you can find the solution for m (a,b, not used)

           using the rules for converting determinants:

           D21 =  det [dir1, -dir2, -(dir1 x dir2)]
               =  det [dir1,  dir2,  (dir1 x dir2)]
               = -det [dir2,  dir1,  (dir1 x dir2)]
               = -D12

           Dl  =  det [base2 - base1, -dir2, -(dir1 x dir2)]
               =  det [base2 - base1,  dir1,  (dir1 x dir2)]
               = -det [base1 - base2,  dir1,  (dir1 x dir2)]

            l  =   Dl/D21
               = - Dl/D12

           P2: p2 = x1(m)
                  = base1 - Dl/D12 * dir1


           vertex = p1 + 1/2 * (p2 - p1)
                  = 1/2 * (p2 + p1)
                  = 1/2 *( (base1 + base2) +  1/D12 * ( Dm * dir2 - Dl * dir1) )

 calculating cross point
 taking all three equations into account solving the overdetermined set of lin. equations
 of
 base1 + l * dir2 =  base1 + m * dir2

 set of lin. equations:

   base1(0) + l * dir1(0) = base2(0) + m * dir2(0)
   base1(1) + l * dir1(1) = base2(1) + m * dir2(1)
   base1(2) + l * dir1(2) = base2(2) + m * dir2(2) this line is ignored

   written in matrix form

        l \\                                                                  .
   M * |   | = base2 - base1
\\ m

   M is a 3x2 matrix

 to solve multiply the equation by the transposed Matrix of M from the left: M

  T      /  l \\                                                               .
 M * M * |    | = M  * (base2 - base1)
\\ -m
 MIND THE '-' of m

     / dir1(0) dir2(0) \\                                                      .
     |                 |    T   / dir1(0) dir1(1) dir1(2) \\                   .
 M = | dir1(1) dir2(1) |,  M  = |                         |
     |                 |        \\ dir2(0) dir2(1) dir2(2) /                   .
\\ dir1(2) dir2(2)

  T      / (dir1(0)*dir1(0) + dir1(1)*dir1(1) + dir1(2)*dir1(2))   (dir1(0)*dir2(0) + dir1(1)*dir2(1) + dir1(2)*dir2(2))  \\ .

 M * M = |                                                                                                                |

\\ (dir1(0)*dir2(0) + dir1(1)*dir2(1) + dir1(2)*dir2(2))   (dir2(0)*dir2(0) + dir2(1)*dir2(1) + dir2(2)*dir2(2))


  T       / d1d1 d1d2 \\                           .
 M  * M = |           |
\\ d1d2 d2d2

 diff = base2 - base1

  T           /  (dir1(0)*diff(0) + dir1(1)*diff(1) + dir1(2)*diff(2)) \\         .
 M  * diff =  |                                                        |
\\  (dir2(0)*diff(0) + dir2(1)*diff(1) + dir2(2)*diff(2))

  T           /  d1diff  \\                                          .
 M  * diff =  |          |
\\  d2diff

 now the new Matrix set is to be solved by CRAMER'S Rule:

 / d1d1 d1d2 \\   /  l \\   /  d1diff \\                   .
 |           | * |    | = |          |
\\ d1d2 d2d2 /   \\ -m /   \\  d2diff

     | d1d1 d1d2 |
 D = |           | = d1d1*d2d2 - d1d2*d1d2;
     | d1d2 d2d2 |

     | d1diff d1d2 |
 Dl= |              | = d1diff*d2d2 - d1d2*d2diff;
     | d2diff d2d2 |

 l = Dl/D = l_cross

 vertex = base1 + l_cross * dir1

 Calculates the Vertex of two straight lines defined by the vectors base and dir

      g: x1 = base1 + l * dir1
      h: x2 = base2 + m * dir2 , where l,m are real numbers
                                   h
 1. are g and h
       parallel / identical, i.e. are dir1 and dir2 linear dependent?

                                        /-
                                        |
                                        |   = 0    linear dependent, no unique solution, returning dummy
      => cross product : dir1 x dir2 = -|
                                        |  != 0    linear independent
                                        |
                                        \\-

 2. are g and h
       skew or do they have a crossing point, i.e are dir1, dir2 and (base1 - base2) linear dependent ?

                                                    /-
                                                    |
                                                    |   = 0    linear dependent
                                                    |          g and h are intersecting
                                                    |          calculating vertex as point of intersection
                                                    |
    => determinant: det[ dir1, dir2, base1-base2]= -|
                                                    |  != 0    linear independent
                                                    |          g and h are skew
                                                    |          calulating vertex as point of closest approach
                                                    |
                                                    \\-

 3.
    (a) calculating intersection point
    (b) calculating point of closest approach

 find the first track ID entering the TOF
 Used to suppress the secondaries created in the
 TOF itself.
        0 = realistic (secondaries included)
        1 primary particle is stored
        2 (default) the first track number entering the tof in SAME SECTOR is stored
        3 as 2 but condition on SAME SECTOR && MOD
        4 as 2 but SAME SECTOR && MOD && ROD

 Used to suppress the secondaries created in the
 SHOWER itself.
        0 = realistic (secondaries included)
        1 primary particle is stored
        2 the first track number entering the SHOWER in SAME SECTOR is stored
        3 the first track number entering the TOFINO in SAME SECTOR is stored
          or the primary track if no TOFINO was found
        4 (default) the first track number entering the TOFINO in SAME SECTOR is stored
          or the first track in SHOWER if no TOFINO was found

 Used to suppress the secondaries created in the
 SHOWER itself.
        0 = realistic (secondaries included)
        1 primary particle is stored
        2 the first track number entering the SHOWER in SAME SECTOR is stored
        3 the first track number entering the RPC in SAME SECTOR is stored
          or the primary track if no RPC was found
        4 (default) the first track number entering the RPC in SAME SECTOR is stored
          or the first track in SHOWER if no RPC was found

 retrieve content of 1-dim Hist corresponding to x val.
 The values will be linear interpolated. If warn == kTRUE
 warning will be emitted if the xval is out of the range
 of the hist. In case the value is out of range the value
 of first or last bin will be returned respectively.

 retrieve value from Histogram (1,2 and 3 dim) corresponding
 to x val, y val and z val.  If the values are out of range of
 the histogram axis the lowest/highest bin of the axis will be
 used. No interpolation performed.

 return HRichHit pointer from the object index
 in the category. In case of no success returns NULL

 return HTofHit pointer from the object index
 in the category. In case of no success returns NULL

 return HTofCluster pointer from the object index
 in the category. In case of no success returns NULL

 return HRpcCluster pointer from the object index
 in the category. In case of no success returns NULL

 return HShowerHit pointer from the object index
 in the category. In case of no success returns NULL

 return HEmcCluster pointer from the object index
 in the category. In case of no success returns NULL

 return HMetaMatch2 pointer from the object index
 in the category. In case of no success returns NULL

 return HMdcTrkCand pointer from the object index of MetaMatch2
 in the category (indMeta->HMetaMatch2->HMdcTrkCand). In case of
 no success returns NULL

 return HMdcSeg pointer from the object index
 in the category. In case of no success returns NULL

 return HMdcHit pointer from the object index of HMdcSeg
 in the category (indSeg->HMdcSeg->HMdcHit). nhit (0 or 1)
 is the number of the hit inside the segment which should
 be retrived. In case of no success returns NULL

 return HMdcClusInf pointer from the object index of HMdcSeg
 in the category (indSeg->HMdcSeg->HMdcClusInf). nhit (0 or 1)
 is the number of the hit inside the segment which should
 be retrived. In case of no success returns NULL

 return HMdcClusFit pointer from the object index of HMdcSeg
 in the category (indSeg->HMdcSeg->HMdcClsuInf->HMdcClusFit).
 In case of no success returns NULL

 return HMdcClus pointer from the object index of HMdcSeg
 in the category (indSeg->HMdcSeg->HMdcClus).
 In case of no success returns NULL

 return TObjArray pointer to an array of HMdcWireFit
 pointer from the object index of HMdcSeg
 in the category (indSeg->HMdcSeg->HMdcClusInf->HMdcClusFit->HMdcWireFit).
 The user has to delete the TObjArray object
 (not the content) by himself.

 fill vector of HMdcWireFit
 pointer from the object index of HMdcSeg
 in the category (indSeg->HMdcSeg->HMdcClusInf->HMdcClusFit->HMdcWireFit).
 The user has to delete the TObjArray object
 (not the content) by himself. Returns the number of
 collected objects .the vector will be cleared
 if clear=kTRUE

 return TObjArray pointer to an array of HMdcCal1
 pointer from the object index of HMdcSeg
 in the category (indSeg->HMdcSeg->HMdcCal1).
 user has to delete the TObjArray object
 (not the content) by himself.

 fill vector of HMdcCal1
 pointer from the object index of HMdcSeg
 in the category (indSeg->HMdcSeg->HMdcCal1).
 user has to delete the TObjArray object
 (not the content) by himself. Returns number
 of collected objects. the vector will be cleared
 if clear=kTRUE

 return TObjArray pointer to an array of HMdcCal1
 pointer from the object index of HMdcSeg
 in the category (indSeg->HMdcSeg->HMdcClus->HMdcCal1).
 user has to delete the TObjArray object
 (not the content) by himself.

 fill vector of HMdcCal1
 pointer from the object index of HMdcSeg
 in the category (indSeg->HMdcSeg->HMdcClus->HMdcCal1).
 user has to delete the TObjArray object
 (not the content) by himself. Returns the number
 of collected objects. The vector will be cleared
 if clear=kTRUE

 evalutates the bitwise flags defined in eClosePairSelect (hparticledef.h)
 for cand1 (reference for closePair) and cand2. cand1 can be NULL, the comparison
 for same detector hits will be skipped then.

 evalutates the bitwise flags defined in flag (see eClosePairSelect + ePairCase (hparticledef.h)
 against fl. return kTRUE if all set bit in flag are set in fl too.

 evalutates the bitwise flags defined fl (see eClosePairSelect + ePairCase (hparticledef.h))
 return kTRUE if all set bits in fl are set in flags too

 evalutates the bitwise flags defined in eClosePairSelect + ePairCase (hparticledef.h)
 return kTRUE if one of the flags in vector flags are identical. The result for
 each individual flag is store in vector results (which will be automaticly cleared before).

 evalutates the bitwise flags defined in eClosePairSelect + ePairCase (hparticledef.h)
 return kTRUE if one of the flags in vector flags are identical.

 request good chi2 and a z pos > minZ (apr12 typically -65 mm, jul14/aug14 -200)
 minZ is given in mm
 if minZ > 0 gHades is used to retrieve the beamTimeID default values

 request good chi2 and a z pos > minZ (apr12 typically -65 mm)
 minZ is given in mm. For good chi2 at least 2 particle cands are needed.
 if minZ > 0 gHades is used to retrieve the beamTimeID default values

 request existing start hit object and starthit->getCorrFlag()>=minFlag
 REMARK : corrFlags are filled by HParticleStart2HitF (-1,0,1,2).
 In this case HStart2Hit::getIteration() (0,1,2) gives 2. For Iteration
 <2 corrFlags are not checked
 return kFALSE if category is not available

 return kTRUE if no VETO hit inside timewindow minStart-maxStart [ns]
 relative to starttime was found. otherwise kFALSE.
 requires  catStart2Cal catStart2Hit
 return kFALSE if category is not available

 return kTRUE if no START hit inside timewindow minStart-maxStart [ns] of the
 START time was found. otherwise kFALSE. (startime +- window excluded)
 requires catStart2Hit and catStart2Cal
 return kFALSE if categories are not available

 return kTRUE is no starthit between minStart [ns] and maxStart [ns]
 has been found which has no correlation with VETO inside window [ns]
 +-window arround starthit startime is excluded.
 requires catStart2Hit + catStart2Cal category. If the categories are
 not available kFALSE  is returned.

 search for metahits inside the event which are correlated with
 late starthits.
 return kTRUE if in range minStart [ns] to maxStart [ns] of START Hits
 not more than tresh metahits inside correlation window [ns] are found.
 offset [ns](apr12 = 7) has to be adjusted to move the fastest particles
 of good triggered event to 0.
 requires catRpcHit, catTofHit, catStart2Cal, catStart2Hit. if any of those is missing kFALSE
 is returned.

 request existing start hit object and starthit->getMultiplicity()==1
 return kFALSE if categories are not available

 loops TofHit and RpcCluster and counds objects with tof < 0
 or tof > ftimeTofCut. if n > threshold (pileup) kFALSE is returned
 if tofhit and rpccluster cateories are not available kTRUE is returned
 if threshold < 0 gHades is used to retrieve the beamTimeID default values

 test if the triggerbit is set ( bit number is pt (physics trigger) + 10)
 example : pt3 -> 13
 if triggerbit < 0 gHades is used to retrieve the beamTimeID default values

 return the TofHit multiplicity between minTof and maxTof. if sector
 (pointer to Int_t sector[6]) is not NULL sectorwise mult is filled.
 the array is rest to 0 before. requires catTofHit

 return the RpcHit multiplicity between minTof and maxTof. if sector
 (pointer to Int_t sector[6]) is not NULL sectorwise mult is filled.
 the array is rest to 0 before. requires catRpcHit.