---

FluxSource.h

Go to the documentation of this file.

//      $Header: /nfs/slac/g/glast/ground/cvs/flux/flux/FluxSource.h,v 1.9 2001/10/31 23:20:04 srobinsn Exp $
//      EventSource subclass to take over the functionality of the old Flux class, which implemented
//      a GISMO based event generation scheme.

#ifndef FluxSource_h
#define FluxSource_h 1

#include "flux/EventSource.h"
#include "flux/Spectrum.h"
#include "geometry/Point.h"

// forward declarations
class Box;
class DOM_Element;

// 


class FluxSource : public EventSource  
{
  public:      
      FluxSource ( Spectrum* aSpec = 0, double aFlux = 1 );
      FluxSource ( const DOM_Element& xelem );
      
      virtual ~FluxSource();
          
      virtual FluxSource* event();
      
      virtual std::string fullTitle () const;
      
      virtual std::string displayTitle () const;
      
      virtual void computeLaunch ();

      virtual double flux()const; // calculate flux for attached specturm

      double solidAngle()const;

      void setPhiRange(double min_phi, double max_phi);
      void setCosThetaRange(double min_cos, double max_cos);

      void useSpectrumDirection();

      void setAcceptance ();

      void setLaunch(const Vector& dir, const Point& pos);
      void setLaunch(const Vector& dir);
      void setLaunch(double theta, double phi);
      void setLaunch(double xMax, double xMin, double yMax, double yMin, 
                     double zTop, double zBot, bool fan);
      void FluxSource::setLaunch(double theta, double phi, double xMax, 
                                 double xMin, double yMax, double yMin, 
                                 double zTop, double zBot);

      void unSetLaunch();
      
      // return of angle & solid angle parameters
      double minPhi() const      {return _minPhi;}
      double maxPhi() const      {return _maxPhi;}
      double minCosTheta() const {return _minCos;}
      double maxCosTheta() const {return _maxCos;}
      double phi() const         {return _phi;}
      double theta() const       {return _theta;}

      
      void getSurfacePosDir(); // setup position & direction for Surface illumination

      std::string title()const;

      void  printOn ( std::ostream& out ) {}
      
      void spectrum(Spectrum* s, double emax=-1);
      Spectrum* spectrum() const{ return m_spectrum; }



          void FluxSource::getGalacticDir(double l,double b);

      double maxEnergy()const { return m_maxEnergy;}
      void setMaxEnergy(double e) { m_maxEnergy = e; }


      enum LaunchType { 
          NONE,         
          POINT,        
          DIRECTION ,   
          SURFACE,      
          SPECTRUM, 
          PATCHFIXED,   
                  GALACTIC  
      } m_launch;

          enum PointType { 
          NOPOINT,         
          SINGLE,        
          PATCH   
      } m_pointtype;





      virtual int eventNumber()const;

      double energy()const { return m_energy;}
      const Vector& launchDir()const {return m_launchDir;}
      const Point&  launchPoint()const { return m_launchPoint;}

          void refLaunch(LaunchType launch);
          void refPoint(PointType point);
          int refLaunch()const {return m_launch;}
          int refPoint()const {return m_pointtype;}

  private:

      static    double  s_radius, s_backoff;

      Spectrum*         m_spectrum;         // spectrum to generate

      double m_maxEnergy; // max kinetic energy allowed when running a spectrum
      
      double _minCos, _maxCos, _minPhi, _maxPhi;
      // solid angle, with respect to z-axis
      
      double m_rmin, m_rmax;
      // minimum, maxumum value for random number (fraction of spectrum)
      
      double  _phi, _theta;
      //  angles, with respect to z-axis
      
      // galactic position of source - for use with GALACTIC
      double m_galb, m_gall;
      // dimensions of patch to be illuminated  -- for use with SURFACE
      double patchHeight, patchBottom, patchTop, patchXmax, patchXmin;
      double patchYmax, patchYmin, patchWidX, patchWidY, Fratio;
      double patchRange, patchOffset;
      // for use with SURFACE -- sidePatch means illumination of ONE side
      // fanBeam == false means polar beam
      bool sidePatch, fanBeam;
      Box* illumBox;
      

      Vector m_launchDir;
      Point  m_launchPoint;
      double m_energy;
      // associated with a specific launch

    void randomLaunchPoint(); 
    // calculate a random launch point in a plane perpendicular to _launchDir

};
#endif

---