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=61;
        static const int DAT_DAY  =29, DAT_MONTH=9, DAT_YEAR=15;
    
        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