BaseGEM.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004 by Olivier Stezowski                               *
 *   stezow(AT)ipnl.in2p3.fr                                               *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifndef GW_BASEGEM_H
#define GW_BASEGEM_H

#include <RandObj.h>
#include <LevelScheme.h>
#include <Link.h>

class TLorentzVector;

namespace Gw {
    
    class BaseGEM : public TObject
    {
    public:
        enum EDirection { kDown, kUp } ;
        
    private:
        LevelScheme *fLevelScheme;      // level scheme on which is performed the Monte-Carlo
        
    private:
        TObjArray fFeeding;             // list to store all the constructed feeding links
        TObjArray fRandFeeding; // list to store the random selectors for all the feeding links
        TObjArray fRandDown;    // list to store the random selectors for all the links of the level scheme
        TObjArray fAD;          // list of functions used for angular distributions
        
    private:
        RandObj fRand0;         // random selector to determine the starting point (one of the feeding links)
        
    private:
        TList fTmp;                     // temporary list that owns objects to be deleted by BaseGEM
        TObject fEoC;           // EoC (End of Cascade). The random cascade stops when this particular link is reached.
        
    protected:
        Int_t fDirection;               // Simulated cascade up or down.
        
    protected:
        Double_t fMinEnergyFactor;      // minimum intensity of a link with a strength equal to 0
        Int_t fADType;              // 0 means isotropic, 1 means angular distribution from pure m-substate, 2 with a gaussian-distribution driven by sigma
        Double_t fCutLifeTime;          // under such life time, angular distribution is isotropic
        Double_t fSigma;            // sigma of the gaussian for orientation paramters. 0 by default

    protected:
        virtual void InitRandom();
        virtual void DoAngularDistribution(Int_t which_gamma, TLorentzVector &, Bool_t forceiso = false);

    public:
        BaseGEM();
        virtual ~BaseGEM();
        
        const TObjArray &GetFeedings() const
        {
            return fFeeding;
        }
        
        Bool_t SetParameter(const char *name, Int_t value);
        Bool_t SetParameter(const char *name, Double_t value);
        

        virtual void SetDirection(EDirection d = kDown)
        {
            fDirection = d;
        }
        

        //Float_t SetMinFactor(Float_t newmin) { Float_t tmp = fMinEnergyFactor ; fMinEnergyFactor = newmin; return tmp; }
        
        const LevelScheme *GetLS() const
        {
            return fLevelScheme;
        }
        

        virtual Int_t Import(const Char_t *, Option_t *opt="152DY");
        

        virtual void Clear(Option_t *opt = "all");
        

        virtual Int_t DoCascade(TSeqCollection &cascade, Option_t *opt = "");

        virtual Int_t DoCascade(TSeqCollection &cascade, TSeqCollection &directions, Option_t *opt = "");
        

        virtual Int_t DoCascade(TSeqCollection &cas, Int_t from, Option_t *opt = "");
        virtual Int_t DoCascade(TSeqCollection &cas, TSeqCollection &directions, Int_t from, Option_t *opt = "");
        
        
        //   virtual void FillRandom(TH1 *h, Int_t ntimes = 5000);
        
        ClassDef(BaseGEM,0); // Base for a Monte-Carlo on a Level Scheme
    };
    
    
}
#endif