PhotosParticle.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".              *
//****************************************************************************

//****************************************************************************
//*                   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 _PhotosParticle_h_included_
#define _PhotosParticle_h_included_

#include <vector>
#include "Photos.h"

namespace Photospp {

class PhotosParticle {
 public:
  static const int STABLE = 1;

  static const int DECAYED = 2;

  static const int HISTORY = 3;

  static const int X_AXIS = 1;

  static const int Y_AXIS = 2;

  static const int Z_AXIS = 3;

  static const int Z0 = 23;

  static const int HIGGS = 25;

  static const int HIGGS_H = 35;

  static const int HIGGS_A = 36;

  static const int HIGGS_PLUS = 37;

  static const int HIGGS_MINUS = -37;

  static const int W_PLUS = 24;

  static const int W_MINUS = -24;

  static const int GAMMA = 22;

  static const int TAU_PLUS = -15;

  static const int TAU_MINUS = 15;

  static const int TAU_NEUTRINO = 16;

  static const int TAU_ANTINEUTRINO = -16;

  static const int MUON_PLUS = -13;

  static const int MUON_MINUS = 13;

  static const int MUON_NEUTRINO = 14;

  static const int MUON_ANTINEUTRINO = -14;

  static const int POSITRON = -11;

  static const int ELECTRON = 11;

  static const int ELECTRON_NEUTRINO = 12;

  static const int ELECTRON_ANTINEUTRINO = -12;

  static const int UP = 2;

  static const int ANTIUP = -2;

  static const int DOWN = 1;

  static const int ANTIDOWN = -1;

  static const int OTHER = 0;

 public:
  virtual ~PhotosParticle(){};

  bool hasDaughters();

  PhotosParticle *findLastSelf();

  std::vector<PhotosParticle *> findProductionMothers();

  std::vector<PhotosParticle *> getDecayTree();

  void boostToRestFrame(PhotosParticle *boost);

  void boostDaughtersToRestFrame(PhotosParticle *boost);

  void boostFromRestFrame(PhotosParticle *boost);

  void boostDaughtersFromRestFrame(PhotosParticle *boost);

  void boostAlongZ(double pz, double e);

  void rotate(int axis, double phi, int second_axis = Z_AXIS);

  void rotateDaughters(int axis, double phi, int second_axis = Z_AXIS);

  double getRotationAngle(int axis, int second_axis = Z_AXIS);

  double getP();

  double getP(int axis);

  void setP(int axis, double p_component);

  virtual double getVirtuality();

 public:
  virtual bool checkMomentumConservation() = 0;

  virtual double getPx() = 0;

  virtual double getPy() = 0;

  virtual double getPz() = 0;

  virtual double getE() = 0;

  virtual double getMass() = 0;

  virtual void setPx(double px) = 0;

  virtual void setPy(double py) = 0;

  virtual void setPz(double pz) = 0;

  virtual void setE(double e) = 0;

  virtual void setMothers(std::vector<PhotosParticle *> mothers) = 0;

  virtual void setDaughters(std::vector<PhotosParticle *> daughters) = 0;

  virtual void addDaughter(PhotosParticle *daughter) = 0;

  virtual std::vector<PhotosParticle *> getMothers() = 0;

  virtual std::vector<PhotosParticle *> getDaughters() = 0;

  virtual std::vector<PhotosParticle *> getAllDecayProducts() = 0;

  virtual void setPdgID(int pdg_id) = 0;

  virtual void setMass(double mass) = 0;

  virtual void setStatus(int status) = 0;

  virtual int getPdgID() = 0;

  virtual int getStatus() = 0;

  virtual int getBarcode() = 0;

  virtual PhotosParticle *createNewParticle(int pdg_id, int status, double mass, double px, double py, double pz, double e) = 0;

  virtual void createHistoryEntry() = 0;

  virtual void createSelfDecayVertex(PhotosParticle *out) = 0;

  virtual void print() = 0;
};

} // namespace Photospp
#endif