ERIonGenerator.h

/********************************************************************************
 *              Copyright (C) Joint Institute for Nuclear Research              *
 *                                                                              *
 *              This software is distributed under the terms of the             *
 *         GNU Lesser General Public Licence version 3 (LGPL) version 3,        *
 *                  copied verbatim in the file "LICENSE"                       *
 ********************************************************************************/

#ifndef ERIonGenerator_H
#define ERIonGenerator_H

#include "Rtypes.h"
#include "TMath.h"

#include "FairGenerator.h"

class FairIon;
class FairPrimaryGenerator;

class ERIonGenerator : public FairGenerator
{

  public:

    ERIonGenerator();

    ERIonGenerator(const Char_t* ionName, Int_t mult);

    ERIonGenerator(TString name, Int_t z, Int_t a, Int_t q, Int_t mult);

    virtual ~ERIonGenerator();

    void SetCharge(Int_t charge) {fQ=charge;}

    void SetExcitationEnergy(Double_t eExc);

    void SetPDGType      (Int_t pdg)  {fPDGType = pdg;  };

    void SetMultiplicity (Int_t mult) {fMult    = mult; };

    void SetPRange(Double32_t pmin = 0   , Double32_t pmax = 10)
    {fPMin=pmin; fPMax=pmax; fPRangeIsSet=kTRUE;}

    void SetPtRange      (Double32_t ptmin = 0   , Double32_t ptmax = 10)
    {fPtMin=ptmin; fPtMax=ptmax; fPtRangeIsSet=kTRUE;};

    void SetPhiRange     (Double32_t phimin = 0  , Double32_t phimax = 360)
    {fPhiMin=phimin; fPhiMax=phimax;};

    void SetEtaRange     (Double32_t etamin = -5 , Double32_t etamax = 7)
    {fEtaMin=etamin; fEtaMax=etamax; fEtaRangeIsSet=kTRUE;};

    void SetYRange(Double32_t ymin = -5., Double32_t ymax = 7.)
    { fYMin=ymin; fYMax=ymax; fYRangeIsSet=kTRUE; }

    void SetThetaRange(Double32_t thetamin = 0., Double32_t thetamax = 90.)
    { fThetaMin=thetamin; fThetaMax=thetamax; fThetaRangeIsSet=kTRUE; }

    void SetThetaSigma(Double32_t theta = 0., Double32_t sigmaTheta = 1.)
    {
      fGausTheta = theta;
      fSigmaTheta = sigmaTheta;
      fSigmaThetaIsSet = kTRUE;
    }

    void SetCosTheta   ()
    {fCosThetaIsSet=kTRUE;};

    void SetXYZ   (Double32_t x = 0, Double32_t y = 0, Double32_t z = 0) {
      fX=x;
      fY=y;
      fZ=z;
      fPointVtxIsSet=kTRUE;
    }

    void SetRoundXY (Double32_t rho = 0, 
                     Double32_t centerX = 0, 
                     Double32_t centerY = 0,
                     Double32_t centerZ = 0) 
    {
      fRho = rho;
      fCenterX = centerX;
      fCenterY = centerY;
      fZ = centerZ;
      fRoundXYIsSet=kTRUE;
    }

    void SetBoxXYZ (Double32_t x1=0, Double32_t y1=0, Double32_t x2=0, Double32_t y2=0, Double32_t z=0) {
      fX1=x1;
      fY1=y1;
      fX2=x2;
      fY2=y2;
      fZ=z;
      fBoxVtxIsSet=kTRUE;
    }

    void SetSigmaXYZ(Double32_t x=0, Double32_t y=0, Double32_t z=0,
                    Double32_t sigmaX=1, Double32_t sigmaY=1)
    {
      fGausX = x;
      fGausY = y;
      fSigmaX = sigmaX;
      fSigmaY = sigmaY;
      fZ = z;
      fBoxSigmaIsSet = kTRUE;
    }

    void SetKinERange(Double32_t kinEMin, Double32_t kinEMax);

    void SetKinESigma(Double32_t kinE, Double32_t sigmaKinE); 


    void SetKinE(Double32_t kinE);

    void SetPSigmaOverP(Double32_t sigmaPOverP) { fSigmaP = sigmaPOverP*fGausP; fSigmaPIsSet = kTRUE;}

    void SetPSigma(Double32_t p = 0 , Double32_t sigma = 1)
    {fGausP=p; fSigmaP=sigma; fSigmaPIsSet=kTRUE;}

    void SetDebug(Bool_t debug=0) {fDebug = debug;}

    void SpreadingOnTarget(void) {fSpreadingOnTarget = kTRUE;}

    FairIon* Ion() {return fIon;}

  public:
    virtual Bool_t ReadEvent(FairPrimaryGenerator* primGen);


  protected:
    void SpreadingParameters(void);

  protected:
    Int_t      fMult;                
    FairIon*   fIon;                 
    Int_t      fQ;                   

    TString    fName;                
    Int_t      fPDGType;             

    Double32_t fIonMass;             
    Double32_t fPtMin, fPtMax;      
    Double32_t fPhiMin, fPhiMax;     
    Double32_t fEtaMin, fEtaMax;     
    Double32_t fYMin, fYMax;       
    Double32_t fPMin, fPMax;       
    Double32_t fThetaMin, fThetaMax; 
    Double32_t fX, fY, fZ;           
    Double32_t fX1, fY1, fX2, fY2;   
    Double32_t fPx, fPy, fPz;        
    Double32_t fGausX, fGausY;       
    Double32_t fSigmaX, fSigmaY;     
    Double32_t fGausP;               
    Double32_t fSigmaP;              
    Double32_t fGausTheta;           
    Double32_t fSigmaTheta;          
    Double32_t fKinE;                
    Double32_t fRho, fCenterX, fCenterY;

    Bool_t fEtaRangeIsSet;       
    Bool_t fYRangeIsSet;         
    Bool_t fThetaRangeIsSet;     
    Bool_t fCosThetaIsSet;       
    Bool_t fPtRangeIsSet;        
    Bool_t fPRangeIsSet;         
    Bool_t fPointVtxIsSet;       
    Bool_t fBoxVtxIsSet;         
    Bool_t fBoxSigmaIsSet;       
    Bool_t fSigmaPIsSet;         
    Bool_t fDebug;               
    Bool_t fSpreadingOnTarget;   
    Bool_t fSigmaThetaIsSet;     
    Bool_t fRoundXYIsSet;        

 private:
    ERIonGenerator(const ERIonGenerator&);
    ERIonGenerator& operator=(const ERIonGenerator&);

    ClassDef(ERIonGenerator,1);
};

#endif // ERIonGenerator_H