Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/event/src/G4SingleParticleSource.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /event/src/G4SingleParticleSource.cc (Version 11.3.0) and /event/src/G4SingleParticleSource.cc (Version 9.5)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 // G4SingleParticleSource source implementatio << 
 27 //                                             << 
 28 // Author: Fan Lei, QinetiQ ltd. - 05/02/2004  << 
 29 // Customer: ESA/ESTEC                         << 
 30 // Revision: Andrea Dotti, SLAC                << 
 31 // ------------------------------------------- << 
 32                                                << 
 33 #include <cmath>                               << 
 34                                                    26 
 35 #include "G4SingleParticleSource.hh"           <<  27 ///////////////////////////////////////////////////////////////////////////////
 36                                                <<  28 //
 37 #include "G4SystemOfUnits.hh"                  <<  29 // MODULE:        G4SingleParticleSource.hh
                                                   >>  30 //
                                                   >>  31 // Version:      1.0
                                                   >>  32 // Date:         5/02/04
                                                   >>  33 // Author:       Fan Lei 
                                                   >>  34 // Organisation: QinetiQ ltd.
                                                   >>  35 // Customer:     ESA/ESTEC
                                                   >>  36 //
                                                   >>  37 ///////////////////////////////////////////////////////////////////////////////
                                                   >>  38 //
                                                   >>  39 // CHANGE HISTORY
                                                   >>  40 // --------------
                                                   >>  41 //
                                                   >>  42 // Version 1.0, 05/02/2004, Fan Lei, Created.
                                                   >>  43 //      Based on the G4GeneralParticleSource class in Geant4 v6.0
                                                   >>  44 //
                                                   >>  45 ///////////////////////////////////////////////////////////////////////////////
                                                   >>  46 //
 38 #include "G4PrimaryParticle.hh"                    47 #include "G4PrimaryParticle.hh"
 39 #include "G4Event.hh"                              48 #include "G4Event.hh"
 40 #include "Randomize.hh"                            49 #include "Randomize.hh"
                                                   >>  50 #include <cmath>
 41 #include "G4ParticleTable.hh"                      51 #include "G4ParticleTable.hh"
 42 #include "G4Geantino.hh"                           52 #include "G4Geantino.hh"
 43 #include "G4ParticleDefinition.hh"                 53 #include "G4ParticleDefinition.hh"
 44 #include "G4IonTable.hh"                           54 #include "G4IonTable.hh"
 45 #include "G4Ions.hh"                               55 #include "G4Ions.hh"
 46 #include "G4TrackingManager.hh"                    56 #include "G4TrackingManager.hh"
 47 #include "G4Track.hh"                              57 #include "G4Track.hh"
 48 #include "G4AutoLock.hh"                       <<  58 #include "G4SingleParticleSource.hh"
 49                                                << 
 50 G4SingleParticleSource::part_prop_t::part_prop << 
 51 {                                              << 
 52   momentum_direction = G4ParticleMomentum(1,0, << 
 53   energy = 1.*MeV;                             << 
 54   position = G4ThreeVector();                  << 
 55 }                                              << 
 56                                                << 
 57 G4SingleParticleSource::G4SingleParticleSource << 
 58 {                                              << 
 59   // Initialise all variables                  << 
 60   // Position distribution Variables           << 
 61                                                << 
 62   NumberOfParticlesToBeGenerated = 1;          << 
 63   definition = G4Geantino::GeantinoDefinition( << 
 64                                                << 
 65   charge = 0.0;                                << 
 66   time = 0;                                    << 
 67   polarization = G4ThreeVector();              << 
 68                                                << 
 69   biasRndm = new G4SPSRandomGenerator();       << 
 70   posGenerator = new G4SPSPosDistribution();   << 
 71   posGenerator->SetBiasRndm(biasRndm);         << 
 72   angGenerator = new G4SPSAngDistribution();   << 
 73   angGenerator->SetPosDistribution(posGenerato << 
 74   angGenerator->SetBiasRndm(biasRndm);         << 
 75   eneGenerator = new G4SPSEneDistribution();   << 
 76   eneGenerator->SetBiasRndm(biasRndm);         << 
 77                                                << 
 78   verbosityLevel = 0;                          << 
 79                                                << 
 80   G4MUTEXINIT(mutex);                          << 
 81 }                                              << 
 82                                                << 
 83 G4SingleParticleSource::~G4SingleParticleSourc << 
 84 {                                              << 
 85   delete biasRndm;                             << 
 86   delete posGenerator;                         << 
 87   delete angGenerator;                         << 
 88   delete eneGenerator;                         << 
 89                                                << 
 90   G4MUTEXDESTROY(mutex);                       << 
 91 }                                              << 
 92                                                << 
 93 void G4SingleParticleSource::SetVerbosity(G4in << 
 94 {                                              << 
 95   G4AutoLock l(&mutex);                        << 
 96   verbosityLevel = vL;                         << 
 97   posGenerator->SetVerbosity(vL);              << 
 98   angGenerator->SetVerbosity(vL);              << 
 99   eneGenerator->SetVerbosity(vL);              << 
100 }                                              << 
101                                                    59 
102 void G4SingleParticleSource::                  <<  60 G4SingleParticleSource::G4SingleParticleSource() {
103 SetParticleDefinition(G4ParticleDefinition* aP <<  61   // Initialise all variables
104 {                                              <<  62   // Position distribution Variables
105   definition = aParticleDefinition;            <<  63 
106   charge = aParticleDefinition->GetPDGCharge() <<  64   NumberOfParticlesToBeGenerated = 1;
                                                   >>  65   particle_definition = G4Geantino::GeantinoDefinition();
                                                   >>  66   G4ThreeVector zero;
                                                   >>  67   particle_momentum_direction = G4ParticleMomentum(1, 0, 0);
                                                   >>  68   particle_energy = 1.0 * MeV;
                                                   >>  69   particle_position = zero;
                                                   >>  70   particle_time = 0.0;
                                                   >>  71   particle_polarization = zero;
                                                   >>  72   particle_charge = 0.0;
                                                   >>  73   particle_weight = 1.0;
                                                   >>  74 
                                                   >>  75   biasRndm = new G4SPSRandomGenerator();
                                                   >>  76   posGenerator = new G4SPSPosDistribution();
                                                   >>  77   posGenerator->SetBiasRndm(biasRndm);
                                                   >>  78   angGenerator = new G4SPSAngDistribution();
                                                   >>  79   angGenerator->SetPosDistribution(posGenerator);
                                                   >>  80   angGenerator->SetBiasRndm(biasRndm);
                                                   >>  81   eneGenerator = new G4SPSEneDistribution();
                                                   >>  82   eneGenerator->SetBiasRndm(biasRndm);
                                                   >>  83 
                                                   >>  84   // verbosity
                                                   >>  85   verbosityLevel = 0;
                                                   >>  86 
                                                   >>  87 }
                                                   >>  88 
                                                   >>  89 G4SingleParticleSource::~G4SingleParticleSource() {
                                                   >>  90   delete biasRndm;
                                                   >>  91   delete posGenerator;
                                                   >>  92   delete angGenerator;
                                                   >>  93   delete eneGenerator;
                                                   >>  94 }
                                                   >>  95 
                                                   >>  96 void G4SingleParticleSource::SetVerbosity(int vL) {
                                                   >>  97   verbosityLevel = vL;
                                                   >>  98   posGenerator->SetVerbosity(vL);
                                                   >>  99   angGenerator->SetVerbosity(vL);
                                                   >> 100   eneGenerator->SetVerbosity(vL);
                                                   >> 101   G4cout << "Verbosity Set to: " << verbosityLevel << G4endl;
                                                   >> 102 }
                                                   >> 103 
                                                   >> 104 void G4SingleParticleSource::SetParticleDefinition(
                                                   >> 105     G4ParticleDefinition* aParticleDefinition) {
                                                   >> 106   particle_definition = aParticleDefinition;
                                                   >> 107   particle_charge = particle_definition->GetPDGCharge();
                                                   >> 108 }
                                                   >> 109 
                                                   >> 110 void G4SingleParticleSource::GeneratePrimaryVertex(G4Event *evt) {
                                                   >> 111   if (particle_definition == NULL)
                                                   >> 112     return;
                                                   >> 113 
                                                   >> 114   if (verbosityLevel > 1)
                                                   >> 115     G4cout << " NumberOfParticlesToBeGenerated: "
                                                   >> 116         << NumberOfParticlesToBeGenerated << G4endl;
                                                   >> 117 
                                                   >> 118   // Position stuff
                                                   >> 119   particle_position = posGenerator->GenerateOne();
                                                   >> 120 
                                                   >> 121   // create a new vertex
                                                   >> 122   G4PrimaryVertex* vertex = new G4PrimaryVertex(particle_position,
                                                   >> 123       particle_time);
                                                   >> 124 
                                                   >> 125   for (G4int i = 0; i < NumberOfParticlesToBeGenerated; i++) {
                                                   >> 126     // Angular stuff
                                                   >> 127     particle_momentum_direction = angGenerator->GenerateOne();
                                                   >> 128     // Energy stuff
                                                   >> 129     particle_energy = eneGenerator->GenerateOne(particle_definition);
                                                   >> 130 
                                                   >> 131     if (verbosityLevel >= 2)
                                                   >> 132       G4cout << "Creating primaries and assigning to vertex" << G4endl;
                                                   >> 133     // create new primaries and set them to the vertex
                                                   >> 134     G4double mass = particle_definition->GetPDGMass();
                                                   >> 135     G4PrimaryParticle* particle =
                                                   >> 136       new G4PrimaryParticle(particle_definition);
                                                   >> 137     particle->SetKineticEnergy( particle_energy );
                                                   >> 138     particle->SetMass( mass );
                                                   >> 139     particle->SetMomentumDirection( particle_momentum_direction );
                                                   >> 140     particle->SetCharge( particle_charge );
                                                   >> 141     particle->SetPolarization(particle_polarization.x(),
                                                   >> 142             particle_polarization.y(),
                                                   >> 143             particle_polarization.z());
                                                   >> 144     if (verbosityLevel > 1) {
                                                   >> 145       G4cout << "Particle name: "
                                                   >> 146           << particle_definition->GetParticleName() << G4endl;
                                                   >> 147       G4cout << "       Energy: " << particle_energy << G4endl;
                                                   >> 148       G4cout << "     Position: " << particle_position << G4endl;
                                                   >> 149       G4cout << "    Direction: " << particle_momentum_direction
                                                   >> 150           << G4endl;
                                                   >> 151     }
                                                   >> 152     // Set bweight equal to the multiple of all non-zero weights
                                                   >> 153     particle_weight = eneGenerator->GetWeight()*biasRndm->GetBiasWeight();
                                                   >> 154     // pass it to primary particle
                                                   >> 155     particle->SetWeight(particle_weight);
                                                   >> 156 
                                                   >> 157     vertex->SetPrimary(particle);
                                                   >> 158 
                                                   >> 159   }
                                                   >> 160   // now pass the weight to the primary vertex. CANNOT be used here!
                                                   >> 161   //  vertex->SetWeight(particle_weight);
                                                   >> 162   evt->AddPrimaryVertex(vertex);
                                                   >> 163   if (verbosityLevel > 1)
                                                   >> 164     G4cout << " Primary Vetex generated !" << G4endl;
107 }                                                 165 }
108                                                   166 
109 void G4SingleParticleSource::GeneratePrimaryVe << 
110 {                                              << 
111   if (definition == nullptr)                   << 
112   {                                            << 
113     // TODO: Should this rise an exception???  << 
114     return;                                    << 
115   }                                            << 
116                                                << 
117   if (verbosityLevel > 1)                      << 
118   {                                            << 
119     G4cout << " NumberOfParticlesToBeGenerated << 
120            << NumberOfParticlesToBeGenerated < << 
121   }                                            << 
122                                                << 
123   part_prop_t& pp = ParticleProperties.Get();  << 
124                                                << 
125   // Position stuff                            << 
126   pp.position = posGenerator->GenerateOne();   << 
127                                                << 
128   // Create a new vertex                       << 
129   auto* vertex = new G4PrimaryVertex(pp.positi << 
130                                                << 
131   for (G4int i=0; i<NumberOfParticlesToBeGener << 
132   {                                            << 
133     // Angular stuff                           << 
134     pp.momentum_direction = angGenerator->Gene << 
135                                                << 
136     // Energy stuff                            << 
137     pp.energy = eneGenerator->GenerateOne(defi << 
138                                                << 
139     if (verbosityLevel >= 2)                   << 
140     {                                          << 
141       G4cout << "Creating primaries and assign << 
142     }                                          << 
143                                                << 
144     // Create new primaries and set them to th << 
145     //                                         << 
146     G4double mass = definition->GetPDGMass();  << 
147     auto* particle = new G4PrimaryParticle(def << 
148     particle->SetKineticEnergy(pp.energy );    << 
149     particle->SetMass( mass );                 << 
150     particle->SetMomentumDirection( pp.momentu << 
151     particle->SetCharge( charge );             << 
152     particle->SetPolarization(polarization.x() << 
153                               polarization.y() << 
154                               polarization.z() << 
155     if (verbosityLevel > 1)                    << 
156     {                                          << 
157       G4cout << "Particle name: " << definitio << 
158       G4cout << "       Energy: " << pp.energy << 
159       G4cout << "     Position: " << pp.positi << 
160       G4cout << "    Direction: " << pp.moment << 
161     }                                          << 
162                                                << 
163     // Set bweight equal to the multiple of al << 
164     //                                         << 
165     G4double weight = eneGenerator->GetWeight( << 
166                                                << 
167     if(eneGenerator->IfApplyEnergyWeight())    << 
168     {                                          << 
169       weight *= eneGenerator->GetArbEneWeight( << 
170     }                                          << 
171                                                << 
172     // Pass it to primary particle             << 
173     //                                         << 
174     particle->SetWeight(weight);               << 
175     vertex->SetPrimary(particle);              << 
176   }                                            << 
177                                                << 
178   // Now pass the weight to the primary vertex << 
179   //  vertex->SetWeight(particle_weight);      << 
180   evt->AddPrimaryVertex(vertex);               << 
181                                                << 
182   if (verbosityLevel > 1)                      << 
183   {                                            << 
184     G4cout << " Primary Vetex generated !" <<  << 
185   }                                            << 
186 }                                              << 
187                                                   167