beamBase.h

/* 
Beam Delivery Simulation (BDSIM) Copyright (C) Royal Holloway, 
University of London 2001 - 2023.
 
This file is part of BDSIM.
 
BDSIM 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 version 3 of the License.
 
BDSIM 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 BDSIM.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef BEAMBASE_H
#define BEAMBASE_H
 
#include <string>
#include <vector>
 
namespace GMAD
{
  class BeamBase
    {
    public:
      BeamBase();
 
      std::string particle;
      std::string beamParticleName;
      double      beamEnergy;
      double      beamKineticEnergy;
      double      beamMomentum;
      std::string distrType;
      std::string xDistrType;
      std::string yDistrType;
      std::string zDistrType;
      std::string spaceDistrType;
      std::string directionDistrType;
      std::string energyDistrType;
      std::string distrFile;
      std::string distrFileFormat;
      bool        distrFileFromExecOptions; 
      bool        distrFileMatchLength;
      bool        distrFileLoop;
      int         distrFileLoopNTimes;
      bool        removeUnstableWithoutDecay;
      int         nlinesIgnore; 
      int         nlinesSkip;   
 
      double bunchFrequency;
      double bunchPeriod;
      int    eventsPerBunch;
      
      double X0, Y0, Z0, S0;
      double Xp0, Yp0, Zp0;
      double T0;
      double E0;
      double Ek0;
      double P0;
 
      double tilt;
 
      double sigmaT;
 
      double sigmaE;
      double sigmaEk;
      double sigmaP;
      
      double betx, bety, alfx, alfy, emitx, emity, dispx, dispy, dispxp, dispyp;
      double emitNX, emitNY;
      
      double sigmaX, sigmaXp, sigmaY, sigmaYp;
      
      double envelopeX, envelopeXp, envelopeY, envelopeYp, envelopeZ, envelopeZp;
      double envelopeT, envelopeE;
      double envelopeR, envelopeRp;
      bool   zFromT;
      
      double sigma11, sigma12, sigma13, sigma14, sigma15, sigma16;
      double          sigma22, sigma23, sigma24, sigma25, sigma26;
      double                   sigma33, sigma34, sigma35, sigma36;
      double                            sigma44, sigma45, sigma46;
      double                                     sigma55, sigma56;
      double                                              sigma66;
      
      double shellX, shellXp, shellY, shellYp;
      double shellXWidth, shellXpWidth, shellYWidth, shellYpWidth;
      
      double Rmin, Rmax;
      
      double haloNSigmaXInner;
      double haloNSigmaXOuter;
      double haloNSigmaYInner;
      double haloNSigmaYOuter;
      double haloXCutInner;
      double haloYCutInner;
      double haloXCutOuter;
      double haloYCutOuter;
      double haloXpCutInner;
      double haloYpCutInner;
      double haloXpCutOuter;
      double haloYpCutOuter;
      double haloPSWeightParameter;
      std::string haloPSWeightFunction;
 
      bool offsetSampleMean;
 
      int    eventGeneratorNEventsSkip;
      double eventGeneratorMinX;
      double eventGeneratorMaxX;
      double eventGeneratorMinY;
      double eventGeneratorMaxY;
      double eventGeneratorMinZ;
      double eventGeneratorMaxZ;
      double eventGeneratorMinXp;
      double eventGeneratorMaxXp;
      double eventGeneratorMinYp;
      double eventGeneratorMaxYp;
      double eventGeneratorMinZp;
      double eventGeneratorMaxZp;
      double eventGeneratorMinRp;
      double eventGeneratorMaxRp;
      double eventGeneratorMinT;
      double eventGeneratorMaxT;
      double eventGeneratorMinEK;
      double eventGeneratorMaxEK;
      std::string eventGeneratorParticles;
      bool   eventGeneratorWarnSkippedParticles;
  
      std::vector<std::string> setKeys;
    };
}
 
#endif