d3/d4c/TestEm18_2src_2PhysListEmPenelope_8cc_source.html

//

// ********************************************************************

// * License and Disclaimer                                           *

// *                                                                  *

// * The  Geant4 software  is  copyright of the Copyright Holders  of *

// * the Geant4 Collaboration.  It is provided  under  the terms  and *

// * conditions of the Geant4 Software License,  included in the file *

// * LICENSE and available at  http://cern.ch/geant4/license .  These *

// * include a list of copyright holders.                             *

// *                                                                  *

// * Neither the authors of this software system, nor their employing *

// * institutes,nor the agencies providing financial support for this *

// * work  make  any representation or  warranty, express or implied, *

// * regarding  this  software system or assume any liability for its *

// * use.  Please see the license in the file  LICENSE  and URL above *

// * for the full disclaimer and the limitation of liability.         *

// *                                                                  *

// * This  code  implementation is the result of  the  scientific and *

// * technical work of the GEANT4 collaboration.                      *

// * By using,  copying,  modifying or  distributing the software (or *

// * any work based  on the software)  you  agree  to acknowledge its *

// * use  in  resulting  scientific  publications,  and indicate your *

// * acceptance of all terms of the Geant4 Software license.          *

// ********************************************************************

//

//

//

//

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......


#include "PhysListEmPenelope.hh"

#include "G4BuilderType.hh"

#include "G4ParticleDefinition.hh"

#include "G4ProcessManager.hh"

#include "G4PhysicsListHelper.hh"


// gamma


#include "G4PhotoElectricEffect.hh"

#include "G4PenelopePhotoElectricModel.hh"


#include "G4ComptonScattering.hh"

#include "G4PenelopeComptonModel.hh"


#include "G4GammaConversion.hh"

#include "G4PenelopeGammaConversionModel.hh"


#include "G4RayleighScattering.hh"

#include "G4PenelopeRayleighModel.hh"


// e-


#include "G4eIonisation.hh"

#include "G4PenelopeIonisationModel.hh"

#include "G4UniversalFluctuation.hh"


#include "G4eBremsstrahlung.hh"

#include "G4PenelopeBremsstrahlungModel.hh"


// e+


#include "G4eplusAnnihilation.hh"

#include "G4PenelopeAnnihilationModel.hh"


// mu


#include "G4MuIonisation.hh"

#include "G4MuBremsstrahlung.hh"

#include "G4MuPairProduction.hh"


// hadrons, ions


#include "G4hIonisation.hh"

#include "G4ionIonisation.hh"


// deexcitation


#include "G4LossTableManager.hh"

#include "G4UAtomicDeexcitation.hh"


#include "G4SystemOfUnits.hh"


//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......


PhysListEmPenelope::PhysListEmPenelope(const G4String& name)

  :  G4VPhysicsConstructor(name)

{

    G4EmParameters* param = G4EmParameters::Instance();

    param->SetDefaults();

    param->SetMinEnergy(10*eV);

    param->SetMaxEnergy(10*TeV);

    param->SetNumberOfBinsPerDecade(10);

    param->SetBuildCSDARange(true);

    param->SetMaxEnergyForCSDARange(10*TeV);

    SetPhysicsType(bElectromagnetic);


    param->SetVerbose(0);

    param->Dump();

}


//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......


PhysListEmPenelope::~PhysListEmPenelope()

{ }


//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......


void PhysListEmPenelope::ConstructProcess()

{

    G4PhysicsListHelper* list = G4PhysicsListHelper::GetPhysicsListHelper();


  // Add standard EM Processes


  auto particleIterator=GetParticleIterator();

  particleIterator->reset();

  while( (*particleIterator)() ){

    G4ParticleDefinition* particle = particleIterator->value();

    G4String particleName = particle->GetParticleName();


    //Applicability range for Penelope models

    //for higher energies, the Standard models are used

    G4double highEnergyLimit = 1*GeV;


    if (particleName == "gamma") {

      // gamma


      G4PhotoElectricEffect* phot = new G4PhotoElectricEffect();

      G4PenelopePhotoElectricModel*

      photModel = new G4PenelopePhotoElectricModel();

      photModel->SetHighEnergyLimit(highEnergyLimit);

      phot->AddEmModel(0, photModel);

      list->RegisterProcess(phot, particle);


      G4ComptonScattering* compt = new G4ComptonScattering();

      G4PenelopeComptonModel*

      comptModel = new G4PenelopeComptonModel();

      comptModel->SetHighEnergyLimit(highEnergyLimit);

      compt->AddEmModel(0, comptModel);

      list->RegisterProcess(compt, particle);


      G4GammaConversion* conv = new G4GammaConversion();

      G4PenelopeGammaConversionModel*

      convModel = new G4PenelopeGammaConversionModel();

      convModel->SetHighEnergyLimit(highEnergyLimit);

      conv->AddEmModel(0, convModel);

      list->RegisterProcess(conv, particle);


      G4RayleighScattering* rayl = new G4RayleighScattering();

      G4PenelopeRayleighModel*

      raylModel = new G4PenelopeRayleighModel();

      raylModel->SetHighEnergyLimit(highEnergyLimit);

      rayl->AddEmModel(0, raylModel);

      list->RegisterProcess(rayl, particle);


    } else if (particleName == "e-") {

      //electron


      G4eIonisation* eIoni = new G4eIonisation();

      G4PenelopeIonisationModel*

      eIoniModel = new G4PenelopeIonisationModel();

      eIoniModel->SetHighEnergyLimit(highEnergyLimit);

      eIoni->AddEmModel(0, eIoniModel, new G4UniversalFluctuation() );

      list->RegisterProcess(eIoni, particle);


      G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();

      G4PenelopeBremsstrahlungModel*

      eBremModel = new G4PenelopeBremsstrahlungModel();

      eBremModel->SetHighEnergyLimit(highEnergyLimit);

      eBrem->AddEmModel(0, eBremModel);

      list->RegisterProcess(eBrem, particle);


    } else if (particleName == "e+") {

      //positron

      G4eIonisation* eIoni = new G4eIonisation();

      G4PenelopeIonisationModel*

      eIoniModel = new G4PenelopeIonisationModel();

      eIoniModel->SetHighEnergyLimit(highEnergyLimit);

      eIoni->AddEmModel(0, eIoniModel, new G4UniversalFluctuation() );

      list->RegisterProcess(eIoni, particle);


      G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();

      G4PenelopeBremsstrahlungModel*

      eBremModel = new G4PenelopeBremsstrahlungModel();

      eBremModel->SetHighEnergyLimit(highEnergyLimit);

      eBrem->AddEmModel(0, eBremModel);

      list->RegisterProcess(eBrem, particle);


      G4eplusAnnihilation* eAnni = new G4eplusAnnihilation();

      G4PenelopeAnnihilationModel*

      eAnniModel = new G4PenelopeAnnihilationModel();

      eAnniModel->SetHighEnergyLimit(highEnergyLimit);

      eAnni->AddEmModel(0, eAnniModel);

      list->RegisterProcess(eAnni, particle);


    } else if( particleName == "mu+" ||

               particleName == "mu-"    ) {

      //muon

      list->RegisterProcess(new G4MuIonisation,     particle);

      list->RegisterProcess(new G4MuBremsstrahlung, particle);

      list->RegisterProcess(new G4MuPairProduction, particle);


    } else if( particleName == "alpha" || particleName == "GenericIon" ) {

      list->RegisterProcess(new G4ionIonisation, particle);


    } else if ((!particle->IsShortLived()) &&

               (particle->GetPDGCharge() != 0.0) &&

               (particle->GetParticleName() != "chargedgeantino")) {

      //all others charged particles except geantino

      list->RegisterProcess(new G4hIonisation, particle);

    }

  }

  // Deexcitation

  //

  G4VAtomDeexcitation* deex = new G4UAtomicDeexcitation();

  G4LossTableManager::Instance()->SetAtomDeexcitation(deex);

}


//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......