Photos.h

Go to the documentation of this file.

#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::vector;
using std::pair;

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