FairPrimaryGenerator.h

Go to the documentation of this file.

/********************************************************************************
 *    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH *
 *                                                                              *
 *              This software is distributed under the terms of the *
 *              GNU Lesser General Public Licence (LGPL) version 3,             *
 *                  copied verbatim in the file "LICENSE" *
 ********************************************************************************/

#ifndef FAIRPRIMARYGENERATOR_H
#define FAIRPRIMARYGENERATOR_H

#include "FairGenerator.h"   // for FairGenerator

#include <Rtypes.h>   // for Double_t, Bool_t, Int_t, etc
#include <TMCProcess.h>
#include <TNamed.h>      // for TNamed
#include <TObjArray.h>   // for TObjArray
#include <TVector3.h>    // for TVector3
#include <iostream>      // for cout

class FairGenericStack;
class FairMCEventHeader;
class TIterator;

class FairPrimaryGenerator : public TNamed
{

  public:
    FairPrimaryGenerator();

    FairPrimaryGenerator(const char *name, const char *title = "FAIR Generator");

    virtual ~FairPrimaryGenerator();

    virtual Bool_t Init();

    void AddGenerator(FairGenerator *generator)
    {
        if (!fGenList) {
            std::cout << "Empty fGenList pointer ! " << std::endl;
            return;
        }
        fGenList->Add(generator);
    }

    void SetEventNr(Int_t evtNr) { fEventNr = evtNr; }

    virtual Bool_t GenerateEvent(FairGenericStack *pStack);

    virtual void AddTrack(Int_t pdgid,
                          Double_t px,
                          Double_t py,
                          Double_t pz,
                          Double_t vx,
                          Double_t vy,
                          Double_t vz,
                          Int_t parent = -1,
                          Bool_t wanttracking = true,
                          Double_t e = -9e9,
                          Double_t tof = 0.,
                          Double_t weight = 0.,
                          TMCProcess proc = kPPrimary);

    virtual FairPrimaryGenerator *ClonePrimaryGenerator() const;

    void SetBeam(Double_t beamX0, Double_t beamY0, Double_t beamSigmaX, Double_t beamSigmaY);

    void SetBeamAngle(Double_t beamAngleX0, Double_t beamAngleY0, Double_t beamAngleSigmaX, Double_t beamAngleSigmaY);

    void SetEventPlane(Double_t phiMin, Double_t phiMax);

    void SetTarget(Double_t targetZ, Double_t targetDz);

    void SetMultTarget(Int_t nroftargets, Double_t *targetZ, Double_t targetDz);

    void SmearVertexZ(Bool_t flag);
    void SmearGausVertexZ(Bool_t flag);
    void SmearVertexXY(Bool_t flag);
    void SmearGausVertexXY(Bool_t flag);

    TObjArray *GetListOfGenerators() { return fGenList; }

    void SetEvent(FairMCEventHeader *event) { fEvent = event; };

    FairMCEventHeader *GetEvent() { return fEvent; };

    void DoTracking(Bool_t doTracking = kTRUE) { fdoTracking = doTracking; }

    Int_t GetTotPrimary() { return fTotPrim; }

  protected:
    FairPrimaryGenerator(const FairPrimaryGenerator &);
    FairPrimaryGenerator &operator=(const FairPrimaryGenerator &);

    Double_t fBeamX0;
    Double_t fBeamY0;
    Double_t fBeamSigmaX;
    Double_t fBeamSigmaY;

    Double_t fBeamAngleX0;
    Double_t fBeamAngleY0;
    Double_t fBeamAngleX;
    Double_t fBeamAngleY;
    Double_t fBeamAngleSigmaX;
    Double_t fBeamAngleSigmaY;
    TVector3 fBeamDirection;

    Double_t fPhiMin;
    Double_t fPhiMax;
    Double_t fPhi;

    Double_t *fTargetZ;   

    Int_t fNrTargets;
    Double_t fTargetDz;

    TVector3 fVertex;

    Int_t fNTracks;

    Bool_t fSmearVertexZ;
    Bool_t fSmearGausVertexZ;
    Bool_t fSmearVertexXY;
    Bool_t fSmearGausVertexXY;
    Bool_t fBeamAngle;
    Bool_t fEventPlane;

    FairGenericStack *fStack;   

    TObjArray *fGenList;
    TIterator *fListIter;   

    FairMCEventHeader *fEvent;   

    Bool_t fdoTracking;   

    Int_t fMCIndexOffset;   

    static Int_t fTotPrim;   

    Int_t fEventNr;

    virtual void MakeVertex();

    virtual void MakeBeamAngle();

    void MakeEventPlane();

    ClassDef(FairPrimaryGenerator, 5);
};

#endif