---

PEGSData.h

Go to the documentation of this file.

// -*- C++ -*-  $Id: PEGSData.h,v 1.1 2000/09/01 20:20:16 burnett Exp $
//
// This file is part of Gismo 2

#ifndef __PEGSDATA_H
#define __PEGSDATA_H

#include "gismo/Material.h"
#include "gismo/MatData.h"

#include <iostream>

#include <cstdlib>
#include <algorithm>

#include "egs/Photin.h"
#include "egs/Brempr.h"
#include "egs/Elecin.h"

class PEGSData : public MatData
{
    friend class EGS;
public:
    PEGSData():ae(1E12f),ap(1E12f){};
    // default, null constructor

    ~PEGSData();
    // destructor

    void read(std::istream& in,  Material& mat);
    // read, from open stream

    MatData* copy()const {return new PEGSData();}
    // make a copy

    void read(std::istream&);
    // read data from open file in PEGS format

    // Access to PEGSData for the rest of the World
    float ecut() const {return ae;}
    float pcut() const {return ap;}
    float emax() const {return ue;}
    float pmax() const {return up;}
    float rl()  const {return rldu;}

    float hzbrang()const {return zbrang;} //harrison    


    float tmxs(float ke)const;
    // the maximum step size

    float meanFreePath(float e, int charge)const;
    float dedx(float  e, int charge) const;
    // return meanFreePath or dedx for electron, positron, or gamma

    enum channel {STOP, BREMS, MOLLER, ANNIH, BHABHA, PAIR, COMPT, PHOTO, RAYLEIGH};
    // define possible channels returned by chooseChannel

    PEGSData::channel chooseChannel(float ran,float e,int charge)const;
    // return a channel, given uniform random number, energy, charge


    static float estepe;
    // fractional eloss allowed per step, user-settable. If zero, use standard
    // EGS step size, otherwise, calls fixtmx to modify step sizes when material
    // is defined

    static int irayl;
    // user settable, to control use of Rayleigh option

    static const float rm;       // electron mass in MeV
    static const float dunit;    // distance unit, in cm


    void printHead1(std::ostream&);
    void printHead2(std::ostream&);
    void printOn(std::ostream&);
    // print info about this material

private:

    float rldu;         // radiation length scaled to actual units
    int   iraylm;       // user has to set to use Rayleigh option


    float ae, ap,       // thresholds
        up, ue,
        te,
        thmoll; // Moller

    float zbrang;       // ((1/111)*zeff**(1/3))**2


    Brempr bp;          // brems and pair Bethe-Heitler function
    Elecin el;          // electron/postron cross sections
    Photin ph;          // photon cross sections
    Kedge  edge;        // stuff for the photoelectric

public:

    // various cross sections, branching ratios

    float  esig(float e)const;
    float  psig(float e)const;
    float ededx(float e)const;
    float pdedx(float e)const;
    float  ebr1(float e)const;
    float  pbr1(float e)const;
    float  pbr2(float e)const;

    float  gmfp(float e)const;
    float  gbr1(float e)const;
    float  gbr2(float e)const;
    float  cohe(float e)const;

    float blcc()const{return el.blcc;}
    float xcc()const{return el.xcc;}
    float ebinda()const{return ph.ebinda;}

    float screening(float del, int lvx, int lvl)const { return bp.screening(del,lvx,lvl);}
    float alphi(int lvx)const{return bp.alphi[lvx];}
    float bpar(int lvx)const{return bp.bpar[lvx];}

};

// evaluate cross sections inline

// electron/positron cross sections, eloss, branching fractions


inline float PEGSData::esig(float ke)const
{
    el.updateIndex(ke); return el.esig();
}
inline float PEGSData::psig(float ke)const
{     el.updateIndex(ke); return el.psig();
}

inline float PEGSData::ededx(float ke)const
{     el.updateIndex(ke); return el.ededx();

}

inline float PEGSData::pdedx(float ke)const
{     el.updateIndex(ke); return el.pdedx();

}

inline float PEGSData::ebr1(float ke) const
{     el.updateIndex(ke); return el.ebr1();

}

inline float
PEGSData::pbr1(float ke)const
{     el.updateIndex(ke); return el.pbr1();

}

inline float
PEGSData::pbr2(float ke)const
{     el.updateIndex(ke); return el.pbr2();

}
inline float
PEGSData::tmxs(float ke)const
{
/* "the following [macro] limits the step size to values less than
200*teff0.  this restriction, which is consistent with egs2,
was found to be necessary after egs3 calculations were
compared with experimental benchmarks.  see chapter 3 of slac-210"
    */
    el.updateIndex(ke); return std::min(el.tmxs(),200*el.teff0);
}

// photon mfp, branching fractions

inline float
PEGSData::gmfp(float eig)const
{     ph.updateIndex(eig); return ph.gmfp();
}

inline float
PEGSData::gbr1(float eig)const
{     ph.updateIndex(eig); return ph.gbr1();
}

inline float
PEGSData::gbr2(float eig)const
{     ph.updateIndex(eig); return ph.gbr2();
}

inline float
PEGSData::cohe(float eig)const
{     ph.updateIndex(eig); return ph.cohe();
}

#endif

---