RhoEventShapes.h

Go to the documentation of this file.

//****************************************************************************
//*                   This file is part of PandaRoot.                        *
//*                                                                          *
//*            PandaRoot is distributed under the terms of the               *
//*              GNU General Public License (GPL) version 3,                 *
//*                 copied verbatim in the file "LICENSE".                   *
//*                                                                          *
//*  Copyright (C) 2006 - 2024 FAIR GmbH and copyright holders of PandaRoot  *
//*     The copyright holders are listed in the file "COPYRIGHTHOLDERS".     *
//*               The authors are listed in the file "AUTHORS".              *
//****************************************************************************

#ifndef RHOEVENTSHAPES_H
#define RHOEVENTSHAPES_H
//                                                                      //
// RhoEventShapes                                                       //
//                                                                      //
// Functions to calculate the event & event shape variables             //
//                                                                      //
// Author List:                                                         //
// Klaus Goetzen, GSI, May 2013                                         //
// Ralf Kliemt, HIM/GSI May.2013                                        //
//                                                                      //

#include "TLorentzVector.h"
#include "TVector3.h"
#include "TMatrixD.h"
#include "TMatrixDEigen.h"
#include "RhoCandList.h"

#define FWMAX 6 // maximum Fox Wolfram moment

class RhoEventShapes {
 public:
  RhoEventShapes(RhoCandList &l, TLorentzVector cms);
  virtual ~RhoEventShapes(){};

  // ******* multiplicities
  int NParticles() const { return fN; }   // number of particle candidates
  int NCharged() const { return fnChrg; } // number of charged candidates
  int NNeutral() const { return fnNeut; } // number of neutral candidates

  // ******* maxima of momenta
  double PmaxLab() const { return fpmaxlab; } // max momentum in lab system
  double PmaxCms() const { return fpmaxcms; } // max momentum im cms system
  double Ptmax() const { return fptmax; }     // max pt (same for lab and cms)

  // ******* sum of energies/momenta (lab system)
  double PtSumLab() const { return fptsumlab; }         // sum of pt in (lab)
  double NeutEtSumLab() const { return fneutetsumlab; } // sum of transvers energys of neutrals (lab)
  double NeutESumLab() const { return fneutesumlab; }   // sum of energys of neutrals (lab)
  double ChrgPtSumLab() const { return fchrgptsumlab; } // sum of pt of charged (lab)
  double ChrgPSumLab() const { return fchrgpsumlab; }   // sum of momenta of charged (lab)

  // ******* sum of energies/momenta (cms system)
  double PtSumCms() const { return fptsumcms; }         // sum of pt in (lab)
  double NeutEtSumCms() const { return fneutetsumcms; } // sum of transvers energys of neutrals (lab)
  double NeutESumCms() const { return fneutesumcms; }   // sum of energys of neutrals (lab)
  double ChrgPtSumCms() const { return fchrgptsumcms; } // sum of pt of charged (lab)
  double ChrgPSumCms() const { return fchrgpsumcms; }   // sum of momenta of charged (lab)

  // ******* multiplicities with threshold
  int MultPminLab(double pmin); // number of particles with p>pmin (lab frame)
  int MultPmaxLab(double pmax); // number of particles with p<pmax (lab frame)
  int MultPminCms(double pmin); // number of particles with p>pmin (cms frame)
  int MultPmaxCms(double pmax); // number of particles with p<pmax (cms frame)

  // ******* shape variables
  double Sphericity(); // Sphericity
  double Aplanarity(); // Aplanarity
  double Planarity();  // Planarity

  double FoxWolfMomH(int order); // Fox Wolfram moment absolute H_i
  double FoxWolfMomR(int order); // Fox Wolfram moment relative R_i = H_i/H_0

  double Thrust();
  TVector3 ThrustVector();

 private:
  void ComputeSphericity();                                                              // compute sph, apl, pla
  double Eps(const TVector3 v1, const TVector3 v2) { return (v1 * v2) > 0. ? 1. : -1.; } // aux for Thrust
  double Legendre(int l, double x);                                                      // Legendre function; auxilliary for Fox Wolfram moments

  std::vector<TLorentzVector> fLabList; 
  std::vector<TLorentzVector> fCmsList; 
  std::vector<int> fCharge;             

  int fnChrg; // number of charged particles
  int fnNeut; // number of neutral particles
  int fN;     // number of particles

  double fpmaxlab; // maximum momentum lab frame
  double fpmaxcms; // maximum momentum cms frame
  double fptmax;   // maximum transvers momentum

  double fptsumlab;     // sum of pt in (lab)
  double fneutetsumlab; // sum of transvers energys of neutrals (lab)
  double fneutesumlab;  // sum of energys of neutrals (lab)
  double fchrgptsumlab; // sum of pt of charged (lab)
  double fchrgpsumlab;  // sum of momenta of charged (lab)

  double fptsumcms;     // sum of pt in (lab)
  double fneutetsumcms; // sum of transvers energys of neutrals (lab)
  double fneutesumcms;  // sum of energys of neutrals (lab)
  double fchrgptsumcms; // sum of pt of charged (lab)
  double fchrgpsumcms;  // sum of momenta of charged (lab)

  double fsph; // Sphericity
  double fapl; // Aplanarity
  double fpla; // Planarity

  double fFWmom[FWMAX + 1]; // Fox Wolfram moments up to FWMAX
  bool fFWready;            // did we compute FW moments?

  double fthr;       // thrust
  TVector3 fThrVect; // direction of thrust
  TVector3 fBoost;   // boost vector to go to requested frame

  bool fNeutralOnly; // only compute for neutrals
  bool fChargedOnly; // only compute for charged

 public:
  ClassDef(RhoEventShapes, 1);
};
#endif