Photos.h

#ifndef _Photos_h_included_
#define _Photos_h_included_
 
#include <stdarg.h>
#include <vector>
#include "PhotosParticle.h"
#include "PhotosRandom.h"
#include "photosC.h"
// WARNING: VARIANT B of phase space generation was not tested in C++ for all
// options of the program initialization..
//#define VARIANTB true
using std::vector;
using std::pair;
 
namespace Photospp {
 
  class PhotosParticle;
 
  class Photos {
  public:
    static const int VER_MAJOR = 3, VER_MINOR = 64;
    static const int DAT_DAY  = 18, DAT_MONTH = 2, DAT_YEAR = 20;
 
    static enum MomentumUnits { DEFAULT_MOMENTUM = -1, MEV, GEV } momentumUnit;
 
 
  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 IPHEKL_setPi0KLnoEmission(int m);
 
    static bool IPHQRK_setQarknoEmission(int MODCOR, int PDGID);
 
    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 setPairEmission(bool ifpair);
 
    static void setPhotonEmission(bool ifphot);
 
    static void setMeCorrectionWtForScalar(bool corr);
 
    static void setMeCorrectionWtForW(bool corr);
 
    static void setMeCorrectionWtForZ(bool corr);
 
    static void setTopProcessRadiation(bool top)         { phokey.iftop = (int)top; }
 
    static void setMomentumUnit(MomentumUnits unit)      { momentumUnit = unit; }
 
    /* 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; }
 
    static void setEventNo(int iEvt) {EventNo = iEvt; }
  public:
 
 
    static int EventNo;
 
    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 bool IfPair;
 
    static bool IfPhot;
 
 
    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