Photos.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 _Photos_h_included_
#define _Photos_h_included_

#include <stdarg.h>
#include <vector>
#include "PhotosParticle.h"
#include "PhotosRandom.h"
#include "f_Init.h"
using std::pair;
using std::vector;

namespace Photospp {

class PhotosParticle;

class Photos {
 public:
  static const int VER_MAJOR = 3, VER_MINOR = 52;
  static const int DAT_DAY = 4, DAT_MONTH = 11, DAT_YEAR = 12;

 public:
  static void initialize();

  static void iniInfo();

  static void processParticle(PhotosParticle *p);
  static void processBranch(PhotosParticle *p);

  static void suppressBremForDecay(int count, int motherID, ...);
  static void suppressBremForBranch(int count, int motherID, ...);

  static void suppressAll() { isSuppressed = true; }

  static void forceBremForDecay(int count, int motherID, ...);

  static void forceBremForBranch(int count, int motherID, ...);

  static void createHistoryEntries(bool flag, int status);

  static void ignoreParticlesOfStatus(int status);

  static void deIgnoreParticlesOfStatus(int status);

  static bool isStatusCodeIgnored(int status);

 public:
  static void setRandomGenerator(double (*gen)());

  static void setSeed(int iseed1, int iseed2) { PhotosRandom::setSeed(iseed1, iseed2); }

  static void maxWtInterference(double interference) { phokey_.fint = interference; }

  static void setInfraredCutOff(double cut_off) { phocop_.xphcut = cut_off; }

  static void setAlphaQED(double alpha) { phocop_.alpha = alpha; }

  static void setInterference(bool interference) { phokey_.interf = (int)interference; }

  static void setDoubleBrem(bool doub) { phokey_.isec = (int)doub; }

  static void setQuatroBrem(bool quatroBrem) { phokey_.itre = (int)quatroBrem; }

  /* Key for partial effects of  matrix element (in leptonic W decays) */
  static void setCorrectionWtForW(bool corr) { phokey_.ifw = (int)corr; }

  static void setExponentiation(bool expo);

  static void setMeCorrectionWtForScalar(bool corr);

  static void setMeCorrectionWtForW(bool corr);

  static void setMeCorrectionWtForZ(bool corr);

  static void setTopProcessRadiation(bool top) { phokey_.iftop = (int)top; }

  /* Set if PHOTOS should stop at critical error. True by default.
     WARNING: These stops are an essential source of debugging information flow
                    from event record to PHOTOS algorithm. Never switch it off! The only exception:
              you have checked your set-up including particular physics initialization
                    with the substantially large sample and you submit large production. */
  static void setStopAtCriticalError(bool stop);

  static void initializeKinematicCorrections(int flag) { phcork_(&flag); }

  static void forceMassFrom4Vector(bool flag) { massFrom4Vector = flag; }

  static void forceMassFromEventRecord(int pdgid);

  static void forceMass(int pdgid, double mass);

  static void setMomentumConservationThreshold(double threshold) { momentum_conservation_threshold = threshold; }

 public:
  static bool isSuppressed;

  static bool massFrom4Vector;

  static vector<vector<int> *> *supBremList;

  static vector<vector<int> *> *forceBremList;

  static vector<pair<int, double> *> *forceMassList;

  static vector<int> *ignoreStatusCodeList;

  static double momentum_conservation_threshold;

  static bool meCorrectionWtForScalar;

  static bool meCorrectionWtForZ;

  static bool meCorrectionWtForW;

  static bool isCreateHistoryEntries;

  static int historyEntriesStatus;

  static double (*randomDouble)();

 public:
  Photos &getInstance() { return _instance; }

 private:
  /* Singleton: only one instance allowed.
     Constructor sets default values of PHOTOS parameters */
  Photos();
  ~Photos() {}
  Photos(const Photos &);
  Photos &operator=(const Photos &);
  static Photos _instance;
};

} // namespace Photospp
#endif