Warning, /geant4/examples/extended/hadronic/Hadr09/Hadr09.cc-ION_PROJECTILE is written in an unsupported language. File is not indexed.
0001 //
0002 // ********************************************************************
0003 // * License and Disclaimer *
0004 // * *
0005 // * The Geant4 software is copyright of the Copyright Holders of *
0006 // * the Geant4 Collaboration. It is provided under the terms and *
0007 // * conditions of the Geant4 Software License, included in the file *
0008 // * LICENSE and available at http://cern.ch/geant4/license . These *
0009 // * include a list of copyright holders. *
0010 // * *
0011 // * Neither the authors of this software system, nor their employing *
0012 // * institutes,nor the agencies providing financial support for this *
0013 // * work make any representation or warranty, express or implied, *
0014 // * regarding this software system or assume any liability for its *
0015 // * use. Please see the license in the file LICENSE and URL above *
0016 // * for the full disclaimer and the limitation of liability. *
0017 // * *
0018 // * This code implementation is the result of the scientific and *
0019 // * technical work of the GEANT4 collaboration. *
0020 // * By using, copying, modifying or distributing the software (or *
0021 // * any work based on the software) you agree to acknowledge its *
0022 // * use in resulting scientific publications, and indicate your *
0023 // * acceptance of all terms of the Geant4 Software license. *
0024 // ********************************************************************
0025 //
0026 //
0027 /// \file Hadr09.cc
0028 /// \brief Main program of the hadronic/Hadr09 example
0029 //
0030 //------------------------------------------------------------------------
0031 // This program shows how to use the class Hadronic Generator.
0032 // The class HadronicGenerator is a kind of "hadronic generator", i.e.
0033 // provides Geant4 final states (i.e. secondary particles) produced by
0034 // hadron-nuclear inelastic collisions.
0035 // Please see the class itself for more information.
0036 //
0037 // The use of the class Hadronic Generator is very simple:
0038 // the constructor needs to be invoked only once - specifying the name
0039 // of the Geant4 "physics case" to consider ("FTFP_BERT" will be
0040 // considered as default is the name is not specified) - and then one
0041 // method needs to be called at each collision, specifying the type of
0042 // collision (hadron, energy, direction, material) to be simulated.
0043 // The class HadronicGenerator is expected to work also in a
0044 // multi-threaded environment with "external" threads (i.e. threads
0045 // that are not necessarily managed by Geant4 run-manager):
0046 // each thread should have its own instance of the class.
0047 //
0048 // See the string "***LOOKHERE***" below for the setting of parameters
0049 // of this example: the "physics case", the set of possibilities from
0050 // which to sample the projectile (i.e. whether the projectile is a
0051 // hadron or an ion - in the case of hadron projectile, a list of hadrons
0052 // is possible from which to sample at each collision; in the case of
0053 // ion projectile, only one type of ion needs to be specified),
0054 // the kinetic energy of the projectile (which can be sampled within
0055 // an interval), whether the direction of the projectile is fixed or
0056 // sampled at each collision, the target material (a list of materials
0057 // is possible, from which the target material can be sampled at each
0058 // collision, and then from this target material, the target nucleus
0059 // will be chosen randomly by Geant4 itself), and whether to print out
0060 // some information or not and how frequently.
0061 // Once a well-defined type of hadron-nucleus or nucleus-nucleus
0062 // inelastic collision has been chosen, the method
0063 // HadronicGenerator::GenerateInteraction
0064 // returns the secondaries produced by that interaction (in the form
0065 // of a G4VParticleChange object).
0066 // Some information about this final-state is printed out as an example.
0067 //
0068 // Usage: Hadr09
0069 //------------------------------------------------------------------------
0070
0071 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
0072 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
0073
0074 #include <iomanip>
0075 #include "globals.hh"
0076 #include "G4ios.hh"
0077 #include "G4PhysicalConstants.hh"
0078 #include "G4SystemOfUnits.hh"
0079 #include "G4Material.hh"
0080 #include "G4NistManager.hh"
0081 #include "G4VParticleChange.hh"
0082 #include "G4UnitsTable.hh"
0083 #include "G4SystemOfUnits.hh"
0084 #include "HadronicGenerator.hh"
0085 #include "G4GenericIon.hh"
0086 #include "G4ProcessManager.hh"
0087 #include "G4ParticleTable.hh"
0088 #include "G4IonTable.hh"
0089 #include "CLHEP/Random/Randomize.h"
0090 #include "CLHEP/Random/Ranlux64Engine.h"
0091
0092 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
0093
0094 int main( int , char** ) {
0095
0096 G4cout << "=== Test of the HadronicGenerator ===" << G4endl;
0097
0098 // See the HadronicGenerator class for the possibilities and meaning of the "physics cases".
0099 // ( In short, it is the name of the Geant4 hadronic model used for the simulation of
0100 // the collision, with the possibility of having a transition between two models in
0101 // a given energy interval, as in physics lists. )
0102 //const G4String namePhysics = "FTFP_BERT"; //***LOOKHERE*** PHYSICS CASE
0103 //const G4String namePhysics = "FTFP_BERT_ATL";
0104 //const G4String namePhysics = "QGSP_BERT";
0105 //const G4String namePhysics = "QGSP_BIC";
0106 //const G4String namePhysics = "FTFP_INCLXX";
0107 const G4String namePhysics = "FTFP";
0108 //const G4String namePhysics = "QGSP";
0109 //const G4String namePhysics = "BERT";
0110 //const G4String namePhysics = "BIC";
0111 //const G4String namePhysics = "IonBIC";
0112 //const G4String namePhysics = "INCL";
0113
0114 // The kinetic energy of the projectile will be sampled randomly, with flat probability
0115 // in the interval [minEnergy, maxEnergy].
0116 G4double minEnergy = 1.0*CLHEP::GeV; //***LOOKHERE*** HADRON PROJECTILE MIN Ekin
0117 G4double maxEnergy = 30.0*CLHEP::GeV; //***LOOKHERE*** HADRON PROJECTILE MAX Ekin
0118
0119 const G4int numCollisions = 1000; //***LOOKHERE*** NUMBER OF COLLISIONS
0120
0121 // Enable or disable the print out of this program: if enabled, the number of secondaries
0122 // produced in each collisions is printed out; moreover, once every "printingGap"
0123 // collisions, the list of secondaries is printed out.
0124 const G4bool isPrintingEnabled = true; //***LOOKHERE*** PRINT OUT ON/OFF
0125 const G4int printingGap = 100; //***LOOKHERE*** GAP IN PRINTING
0126
0127 // Vector of Geant4 names of hadron projectiles: one of this will be sampled randomly
0128 // (with uniform probability) for each collision, when the projectile is not an ion.
0129 // Note: comment out the corresponding line in order to exclude a particle.
0130 std::vector< G4String > vecProjectiles; //***LOOKHERE*** POSSIBLE HADRON PROJECTILES
0131 vecProjectiles.push_back( "pi-" );
0132 //Note: vecProjectiles.push_back( "pi0" ); // Excluded because too short-lived
0133 vecProjectiles.push_back( "pi+" );
0134 vecProjectiles.push_back( "kaon-" );
0135 vecProjectiles.push_back( "kaon+" );
0136 vecProjectiles.push_back( "kaon0L" );
0137 vecProjectiles.push_back( "kaon0S" );
0138 //Note: vecProjectiles.push_back( "eta" ); // Excluded because too short-lived
0139 //Note: vecProjectiles.push_back( "eta_prime" ); // Excluded because too short-lived
0140 vecProjectiles.push_back( "proton" );
0141 vecProjectiles.push_back( "neutron" );
0142 vecProjectiles.push_back( "deuteron" );
0143 vecProjectiles.push_back( "triton" );
0144 vecProjectiles.push_back( "He3" );
0145 vecProjectiles.push_back( "alpha" );
0146 vecProjectiles.push_back( "lambda" );
0147 vecProjectiles.push_back( "sigma-" );
0148 //Note: vecProjectiles.push_back( "sigma0" ); // Excluded because too short-lived
0149 vecProjectiles.push_back( "sigma+" );
0150 vecProjectiles.push_back( "xi-" );
0151 vecProjectiles.push_back( "xi0" );
0152 vecProjectiles.push_back( "omega-" );
0153 vecProjectiles.push_back( "anti_proton" );
0154 vecProjectiles.push_back( "anti_neutron" );
0155 vecProjectiles.push_back( "anti_lambda" );
0156 vecProjectiles.push_back( "anti_sigma-" );
0157 //Note: vecProjectiles.push_back( "anti_sigma0" ); // Excluded because too short-lived
0158 vecProjectiles.push_back( "anti_sigma+" );
0159 vecProjectiles.push_back( "anti_xi-" );
0160 vecProjectiles.push_back( "anti_xi0" );
0161 vecProjectiles.push_back( "anti_omega-" );
0162 vecProjectiles.push_back( "anti_deuteron" );
0163 vecProjectiles.push_back( "anti_triton" );
0164 vecProjectiles.push_back( "anti_He3" );
0165 vecProjectiles.push_back( "anti_alpha" );
0166 // Charm and bottom hadrons
0167 vecProjectiles.push_back( "D+" );
0168 vecProjectiles.push_back( "D-" );
0169 vecProjectiles.push_back( "D0" );
0170 vecProjectiles.push_back( "anti_D0" );
0171 vecProjectiles.push_back( "Ds+" );
0172 vecProjectiles.push_back( "Ds-" );
0173 //Note: vecProjectiles.push_back( "etac" ); // Excluded because too short-lived
0174 //Note: vecProjectiles.push_back( "J/psi" ); // Excluded because too short-lived
0175 vecProjectiles.push_back( "B+" );
0176 vecProjectiles.push_back( "B-" );
0177 vecProjectiles.push_back( "B0" );
0178 vecProjectiles.push_back( "anti_B0" );
0179 vecProjectiles.push_back( "Bs0" );
0180 vecProjectiles.push_back( "anti_Bs0" );
0181 vecProjectiles.push_back( "Bc+" );
0182 vecProjectiles.push_back( "Bc-" );
0183 //Note: vecProjectiles.push_back( "Upsilon" ); // Excluded because too short-lived
0184 vecProjectiles.push_back( "lambda_c+" );
0185 vecProjectiles.push_back( "anti_lambda_c+" );
0186 //Note: vecProjectiles.push_back( "sigma_c+" ); // Excluded because too short-lived
0187 //Note: vecProjectiles.push_back( "anti_sigma_c+" ); // Excluded because too short-lived
0188 //Note: vecProjectiles.push_back( "sigma_c0" ); // Excluded because too short-lived
0189 //Note: vecProjectiles.push_back( "anti_sigma_c0" ); // Excluded because too short-lived
0190 //Note: vecProjectiles.push_back( "sigma_c++" ); // Excluded because too short-lived
0191 //Note: vecProjectiles.push_back( "anti_sigma_c++" ); // Excluded because too short-lived
0192 vecProjectiles.push_back( "xi_c+" );
0193 vecProjectiles.push_back( "anti_xi_c+" );
0194 vecProjectiles.push_back( "xi_c0" );
0195 vecProjectiles.push_back( "anti_xi_c0" );
0196 vecProjectiles.push_back( "omega_c0" );
0197 vecProjectiles.push_back( "anti_omega_c0" );
0198 vecProjectiles.push_back( "lambda_b" );
0199 vecProjectiles.push_back( "anti_lambda_b" );
0200 //Note: vecProjectiles.push_back( "sigma_b+" ); // Excluded because too short-lived
0201 //Note: vecProjectiles.push_back( "anti_sigma_b+" ); // Excluded because too short-lived
0202 //Note: vecProjectiles.push_back( "sigma_b0" ); // Excluded because too short-lived
0203 //Note: vecProjectiles.push_back( "sigma_b0" ); // Excluded because too short-lived
0204 //Note: vecProjectiles.push_back( "sigma_b-" ); // Excluded because too short-lived
0205 //Note: vecProjectiles.push_back( "anti_sigma_b-" ); // Excluded because too short-lived
0206 vecProjectiles.push_back( "xi_b0" );
0207 vecProjectiles.push_back( "anti_xi_b0" );
0208 vecProjectiles.push_back( "xi_b-" );
0209 vecProjectiles.push_back( "anti_xi_b-" );
0210 vecProjectiles.push_back( "omega_b-" );
0211 vecProjectiles.push_back( "anti_omega_b-" );
0212
0213 G4ParticleDefinition* projectileNucleus = nullptr;
0214 G4GenericIon* gion = G4GenericIon::GenericIon();
0215 gion->SetProcessManager( new G4ProcessManager( gion ) );
0216 G4ParticleTable* partTable = G4ParticleTable::GetParticleTable();
0217 G4IonTable* ions = partTable->GetIonTable();
0218 partTable->SetReadiness();
0219 ions->CreateAllIon();
0220 ions->CreateAllIsomer();
0221
0222 const G4bool isProjectileIon = true; //***LOOKHERE*** HADRON (false) OR ION (true) PROJECTILE ?
0223 if ( isProjectileIon ) {
0224 minEnergy = 40.0*13.0*CLHEP::GeV; //***LOOKHERE*** ION PROJECTILE MIN Ekin
0225 maxEnergy = 40.0*13.0*CLHEP::GeV; //***LOOKHERE*** ION PROJECTILE MAX Ekin
0226 G4int ionZ = 18, ionA = 40; //***LOOKHERE*** ION PROJECTILE (Z, A)
0227 projectileNucleus = partTable->GetIonTable()->GetIon( ionZ, ionA, 0.0 );
0228 }
0229
0230 // Vector of Geant4 NIST names of materials: one of this will be sampled randomly
0231 // (with uniform probability) for each collision and used as target material.
0232 // Note: comment out the corresponding line in order to exclude a material;
0233 // or, vice versa, add a new line to extend the list with another material.
0234 std::vector< G4String > vecMaterials; //***LOOKHERE*** : NIST TARGET MATERIALS
0235 //vecMaterials.push_back( "G4_H" );
0236 //vecMaterials.push_back( "G4_He" );
0237 //vecMaterials.push_back( "G4_Be" );
0238 //vecMaterials.push_back( "G4_C" );
0239 //vecMaterials.push_back( "G4_Al" );
0240 //vecMaterials.push_back( "G4_Si" );
0241 vecMaterials.push_back( "G4_Sc" );
0242 //vecMaterials.push_back( "G4_Ar" );
0243 //vecMaterials.push_back( "G4_Fe" );
0244 //vecMaterials.push_back( "G4_Cu" );
0245 //vecMaterials.push_back( "G4_W" );
0246 //vecMaterials.push_back( "G4_Pb" );
0247
0248 const G4int numProjectiles = vecProjectiles.size();
0249 const G4int numMaterials = vecMaterials.size();
0250
0251 G4cout << G4endl
0252 << "================= Configuration ==================" << G4endl
0253 << "Model: " << namePhysics << G4endl
0254 << "Ekin: [ " << minEnergy/CLHEP::GeV << " , " << maxEnergy/CLHEP::GeV
0255 << " ] GeV" << G4endl
0256 << "Number of collisions: " << numCollisions << G4endl
0257 << "Number of hadron projectiles: " << numProjectiles << G4endl
0258 << "Number of materials: " << numMaterials << G4endl
0259 << "IsIonProjectile: " << ( projectileNucleus != nullptr ? "true \t" : "false" )
0260 << ( projectileNucleus != nullptr ? projectileNucleus->GetParticleName() : "") << G4endl
0261 << "===================================================" << G4endl
0262 << G4endl;
0263
0264 CLHEP::Ranlux64Engine defaultEngine( 1234567, 4 );
0265 CLHEP::HepRandom::setTheEngine( &defaultEngine );
0266 G4int seed = time( NULL );
0267 CLHEP::HepRandom::setTheSeed( seed );
0268 G4cout << G4endl << " Initial seed = " << seed << G4endl << G4endl;
0269
0270 // Instanciate the HadronicGenerator providing the name of the "physics case"
0271 HadronicGenerator* theHadronicGenerator = new HadronicGenerator( namePhysics );
0272 //****************************************************************************
0273
0274 if ( theHadronicGenerator == nullptr ) {
0275 G4cerr << "ERROR: theHadronicGenerator is NULL !" << G4endl;
0276 return 1;
0277 } else if ( ! theHadronicGenerator->IsPhysicsCaseSupported() ) {
0278 G4cerr << "ERROR: this physics case is NOT supported !" << G4endl;
0279 return 2;
0280 }
0281
0282 // Loop over the collisions
0283 G4double rnd1, rnd2, rnd3, rnd4, rnd5, rnd6, normalization, projectileEnergy;
0284 G4VParticleChange* aChange = nullptr;
0285 for ( G4int i = 0; i < numCollisions; ++i ) {
0286 // Draw some random numbers to select the hadron-nucleus interaction:
0287 // projectile hadron, projectile kinetic energy, projectile direction, and target material.
0288 rnd1 = CLHEP::HepRandom::getTheEngine()->flat();
0289 rnd2 = CLHEP::HepRandom::getTheEngine()->flat();
0290 rnd3 = CLHEP::HepRandom::getTheEngine()->flat();
0291 rnd4 = CLHEP::HepRandom::getTheEngine()->flat();
0292 rnd5 = CLHEP::HepRandom::getTheEngine()->flat();
0293 rnd6 = CLHEP::HepRandom::getTheEngine()->flat();
0294 // Sample the projectile kinetic energy
0295 projectileEnergy = minEnergy + rnd1*( maxEnergy - minEnergy );
0296 if ( projectileEnergy <= 0.0 ) projectileEnergy = minEnergy;
0297 // Sample the projectile direction
0298 normalization = 1.0 / std::sqrt( rnd2*rnd2 + rnd3*rnd3 + rnd4*rnd4 );
0299 const G4bool isOnSmearingDirection = false; //***LOOKHERE*** IF true THEN SMEAR DIRECTION
0300 G4ThreeVector aDirection = G4ThreeVector( 0.0, 0.0, 1.0 ); //***LOOKHERE*** ELSE USE THIS FIXED DIRECTION
0301 if ( isOnSmearingDirection ) {
0302 aDirection = G4ThreeVector( normalization*rnd2, normalization*rnd3, normalization*rnd4 );
0303 }
0304 // Sample the projectile hadron from the vector vecProjectiles
0305 G4int index_projectile = std::trunc( rnd5*numProjectiles );
0306 G4String nameProjectile = vecProjectiles[ index_projectile ];
0307 G4ParticleDefinition* projectile = partTable->FindParticle( nameProjectile );
0308 if ( projectileNucleus ) {
0309 nameProjectile = projectileNucleus->GetParticleName();
0310 projectile = projectileNucleus;
0311 }
0312 // Sample the target material from the vector vecMaterials
0313 // (Note: the target nucleus will be sampled by Geant4)
0314 G4int index_material = std::trunc( rnd6*numMaterials );
0315 G4String nameMaterial = vecMaterials[ index_material ];
0316 G4Material* material = G4NistManager::Instance()->FindOrBuildMaterial( nameMaterial );
0317 if ( material == nullptr ) {
0318 G4cerr << "ERROR: Material " << nameMaterial << " is not found !" << G4endl;
0319 return 3;
0320 }
0321 if ( isPrintingEnabled ) {
0322 G4cout << "\t Collision " << i << " ; projectile=" << nameProjectile;
0323 if ( projectileNucleus ) {
0324 G4cout << " ; Ekin[MeV]/nucleon=" << projectileEnergy /
0325 static_cast< G4double >( std::abs( projectileNucleus->GetBaryonNumber() ) );
0326 } else {
0327 G4cout << " ; Ekin[MeV]=" << projectileEnergy;
0328 }
0329 G4cout << " ; direction=" << aDirection << " ; material=" << nameMaterial;
0330 }
0331
0332 // Call here the "hadronic generator" to get the secondaries produced by the hadronic collision
0333 aChange = theHadronicGenerator->GenerateInteraction( projectile, projectileEnergy,
0334 /* ********************************************** */ aDirection, material );
0335
0336 G4int nsec = aChange ? aChange->GetNumberOfSecondaries() : 0;
0337 G4bool isPrintingOfSecondariesEnabled = false;
0338 if ( isPrintingEnabled ) {
0339 G4cout << G4endl << "\t --> #secondaries=" << nsec
0340 << " ; impactParameter[fm]=" << theHadronicGenerator->GetImpactParameter() / fermi
0341 << " ; #projectileSpectatorNucleons=" << theHadronicGenerator->GetNumberOfProjectileSpectatorNucleons()
0342 << " ; #targetSpectatorNucleons=" << theHadronicGenerator->GetNumberOfTargetSpectatorNucleons()
0343 << " ; #NNcollisions=" << theHadronicGenerator->GetNumberOfNNcollisions() << G4endl;
0344 if ( i % printingGap == 0 ) {
0345 isPrintingOfSecondariesEnabled = true;
0346 G4cout << "\t \t List of produced secondaries: " << G4endl;
0347 }
0348 }
0349 // Loop over produced secondaries and eventually print out some information.
0350 for ( G4int j = 0; j < nsec; ++j ) {
0351 const G4DynamicParticle* sec = aChange->GetSecondary(j)->GetDynamicParticle();
0352 if ( isPrintingOfSecondariesEnabled ) {
0353 G4cout << "\t \t \t j=" << j << "\t" << sec->GetDefinition()->GetParticleName()
0354 << "\t p=" << sec->Get4Momentum() << " MeV" << G4endl;
0355 }
0356 delete aChange->GetSecondary(j);
0357 }
0358 if ( aChange ) aChange->Clear();
0359 }
0360
0361 G4cout << G4endl << " Final random number = " << CLHEP::HepRandom::getTheEngine()->flat()
0362 << G4endl << "=== End of test ===" << G4endl;
0363 }
0364
0365 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
