PDistribution.h

Go to the documentation of this file.

// Author: I. Froehlich
// Written: 3.7.2006
// Revised:
// Base class for common distributions
 
#ifndef _PDISTRIBUTION_H_
#define _PDISTRIBUTION_H_
 
#define MAX_PARTICLE_LIST              10
#define PARTICLE_LIST_DAUGHTER         1
#define PARTICLE_LIST_PARENT           2
#define PARTICLE_LIST_GRANDPARENT      4
#define PARTICLE_LIST_GRANDGRANDPARENT 8
#define PARTICLE_LIST_GRANDDAUGHTER    16
#define PARTICLE_LIST_SIBLING          128
 
#define DISTRIBUTION_QUASI_PID     1000
#define DISTRIBUTION_SOMETHING_PID 2000
#define DISTRIBUTION_NUCLEON_PID   3000
 
//Flags for sampling, generator, etc.
#define VERSION_SAMPLING          1
#define VERSION_WEIGHTING         2
#define VERSION_INVERT_WEIGHTING  4
#define VERSION_MASS_SAMPLING     128
#define VERSION_IS_PRIMARY        256
#define VERSION_GENERATOR_MC      512
#define VERSION_NO_PHASE_SPACE    1024
#define VERSION_FORCE_NO_PARTIAL_WIDTH    2048
 
#include "TF1.h"
#include "TF2.h"
#include "PParticle.h"
#include "PData.h"
#include "PUtils.h"
 
 
class PDistribution : public TF1 {
 
 public:
 
    PDistribution();
    PDistribution(const Char_t *id, const Char_t *de);
    virtual ~PDistribution();
 
    virtual PDistribution* Clone(const char *delme=NULL) const;
 
    Int_t Add(const Char_t *opt);
    Int_t Add(const Char_t *name, int flag,
          const Char_t *pflag);  //Adds a particle placehoulder to the list
 
    Int_t Add(const Char_t *name, const Char_t *flag1,
          const Char_t *flag2 = NULL, const Char_t *flag3 = NULL);
    //Helper function
 
    Int_t Set(const Char_t *opt);
    Int_t Set(const Char_t *name, const Char_t *pflag); //Like Add(), but rather replace it
 
    void Reset(void);
 
    Int_t SetParticle(PParticle *part, int pid, int flag);
    //Replaces the pointer for the given particle
    //This function should be called from PChannel
 
    void ResetRelatives(Int_t flag = 0);
    const char *GetGroupID(void) { //Some wish where I want to go to...
    return group;
    };
    void SetGroupID(const char *gr) {
    group=gr;
    }
 
    PParticle *GetParticle(const Char_t *pflag=NULL); //get the particly with the private flag
 
    Int_t GetStatus(void); //returns 0 if all particles are set
    Int_t CheckDaughters(void) ; //returns 0 if all daughters are set
    void  NoDaughters(void) {no_daughters=1;};
    void  ResetStatus(void);  //Clean setted particles
 
    virtual void Print(const Option_t *delme=NULL) const ;  //Debug info
    void BasePrint(void) const ;  //Debug info
    const Char_t *OptString(void) {return opt_string;};
    virtual void SubPrint(Int_t opt) const ;  //Print sub-models
    const Char_t *Path(void) const; //print path for models
 
    const Char_t *GetIdentifier(void)  {return identifier;};
    const Char_t *GetDescription(void) {return description;};
 
    void  SetEnable(Int_t en)    {enable=en;};
    Int_t GetEnable(void)        {return enable;};
    void  SetActivated(Int_t en) {is_activated=en;};
    Int_t GetActivated(void)     {return is_activated;};
 
    void  SetVersionFlag(Int_t f)   {version_flag |= f;};
    void  ClearVersionFlag(Int_t f) {version_flag &= (~f);};
    UInt_t GetVersionFlag(UInt_t f = 0xffffffff)  const {
    return version_flag & f;
    };
 
 
    /* the following tool functions set different versions */
    void DisableSampling(void) {
    ClearVersionFlag(VERSION_SAMPLING);
    }; //No Sampling in the GenBod
 
    void EnableGenerator(void) {
    ClearVersionFlag(VERSION_WEIGHTING);
    SetVersionFlag(VERSION_INVERT_WEIGHTING);
    }; //Use distribution as a generator
 
    void EnableWeighting(void) {
    ClearVersionFlag(VERSION_SAMPLING);
    SetVersionFlag(VERSION_WEIGHTING);
    }; //Use distribution as a generator
 
    virtual Bool_t FreezeOut(void);
 
    virtual Bool_t Init(void);
 
    virtual Bool_t Prepare(void);
 
    virtual Bool_t SampleMass(void);
 
    virtual Bool_t SampleMomentum(void);
 
    virtual Bool_t SampleAngle(void);
 
    virtual Bool_t IsNotRejected(void);
 
    virtual Bool_t CheckAbort(void);
 
    virtual Bool_t Finalize(void);
 
    virtual Bool_t EndOfChain(void);
 
    virtual Double_t GetWeight(void);
 
    virtual Bool_t WriteDebugInfo(PParticle *par);
 
    Int_t GetKey(void) {
    return primary_key;
    };
    void SetDecayIdx(Int_t opt) {didx_option=opt;};
 
    virtual int GetDepth(int i=0);
 
    int LinkDBdone(void)   {return linkdbdone;};
    void LinkDBdone(int i) {linkdbdone=i;};
 
    void IncrementWeightSum(Double_t w, Double_t sc=1.) {
//  if (w_num && (sc>(w_num  *1.1))) return;
 
    w_sum += w*sc;
    w_num += sc;
    };
 
    Double_t GetExpectedWeightMean() {
    //For PChannelModels: ExpectedWeightMean is set to the
    //static branching ratio
 
    return exp_w_mean;
    };
 
    void SetExpectedWeightMean(Double_t w) {
    exp_w_mean = w;
    };
 
    Double_t CalcWeightMean() {
    return w_sum/w_num;
    }
 
    void SetWeightMax(Double_t w) {
    w_max = w;
    }
 
    Double_t GetWeightMax(void) {
    return w_max;
    }
 
    Double_t GetDynamicRange() {
    //Used to get the Delta_x for the Monte-Carlo Integral
    return dynamic_range;
    };
 
    Bool_t Exec(const char * command);
    virtual Bool_t ExecCommand(const char *command, Double_t value);
 
    Int_t  debug_flag;
 
    void PreParticles(void) {preliminary_particles = 1;};
 
    void SetDrawScaling(Double_t my_draw_scaling) {draw_scaling = my_draw_scaling;};
 
 protected:
 
    const Char_t *identifier, *description;
    Int_t enable, is_activated;
    char *parse[4];  //Option strings
    Int_t parse_s; //max 4 options
 
    PParticle    *particle[MAX_PARTICLE_LIST];
    const Char_t *names[MAX_PARTICLE_LIST];
    const Char_t *private_flag[MAX_PARTICLE_LIST];
    const Char_t *private_flag_int[MAX_PARTICLE_LIST];
    const Char_t *opt_string;
    Int_t particle_flag[MAX_PARTICLE_LIST], pid[MAX_PARTICLE_LIST];
    Int_t position, current_flag;
 
    Int_t primary_key;   //Model coupled to data base key
    Int_t model_def_key; //Model type definition key
    Int_t sec_key;       //Key if secondary model (tmp)
 
    Int_t didx_option;  //Model has target didx
 
    Int_t preliminary_particles; //Used for auto-Adds in PChannelModel
 
    Int_t GetFlag(const Char_t *flag);
    const Char_t *group;     //Group ID
    Int_t linkdbdone;
    Int_t no_daughters;
    UInt_t version_flag, relative_warning;
 
    Double_t w_sum, exp_w_mean, w_num, dynamic_range; //For weighting method
    Double_t w_max;
    Double_t draw_scaling;
 
    ClassDef(PDistribution,0) //Base class for all distributions
 
};
 
#endif