GGSGunGeneratorAction.h

Go to the documentation of this file.

/*
 * GGSGunGeneratorAction.h
 *
 *  Created on: 09 Oct 2013
 *      Author: Nicola Mori
 */

#ifndef GGSGUNGENERATORACTION_H_
#define GGSGUNGENERATORACTION_H_

#include "montecarlo/generators/GGSGeneratorAction.h"

#include "G4RotationMatrix.hh"
#include "G4ThreeVector.hh"
#include "globals.hh"

class G4ParticleGun;
class GGSGunGeneratorActionMessenger;

class GGSGunGeneratorAction : public GGSGeneratorAction {
public:
  GGSGunGeneratorAction();

  ~GGSGunGeneratorAction();

  void GeneratePrimaries(G4Event *);

  void SetAcceptanceFlag(G4bool val) { _acceptanceFlag = val; }

  void SetRndmMinEnergyFlag(G4bool val) { _rndmMinEnergyFlag = val; }

  void SetRndmMaxEnergyFlag(G4bool val) { _rndmMaxEnergyFlag = val; }

  void SetSpectralIndexFlag(G4bool val) { _spectralIndexFlag = val; }

  void SetEnergy(G4double val) { _energy = val; }

  void SetMinEnergy(G4double val) { _minEnergy = val; }

  void SetMaxEnergy(G4double val) { _maxEnergy = val; }

  void SetSpectralIndex(G4double val) { _spectralIndex = val; }

  void SetPosition(const G4ThreeVector &val) {
    _position = val;
    // Reset random position generation
    _rndmMinPositionFlag = _rndmMaxPositionFlag = false;
    _SetRndmPosFlag();
    _SetRndmFromSurface(0);
  }

  void SetMinPosition(const G4ThreeVector &val) {
    _minPosition = val;
    _rndmMinPositionFlag = true;
    _SetRndmPosFlag();
    _SetRndmFromSurface(1);
  }

  void SetMaxPosition(const G4ThreeVector &val) {
    _maxPosition = val;
    _rndmMaxPositionFlag = true;
    _SetRndmPosFlag();
    _SetRndmFromSurface(1);
  }

  void SetSphereCenter(const G4ThreeVector &val) {
    _rndmSphereCenter = val;
    _SetRndmFromSurface(2);
  }

  void SetSphereCapPosition(const G4ThreeVector &val) {
    _rndmSphereCapPosition = val;
    _rndmSphereRadius = val.mag();
    _rndmSphereCapAlpha = acos(val[2] / _rndmSphereRadius);
    _rndmSphereCapBeta = atan2(val[1], val[0]);
    _SetRndmFromSurface(2);
  }

  void SetSphereCapExtension(G4double val) {
    _rndmSphereCapExtRand = (1. - cos(val)) / 2.;
    _SetRndmFromSurface(2);
  }

  void SetTheta(G4double val) {
    _sinTheta = sin(val);
    _cosTheta = cos(val);
    _rndmMinThetaFlag = _rndmMaxThetaFlag = false;
    _SetRndmDirFlag();
    _SetShootingDir();
  }

  void SetMinTheta(G4double val) {
    _minThetaRand = (1. - cos(val)) / 2.;
    _maxCos2ThetaRand = cos(val);
    _maxCos2ThetaRand *= _maxCos2ThetaRand;
    _rndmMinThetaFlag = true;
    _SetRndmDirFlag();
  }

  void SetMaxTheta(G4double val) {
    _maxThetaRand = (1. - cos(val)) / 2.;
    _minCos2ThetaRand = cos(val);
    _minCos2ThetaRand *= _minCos2ThetaRand;
    _rndmMaxThetaFlag = true;
    _SetRndmDirFlag();
  }

  void SetPhi(G4double val) {
    _sinPhi = sin(val);
    _cosPhi = cos(val);
    _rndmMinPhiFlag = _rndmMaxPhiFlag = false;
    _SetRndmDirFlag();
    _SetShootingDir();
  }

  void SetMinPhi(G4double val) {
    _minPhi = val;
    _rndmMinPhiFlag = true;
    _SetRndmDirFlag();
  }

  void SetMaxPhi(G4double val) {
    _maxPhi = val;
    _rndmMaxPhiFlag = true;
    _SetRndmDirFlag();
  }

  void SetGunParticle(const G4String &particle);

  GGSParameters GetParameters() const;

private:
  // Methods

  void _SetRndmFromSurface(int surfType);

  // These functions reset (ie., disable) the random generation on surfaces
  void _ResetFlat();
  void _ResetSphere();

  G4RotationMatrix &_ComputeRotMatrix(double cosAlpha, double sinAlpha, double cosBeta, double sinBeta);

  void _SetRndmDirFlag();

  void _SetRndmPosFlag();

  void _SetShootingDir() {
    _direction[0] = -_sinTheta * _cosPhi; // momentum direction (unit vectors)
    _direction[1] = -_sinTheta * _sinPhi;
    _direction[2] = -_cosTheta; // along -z
  }

  G4double _GenSpectrumPowerLaw(G4double Emin, G4double Emax, G4double gamma);

  // Members

  GGSGunGeneratorActionMessenger *_messenger; // messenger of this class

  G4ParticleGun *_gunGenerator; // The wrapped standard gun generator

  G4ThreeVector _shootAxis;
  G4bool _acceptanceFlag; // if true, acceptance check will be performed
  G4bool _rndmMinPositionFlag;
  G4bool _rndmMaxPositionFlag;
  G4bool _rndmFromFlat;
  G4bool _rndmFromSphere;
  G4ThreeVector _rndmSphereCenter;
  G4ThreeVector _rndmSphereCapPosition;
  G4double _rndmSphereCapExtRand; // Minimum value for random sampling of polar angle for position std::vector on the
                                  // spherical cap
  G4double _rndmSphereCapAlpha;   // Polar angle of _rndmSphereCapPos
  G4double _rndmSphereCapBeta;    // Azimuth angle of _rndmSphereCapPos
  G4RotationMatrix _rndmSphereCapRotMat; // Rotation from cap frame to absolute frame
  G4double _rndmSphereRadius;
  G4bool _rndmMinEnergyFlag;
  G4bool _rndmMaxEnergyFlag;
  G4bool _spectralIndexFlag;
  G4bool _rndmMinThetaFlag;
  G4bool _rndmMaxThetaFlag;
  G4bool _rndmMinPhiFlag;
  G4bool _rndmMaxPhiFlag;
  G4bool _rndmPosFlag; // Flag for random generation point
  G4bool _rndmDirFlag; // Flag for random generation direction

  G4ThreeVector _position;
  G4ThreeVector _minPosition;
  G4ThreeVector _maxPosition;
  G4double _energy;
  G4double _minEnergy;
  G4double _maxEnergy;
  G4double _spectralIndex;
  G4double _sinTheta, _cosTheta;
  G4double _minThetaRand, _maxThetaRand;
  G4double _minCos2ThetaRand, _maxCos2ThetaRand;
  G4double _sinPhi, _cosPhi;
  G4double _minPhi;
  G4double _maxPhi;
  G4ThreeVector _direction; // Computed automatically given theta and phi
};

#endif /* GGSGUNGENERATORACTION_H_ */