G4AdjointPhysicsList Class Reference

#include <G4AdjointPhysicsList.hh>

Inheritance diagram for G4AdjointPhysicsList:

Collaboration diagram for G4AdjointPhysicsList:

Public Member Functions
	G4AdjointPhysicsList ()
virtual	~G4AdjointPhysicsList ()
void	SetLossFluctuationFlag (bool aBool)
void	SetUseIonisation (bool aBool)
void	SetUseProtonIonisation (bool aBool)
void	SetUseBrem (bool aBool)
void	SetUseCompton (bool aBool)
void	SetUseMS (bool aBool)
void	SetUsePEEffect (bool aBool)
void	SetUseGammaConversion (bool aBool)
void	SetUseEgainFluctuation (bool aBool)
void	SetEminAdjModels (G4double aVal)
void	SetEmaxAdjModels (G4double aVal)
Public Member Functions inherited from G4VUserPhysicsList
	G4VUserPhysicsList ()
virtual	~G4VUserPhysicsList ()
	G4VUserPhysicsList (const G4VUserPhysicsList &)
G4VUserPhysicsList &	operator= (const G4VUserPhysicsList &)
void	Construct ()
void	UseCoupledTransportation (G4bool vl=true)
void	SetDefaultCutValue (G4double newCutValue)
G4double	GetDefaultCutValue () const
void	BuildPhysicsTable ()
void	PreparePhysicsTable (G4ParticleDefinition *)
void	BuildPhysicsTable (G4ParticleDefinition *)
G4bool	StorePhysicsTable (const G4String &directory=".")
G4bool	IsPhysicsTableRetrieved () const
G4bool	IsStoredInAscii () const
const G4String &	GetPhysicsTableDirectory () const
void	SetPhysicsTableRetrieved (const G4String &directory="")
void	SetStoredInAscii ()
void	ResetPhysicsTableRetrieved ()
void	ResetStoredInAscii ()
void	DumpList () const
void	DumpCutValuesTable (G4int flag=1)
void	DumpCutValuesTableIfRequested ()
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel () const
void	SetCutsWithDefault ()
void	SetCutValue (G4double aCut, const G4String &pname)
G4double	GetCutValue (const G4String &pname) const
void	SetCutValue (G4double aCut, const G4String &pname, const G4String &rname)
void	SetParticleCuts (G4double cut, G4ParticleDefinition *particle, G4Region *region=0)
void	SetParticleCuts (G4double cut, const G4String &particleName, G4Region *region=0)
void	SetCutsForRegion (G4double aCut, const G4String &rname)
void	ResetCuts ()
	obsolete methods More...
void	SetApplyCuts (G4bool value, const G4String &name)
G4bool	GetApplyCuts (const G4String &name) const
void	RemoveProcessManager ()
void	AddProcessManager (G4ParticleDefinition *newParticle, G4ProcessManager *newManager=0)
void	CheckParticleList ()
void	DisableCheckParticleList ()
G4int	GetInstanceID () const
void	InitializeWorker ()

Protected Member Functions
virtual void	ConstructParticle ()
virtual void	ConstructProcess ()
virtual void	SetCuts ()
void	ConstructBosons ()
void	ConstructLeptons ()
void	ConstructMesons ()
void	ConstructBaryons ()
void	ConstructAdjointParticles ()
void	ConstructGeneral ()
void	ConstructEM ()
Protected Member Functions inherited from G4VUserPhysicsList
void	AddTransportation ()
G4bool	RegisterProcess (G4VProcess *process, G4ParticleDefinition *particle)
void	BuildIntegralPhysicsTable (G4VProcess *, G4ParticleDefinition *)
virtual void	RetrievePhysicsTable (G4ParticleDefinition *, const G4String &directory, G4bool ascii=false)
void	InitializeProcessManager ()
G4ParticleTable::G4PTblDicIterator *	GetParticleIterator () const

Protected Attributes
G4eIonisation *	fEminusIonisation
G4hIonisation *	fPIonisation
Protected Attributes inherited from G4VUserPhysicsList
G4ParticleTable *	theParticleTable
G4int	verboseLevel
G4double	defaultCutValue
G4bool	isSetDefaultCutValue
G4ProductionCutsTable *	fCutsTable
G4bool	fRetrievePhysicsTable
G4bool	fStoredInAscii
G4bool	fIsCheckedForRetrievePhysicsTable
G4bool	fIsRestoredCutValues
G4String	directoryPhysicsTable
G4bool	fDisableCheckParticleList
G4int	g4vuplInstanceID

Private Attributes
G4AdjointPhysicsMessenger *	fPhysicsMessenger
G4bool	fUse_eionisation
G4bool	fUse_pionisation
G4bool	fUse_brem
G4bool	fUse_compton
G4bool	fUse_ms
G4bool	fUse_egain_fluctuation
G4bool	fUse_peeffect
G4bool	fUse_gamma_conversion
G4double	fEmin_adj_models
G4double	fEmax_adj_models
G4double	fCS_biasing_factor_compton
G4double	fCS_biasing_factor_brem
G4double	fCS_biasing_factor_ionisation
G4double	fCS_biasing_factor_PEeffect

Additional Inherited Members
Static Public Member Functions inherited from G4VUserPhysicsList
static const G4VUPLManager &	GetSubInstanceManager ()
Static Protected Attributes inherited from G4VUserPhysicsList
static G4RUN_DLL G4VUPLManager	subInstanceManager

Detailed Description

Definition at line 58 of file G4AdjointPhysicsList.hh.

Constructor & Destructor Documentation

G4AdjointPhysicsList()

G4AdjointPhysicsList::G4AdjointPhysicsList

(

)

Definition at line 50 of file G4AdjointPhysicsList.cc.

 :G4VUserPhysicsList(),
  fEminusIonisation(0),fPIonisation(0),
  fUse_eionisation(true),fUse_pionisation(true),
  fUse_brem(true),fUse_compton(true),fUse_ms(true),
  fUse_egain_fluctuation(true),fUse_peeffect(true),
  fEmin_adj_models(1.*keV), fEmax_adj_models(1.*MeV),
  fCS_biasing_factor_compton(1.),fCS_biasing_factor_brem(1.),
  fCS_biasing_factor_ionisation(1.),fCS_biasing_factor_PEeffect(1.)
{
  defaultCutValue = 1.0*mm;
  SetVerboseLevel(1);
  fPhysicsMessenger = new G4AdjointPhysicsMessenger(this);
}

Here is the call graph for this function:

~G4AdjointPhysicsList()

G4AdjointPhysicsList::~G4AdjointPhysicsList ( )

virtual

Definition at line 67 of file G4AdjointPhysicsList.cc.

{
}

Member Function Documentation

ConstructAdjointParticles()

void G4AdjointPhysicsList::ConstructAdjointParticles ( )

protected

Definition at line 155 of file G4AdjointPhysicsList.cc.

{
// adjoint_gammma
  G4AdjointGamma::AdjointGammaDefinition();

// adjoint_electron
  G4AdjointElectron::AdjointElectronDefinition();
  
// adjoint_proton
  G4AdjointProton::AdjointProtonDefinition();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ConstructBaryons()

void G4AdjointPhysicsList::ConstructBaryons ( )

protected

Definition at line 141 of file G4AdjointPhysicsList.cc.

{
//  barions
  G4Proton::ProtonDefinition();
  G4AntiProton::AntiProtonDefinition();
  G4Neutron::NeutronDefinition();
  G4AntiNeutron::AntiNeutronDefinition();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ConstructBosons()

void G4AdjointPhysicsList::ConstructBosons ( )

protected

Definition at line 92 of file G4AdjointPhysicsList.cc.

{
  // pseudo-particles
  G4Geantino::GeantinoDefinition();
  G4ChargedGeantino::ChargedGeantinoDefinition();

  // gamma
  G4Gamma::GammaDefinition();

  // optical photon
  G4OpticalPhoton::OpticalPhotonDefinition();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ConstructEM()

void G4AdjointPhysicsList::ConstructEM ( )

protected

Definition at line 211 of file G4AdjointPhysicsList.cc.

{ G4AdjointCSManager* theCSManager =
              G4AdjointCSManager::GetAdjointCSManager();
  
  G4AdjointSimManager* theAdjointSimManager =
              G4AdjointSimManager::GetInstance();
  
  theCSManager->RegisterAdjointParticle(
            G4AdjointElectron::AdjointElectron());
  
  if (fUse_brem || fUse_peeffect ||fUse_compton)
              theCSManager->RegisterAdjointParticle(
                  G4AdjointGamma::AdjointGamma());

  if (fUse_eionisation) {
          if (!fEminusIonisation) fEminusIonisation  =
                         new G4eIonisation();
        fEminusIonisation->SetLossFluctuations(fUse_egain_fluctuation);
  }

  if (fUse_pionisation) {
          if (!fPIonisation) fPIonisation  = new G4hIonisation();
        fPIonisation->SetLossFluctuations(fUse_egain_fluctuation);
        theCSManager->RegisterAdjointParticle(
                G4AdjointProton::AdjointProton());
  }        
  
  G4eBremsstrahlung* theeminusBremsstrahlung = 0;
  if (fUse_brem && fUse_eionisation)
                  theeminusBremsstrahlung = new G4eBremsstrahlung();
  
  G4ComptonScattering* theComptonScattering =0;
  if (fUse_compton) theComptonScattering = new G4ComptonScattering();
  
  G4PhotoElectricEffect* thePEEffect =0;
  if (fUse_peeffect) thePEEffect = new G4PhotoElectricEffect();
  
  G4eMultipleScattering* theeminusMS = 0;
  G4hMultipleScattering* thepMS= 0;
  if (fUse_ms) {
           theeminusMS = new G4eMultipleScattering();
          thepMS = new G4hMultipleScattering();
  }        
  
  G4VProcess*  theGammaConversion =0;
  if (fUse_gamma_conversion) theGammaConversion = new G4GammaConversion();
 
  //Define adjoint e- ionisation
  //-------------------
  G4AdjointeIonisationModel* theeInverseIonisationModel = 0;
  G4eInverseIonisation* theeInverseIonisationProjToProjCase = 0 ;
  G4eInverseIonisation* theeInverseIonisationProdToProjCase = 0;
  if (fUse_eionisation) {
    theeInverseIonisationModel = new G4AdjointeIonisationModel();
    theeInverseIonisationModel->SetHighEnergyLimit(
                                      fEmax_adj_models);
    theeInverseIonisationModel->SetLowEnergyLimit(
                                       fEmin_adj_models);
    theeInverseIonisationModel->SetCSBiasingFactor(
                                    fCS_biasing_factor_ionisation);
    theeInverseIonisationProjToProjCase =
                   new G4eInverseIonisation(true,"Inv_eIon",
                      theeInverseIonisationModel);
    theeInverseIonisationProdToProjCase =
              new G4eInverseIonisation(false,"Inv_eIon1",
                          theeInverseIonisationModel);
    theAdjointSimManager->ConsiderParticleAsPrimary(G4String("e-"));
  }        

  //Define  adjoint Bremsstrahlung
  //-------------------------------
  G4AdjointBremsstrahlungModel* theeInverseBremsstrahlungModel = 0;
  G4eInverseBremsstrahlung* theeInverseBremsstrahlungProjToProjCase = 0;
  G4eInverseBremsstrahlung* theeInverseBremsstrahlungProdToProjCase = 0; 

  if (fUse_brem && fUse_eionisation) {
    theeInverseBremsstrahlungModel = new G4AdjointBremsstrahlungModel();
    theeInverseBremsstrahlungModel->SetHighEnergyLimit(fEmax_adj_models);
    theeInverseBremsstrahlungModel->SetLowEnergyLimit(fEmin_adj_models);
    theeInverseBremsstrahlungModel->SetCSBiasingFactor(
                                     fCS_biasing_factor_brem);
    theeInverseBremsstrahlungProjToProjCase = new G4eInverseBremsstrahlung(
                             true,"Inv_eBrem",theeInverseBremsstrahlungModel);
    theeInverseBremsstrahlungProdToProjCase = new G4eInverseBremsstrahlung(
        false,"Inv_eBrem1",theeInverseBremsstrahlungModel);
    theAdjointSimManager->ConsiderParticleAsPrimary(G4String("e-"));
    theAdjointSimManager->ConsiderParticleAsPrimary(G4String("gamma"));
  }

  
  //Define  adjoint Compton
  //---------------------
  
  G4AdjointComptonModel* theeInverseComptonModel = 0;
  G4eInverseCompton* theeInverseComptonProjToProjCase = 0;
  G4eInverseCompton* theeInverseComptonProdToProjCase = 0;

  if (fUse_compton) { 
    theeInverseComptonModel = new G4AdjointComptonModel();
    theeInverseComptonModel->SetHighEnergyLimit(fEmax_adj_models);
    theeInverseComptonModel->SetLowEnergyLimit(fEmin_adj_models);
    theeInverseComptonModel->SetDirectProcess(theComptonScattering);
    theeInverseComptonModel->SetUseMatrix(false);
    theeInverseComptonModel->SetCSBiasingFactor( fCS_biasing_factor_compton);
    theeInverseComptonProjToProjCase = new G4eInverseCompton(true,"Inv_Compt",
                                           theeInverseComptonModel);
    theeInverseComptonProdToProjCase = new G4eInverseCompton(false,"Inv_Compt1",
                                          theeInverseComptonModel);
    theAdjointSimManager->ConsiderParticleAsPrimary(G4String("e-"));
    theAdjointSimManager->ConsiderParticleAsPrimary(G4String("gamma"));
  }

  //Define  adjoint PEEffect
  //---------------------
  G4AdjointPhotoElectricModel* theInversePhotoElectricModel = 0;
  G4InversePEEffect* theInversePhotoElectricProcess = 0;
  
  if (fUse_peeffect) { 
    theInversePhotoElectricModel = new G4AdjointPhotoElectricModel();
    theInversePhotoElectricModel->SetHighEnergyLimit(fEmax_adj_models);
    theInversePhotoElectricModel->SetLowEnergyLimit(fEmin_adj_models);
    theInversePhotoElectricModel->SetCSBiasingFactor(
                                  fCS_biasing_factor_PEeffect);
    theInversePhotoElectricProcess = new G4InversePEEffect("Inv_PEEffect",
                                       theInversePhotoElectricModel);
    theAdjointSimManager->ConsiderParticleAsPrimary(G4String("e-"));
    theAdjointSimManager->ConsiderParticleAsPrimary(G4String("gamma"));
  }
  

  //Define  adjoint ionisation for protons
  //---------------------
   G4AdjointhIonisationModel* thepInverseIonisationModel = 0;
   G4hInverseIonisation* thepInverseIonisationProjToProjCase = 0 ;
   G4hInverseIonisation* thepInverseIonisationProdToProjCase = 0;
   if (fUse_pionisation) {
     thepInverseIonisationModel = new G4AdjointhIonisationModel(
                                           G4Proton::Proton());
     thepInverseIonisationModel->SetHighEnergyLimit(fEmax_adj_models);
     thepInverseIonisationModel->SetLowEnergyLimit(fEmin_adj_models);
     thepInverseIonisationModel->SetUseMatrix(false);
     thepInverseIonisationProjToProjCase = new G4hInverseIonisation(true,
                                     "Inv_pIon",thepInverseIonisationModel);
     thepInverseIonisationProdToProjCase = new G4hInverseIonisation(false,
                                    "Inv_pIon1",thepInverseIonisationModel);
     theAdjointSimManager->ConsiderParticleAsPrimary(G4String("e-"));
     theAdjointSimManager->ConsiderParticleAsPrimary(G4String("proton"));
  }

  

  //Declare the processes active for the different particles
  //--------------------------------------------------------
  auto particleIterator=GetParticleIterator();
  particleIterator->reset();
  while( (*particleIterator)() ){
    G4ParticleDefinition* particle = particleIterator->value();
    G4ProcessManager* pmanager = particle->GetProcessManager();
    if (!pmanager) {
     pmanager = new G4ProcessManager(particle);
     particle->SetProcessManager(pmanager);
    }
        
    G4String particleName = particle->GetParticleName();
    if (particleName == "e-") {
      if (fUse_ms && fUse_eionisation) pmanager->AddProcess(theeminusMS);
      if (fUse_eionisation){
        pmanager->AddProcess(fEminusIonisation);
        G4AdjointCSManager::GetAdjointCSManager()->
                    RegisterEnergyLossProcess(fEminusIonisation,particle);
      }
      if (fUse_brem && fUse_eionisation) {
        pmanager->AddProcess(theeminusBremsstrahlung);
        G4AdjointCSManager::GetAdjointCSManager()->
                   RegisterEnergyLossProcess(theeminusBremsstrahlung,particle);
      }
      G4int n_order=0;
      if (fUse_ms && fUse_eionisation) {
        n_order++;
        pmanager->SetProcessOrdering(theeminusMS, idxAlongStep,n_order);
      }
      if (fUse_eionisation) {
        n_order++;
        pmanager->SetProcessOrdering(fEminusIonisation,idxAlongStep,n_order);
      }
      if (fUse_brem && fUse_eionisation) {
        n_order++;
        pmanager->SetProcessOrdering(theeminusBremsstrahlung,
                                           idxAlongStep,n_order);
      }
      n_order=0;
      if (fUse_ms && fUse_eionisation) {
        n_order++;
        pmanager->SetProcessOrdering(theeminusMS,idxPostStep,n_order);
      }
      if (fUse_eionisation) {
        n_order++;
        pmanager->SetProcessOrdering(fEminusIonisation,idxPostStep,n_order);
      }
      if (fUse_brem && fUse_eionisation) {
        n_order++;
        pmanager->SetProcessOrdering(theeminusBremsstrahlung,idxPostStep,
                                                                     n_order);
          }
      }

      if (particleName == "adj_e-") {
        G4ContinuousGainOfEnergy* theContinuousGainOfEnergy =0;
        if (fUse_eionisation ) {
          theContinuousGainOfEnergy= new G4ContinuousGainOfEnergy();
          theContinuousGainOfEnergy->SetLossFluctuations(
                                   fUse_egain_fluctuation);
          theContinuousGainOfEnergy->SetDirectEnergyLossProcess(
                                              fEminusIonisation);
          theContinuousGainOfEnergy->SetDirectParticle(G4Electron::Electron());
          pmanager->AddProcess(theContinuousGainOfEnergy);
          }
          G4int n_order=0;
          if (fUse_ms) {
            n_order++;
            pmanager->AddProcess(theeminusMS);
            pmanager->SetProcessOrdering(theeminusMS, idxAlongStep,n_order);
          }

          n_order++;
          pmanager->SetProcessOrdering(theContinuousGainOfEnergy,idxAlongStep,
                                                                    n_order);


          n_order++;
          G4AdjointAlongStepWeightCorrection* theAlongStepWeightCorrection =
                                      new G4AdjointAlongStepWeightCorrection();
          pmanager->AddProcess(theAlongStepWeightCorrection);
          pmanager->SetProcessOrdering(theAlongStepWeightCorrection,
                                                            idxAlongStep,
                                                                 n_order);
          n_order=0;
          if (fUse_eionisation) {
            pmanager->AddProcess(theeInverseIonisationProjToProjCase);
            pmanager->AddProcess(theeInverseIonisationProdToProjCase);
            n_order++;
            pmanager->SetProcessOrdering(theeInverseIonisationProjToProjCase,
                                                          idxPostStep,n_order);
            n_order++;
            pmanager->SetProcessOrdering(theeInverseIonisationProdToProjCase,
                                                         idxPostStep,n_order);
          }
                
          if (fUse_brem && fUse_eionisation) {
            pmanager->AddProcess(theeInverseBremsstrahlungProjToProjCase);
            n_order++;
            pmanager->SetProcessOrdering(
                              theeInverseBremsstrahlungProjToProjCase,
                                                       idxPostStep,n_order);
          }

          if (fUse_compton) {
            pmanager->AddProcess(theeInverseComptonProdToProjCase);
            n_order++;
            pmanager->SetProcessOrdering(theeInverseComptonProdToProjCase,
                                                         idxPostStep,n_order);
          }
          if (fUse_peeffect) {
            pmanager->AddDiscreteProcess(theInversePhotoElectricProcess);
            n_order++;
            pmanager->SetProcessOrdering(theInversePhotoElectricProcess,
                                                           idxPostStep,n_order);
          }
          if (fUse_pionisation) {
            pmanager->AddProcess(thepInverseIonisationProdToProjCase);
            n_order++;
            pmanager->SetProcessOrdering(thepInverseIonisationProdToProjCase,
                                                         idxPostStep,n_order);
          }
          if (fUse_ms && fUse_eionisation) {
            n_order++;
            pmanager->SetProcessOrdering(theeminusMS,idxPostStep,n_order);
          }
        }
        
           
        if(particleName == "adj_gamma") {
          G4int n_order=0;
          G4AdjointAlongStepWeightCorrection* theAlongStepWeightCorrection =
                                      new G4AdjointAlongStepWeightCorrection();
          pmanager->AddProcess(theAlongStepWeightCorrection);
          pmanager->SetProcessOrdering(theAlongStepWeightCorrection,
                                                       idxAlongStep,1);
                
          if (fUse_brem && fUse_eionisation) {
            pmanager->AddProcess(theeInverseBremsstrahlungProdToProjCase);
            n_order++;
            pmanager->SetProcessOrdering(
                                  theeInverseBremsstrahlungProdToProjCase,
                                                   idxPostStep,n_order);
             }
          if (fUse_compton) {
            pmanager->AddDiscreteProcess(theeInverseComptonProjToProjCase);
            n_order++;
            pmanager->SetProcessOrdering(theeInverseComptonProjToProjCase,
                                                        idxPostStep,n_order);
          }
        } 
   
        if (particleName == "gamma") {
          if (fUse_compton) {
            pmanager->AddDiscreteProcess(theComptonScattering);
                G4AdjointCSManager::GetAdjointCSManager()->
                             RegisterEmProcess(theComptonScattering,particle);
          }
          if (fUse_peeffect) {
                pmanager->AddDiscreteProcess(thePEEffect);
                G4AdjointCSManager::GetAdjointCSManager()->
                                       RegisterEmProcess(thePEEffect,particle);
          }
      if (fUse_gamma_conversion) {
            pmanager->AddDiscreteProcess(theGammaConversion);
      }
     }
        
     if (particleName == "e+" && fUse_gamma_conversion) {//positron
      G4VProcess* theeplusMultipleScattering = new G4eMultipleScattering();
      G4VProcess* theeplusIonisation         = new G4eIonisation();
      G4VProcess* theeplusBremsstrahlung     = new G4eBremsstrahlung();
      G4VProcess* theeplusAnnihilation       = new G4eplusAnnihilation();

      // add processes
      pmanager->AddProcess(theeplusMultipleScattering);
      pmanager->AddProcess(theeplusIonisation);
      pmanager->AddProcess(theeplusBremsstrahlung);
      pmanager->AddProcess(theeplusAnnihilation);

      // set ordering for AtRestDoIt
      pmanager->SetProcessOrderingToFirst(theeplusAnnihilation, idxAtRest);

      // set ordering for AlongStepDoIt
      pmanager->SetProcessOrdering(theeplusMultipleScattering,
                                                             idxAlongStep,1);
      pmanager->SetProcessOrdering(theeplusIonisation, idxAlongStep,2);
      pmanager->SetProcessOrdering(theeplusBremsstrahlung,idxAlongStep,3);

      // set ordering for PostStepDoIt
      pmanager->SetProcessOrdering(theeplusMultipleScattering,
                                                             idxPostStep,1);
      pmanager->SetProcessOrdering(theeplusIonisation,idxPostStep,2);
      pmanager->SetProcessOrdering(theeplusBremsstrahlung,idxPostStep,3);
      pmanager->SetProcessOrdering(theeplusAnnihilation,idxPostStep,4);
        }
        if (particleName == "proton" && fUse_pionisation) {
          if (fUse_ms && fUse_pionisation) pmanager->AddProcess(thepMS);

          if (fUse_pionisation){
                pmanager->AddProcess(fPIonisation);
                G4AdjointCSManager::GetAdjointCSManager()->
                          RegisterEnergyLossProcess(fPIonisation,particle);
          }

          G4int n_order=0;
          if (fUse_ms && fUse_pionisation) {
            n_order++;
                pmanager->SetProcessOrdering(thepMS, idxAlongStep,n_order);
          }

          if (fUse_pionisation) {
              n_order++;
              pmanager->SetProcessOrdering(fPIonisation,idxAlongStep,n_order);
          }
                
          n_order=0;
          if (fUse_ms && fUse_pionisation) {
                n_order++;
              pmanager->SetProcessOrdering(thepMS, idxPostStep,n_order);
          }

          if (fUse_pionisation) {
              n_order++;
              pmanager->SetProcessOrdering(fPIonisation,idxPostStep,n_order);
          }
        
        }
        
        if (particleName == "adj_proton" && fUse_pionisation) {
          G4ContinuousGainOfEnergy* theContinuousGainOfEnergy =0;
          if (fUse_pionisation ) {
           theContinuousGainOfEnergy= new G4ContinuousGainOfEnergy();
           theContinuousGainOfEnergy->SetLossFluctuations(
                                   fUse_egain_fluctuation);
           theContinuousGainOfEnergy->SetDirectEnergyLossProcess(fPIonisation);
              theContinuousGainOfEnergy->SetDirectParticle(G4Proton::Proton());
              pmanager->AddProcess(theContinuousGainOfEnergy);
           }

           G4int n_order=0;
           if (fUse_ms) {
             n_order++;
             pmanager->AddProcess(thepMS);
             pmanager->SetProcessOrdering(thepMS, idxAlongStep,n_order);
           }

           n_order++;
           pmanager->SetProcessOrdering(theContinuousGainOfEnergy,idxAlongStep,
                                                                       n_order);
                
           n_order++;
           G4AdjointAlongStepWeightCorrection* theAlongStepWeightCorrection =
                                      new G4AdjointAlongStepWeightCorrection();
          pmanager->AddProcess(theAlongStepWeightCorrection);
          pmanager->SetProcessOrdering(theAlongStepWeightCorrection,
                                                idxAlongStep,
                                                        n_order);
          n_order=0;
          if (fUse_pionisation) {
            pmanager->AddProcess(thepInverseIonisationProjToProjCase);
            n_order++;
                pmanager->SetProcessOrdering(
                                   thepInverseIonisationProjToProjCase,
                                                       idxPostStep,n_order);
          }

          if (fUse_ms && fUse_pionisation) {
            n_order++;
            pmanager->SetProcessOrdering(thepMS,idxPostStep,n_order);
          }
        }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ConstructGeneral()

void G4AdjointPhysicsList::ConstructGeneral ( )

protected

Definition at line 641 of file G4AdjointPhysicsList.cc.

{
  // Add Decay Process
   G4Decay* theDecayProcess = new G4Decay();
  auto particleIterator=GetParticleIterator();
  particleIterator->reset();
  while( (*particleIterator)() ){
    G4ParticleDefinition* particle = particleIterator->value();
    G4ProcessManager* pmanager = particle->GetProcessManager();
    if (theDecayProcess->IsApplicable(*particle)) { 
      pmanager ->AddProcess(theDecayProcess);
      // set ordering for PostStepDoIt and AtRestDoIt
      pmanager ->SetProcessOrdering(theDecayProcess, idxPostStep);
      pmanager ->SetProcessOrdering(theDecayProcess, idxAtRest);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ConstructLeptons()

void G4AdjointPhysicsList::ConstructLeptons ( )

protected

Definition at line 107 of file G4AdjointPhysicsList.cc.

{
  // leptons
  G4Electron::ElectronDefinition();
  G4Positron::PositronDefinition();
  G4MuonPlus::MuonPlusDefinition();
  G4MuonMinus::MuonMinusDefinition();

  G4NeutrinoE::NeutrinoEDefinition();
  G4AntiNeutrinoE::AntiNeutrinoEDefinition();
  G4NeutrinoMu::NeutrinoMuDefinition();
  G4AntiNeutrinoMu::AntiNeutrinoMuDefinition();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ConstructMesons()

void G4AdjointPhysicsList::ConstructMesons ( )

protected

Definition at line 123 of file G4AdjointPhysicsList.cc.

{
//  mesons
  G4PionPlus::PionPlusDefinition();
  G4PionMinus::PionMinusDefinition();
  G4PionZero::PionZeroDefinition();
  G4Eta::EtaDefinition();
  G4EtaPrime::EtaPrimeDefinition();
  G4KaonPlus::KaonPlusDefinition();
  G4KaonMinus::KaonMinusDefinition();
  G4KaonZero::KaonZeroDefinition();
  G4AntiKaonZero::AntiKaonZeroDefinition();
  G4KaonZeroLong::KaonZeroLongDefinition();
  G4KaonZeroShort::KaonZeroShortDefinition();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ConstructParticle()

void G4AdjointPhysicsList::ConstructParticle ( void  )

protectedvirtual

Implements G4VUserPhysicsList.

Definition at line 70 of file G4AdjointPhysicsList.cc.

{
  // In this method, static member functions should be called
  // for all particles which you want to use.
  // This ensures that objects of these particle types will be
  // created in the program. 
  ConstructBosons();
  ConstructLeptons();
  ConstructMesons();
  ConstructBaryons();
  ConstructAdjointParticles();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ConstructProcess()

void G4AdjointPhysicsList::ConstructProcess ( void  )

protectedvirtual

Implements G4VUserPhysicsList.

Definition at line 169 of file G4AdjointPhysicsList.cc.

{
  AddTransportation();
  ConstructEM();
  ConstructGeneral();
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetCuts()

void G4AdjointPhysicsList::SetCuts ( )

protectedvirtual

Reimplemented from G4VUserPhysicsList.

Definition at line 661 of file G4AdjointPhysicsList.cc.

{
  if (verboseLevel >0){
    G4cout << "G4AdjointPhysicsList::SetCuts:";
    G4cout << "CutLength : " << G4BestUnit(defaultCutValue,"Length") << G4endl;
  }

  // set cut values for gamma at first and for e- second and next for e+,
  // because some processes for e+/e- need cut values for gamma
  //
  SetCutValue(defaultCutValue, "gamma");
  SetCutValue(defaultCutValue, "e-");
  SetCutValue(defaultCutValue, "e+");

  if (verboseLevel>0) DumpCutValuesTable();
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetEmaxAdjModels()

void G4AdjointPhysicsList::SetEmaxAdjModels ( G4double  aVal )

inline

Definition at line 75 of file G4AdjointPhysicsList.hh.

{ fEmax_adj_models = aVal;}

Here is the call graph for this function:

Here is the caller graph for this function:

SetEminAdjModels()

void G4AdjointPhysicsList::SetEminAdjModels ( G4double  aVal )

inline

Definition at line 74 of file G4AdjointPhysicsList.hh.

{ fEmin_adj_models = aVal;}

Here is the caller graph for this function:

SetLossFluctuationFlag()

void G4AdjointPhysicsList::SetLossFluctuationFlag

(

bool

aBool

)

Definition at line 85 of file G4AdjointPhysicsList.cc.

{
 if (fEminusIonisation) fEminusIonisation->SetLossFluctuations(aBool);
}

Here is the call graph for this function:

SetUseBrem()

void G4AdjointPhysicsList::SetUseBrem ( bool  aBool )

inline

Definition at line 66 of file G4AdjointPhysicsList.hh.

{fUse_brem = aBool;}

Here is the caller graph for this function:

SetUseCompton()

void G4AdjointPhysicsList::SetUseCompton ( bool  aBool )

inline

Definition at line 67 of file G4AdjointPhysicsList.hh.

{fUse_compton = aBool;}

Here is the caller graph for this function:

SetUseEgainFluctuation()

void G4AdjointPhysicsList::SetUseEgainFluctuation ( bool  aBool )

inline

Definition at line 72 of file G4AdjointPhysicsList.hh.

                                                 { fUse_egain_fluctuation
                        = aBool;}

Here is the caller graph for this function:

SetUseGammaConversion()

void G4AdjointPhysicsList::SetUseGammaConversion ( bool  aBool )

inline

Definition at line 70 of file G4AdjointPhysicsList.hh.

                                                { fUse_gamma_conversion
                       = aBool;}

Here is the caller graph for this function:

SetUseIonisation()

void G4AdjointPhysicsList::SetUseIonisation ( bool  aBool )

inline

Definition at line 64 of file G4AdjointPhysicsList.hh.

{fUse_eionisation = aBool;}

SetUseMS()

void G4AdjointPhysicsList::SetUseMS ( bool  aBool )

inline

Definition at line 68 of file G4AdjointPhysicsList.hh.

{fUse_ms = aBool;}

Here is the caller graph for this function:

SetUsePEEffect()

void G4AdjointPhysicsList::SetUsePEEffect ( bool  aBool )

inline

Definition at line 69 of file G4AdjointPhysicsList.hh.

{fUse_peeffect = aBool;}

Here is the caller graph for this function:

SetUseProtonIonisation()

void G4AdjointPhysicsList::SetUseProtonIonisation ( bool  aBool )

inline

Definition at line 65 of file G4AdjointPhysicsList.hh.

{fUse_pionisation = aBool;}

Here is the caller graph for this function:

Member Data Documentation

fCS_biasing_factor_brem

G4double G4AdjointPhysicsList::fCS_biasing_factor_brem

private

Definition at line 109 of file G4AdjointPhysicsList.hh.

fCS_biasing_factor_compton

G4double G4AdjointPhysicsList::fCS_biasing_factor_compton

private

Definition at line 108 of file G4AdjointPhysicsList.hh.

fCS_biasing_factor_ionisation

G4double G4AdjointPhysicsList::fCS_biasing_factor_ionisation

private

Definition at line 110 of file G4AdjointPhysicsList.hh.

fCS_biasing_factor_PEeffect

G4double G4AdjointPhysicsList::fCS_biasing_factor_PEeffect

private

Definition at line 111 of file G4AdjointPhysicsList.hh.

fEmax_adj_models

G4double G4AdjointPhysicsList::fEmax_adj_models

private

Definition at line 107 of file G4AdjointPhysicsList.hh.

fEmin_adj_models

G4double G4AdjointPhysicsList::fEmin_adj_models

private

Definition at line 106 of file G4AdjointPhysicsList.hh.

fEminusIonisation

G4eIonisation* G4AdjointPhysicsList::fEminusIonisation

protected

Definition at line 93 of file G4AdjointPhysicsList.hh.

fPhysicsMessenger

G4AdjointPhysicsMessenger* G4AdjointPhysicsList::fPhysicsMessenger

private

Definition at line 97 of file G4AdjointPhysicsList.hh.

fPIonisation

G4hIonisation* G4AdjointPhysicsList::fPIonisation

protected

Definition at line 94 of file G4AdjointPhysicsList.hh.

fUse_brem

G4bool G4AdjointPhysicsList::fUse_brem

private

Definition at line 100 of file G4AdjointPhysicsList.hh.

fUse_compton

G4bool G4AdjointPhysicsList::fUse_compton

private

Definition at line 101 of file G4AdjointPhysicsList.hh.

fUse_egain_fluctuation

G4bool G4AdjointPhysicsList::fUse_egain_fluctuation

private

Definition at line 103 of file G4AdjointPhysicsList.hh.

fUse_eionisation

G4bool G4AdjointPhysicsList::fUse_eionisation

private

Definition at line 98 of file G4AdjointPhysicsList.hh.

fUse_gamma_conversion

G4bool G4AdjointPhysicsList::fUse_gamma_conversion

private

Definition at line 105 of file G4AdjointPhysicsList.hh.

fUse_ms

G4bool G4AdjointPhysicsList::fUse_ms

private

Definition at line 102 of file G4AdjointPhysicsList.hh.

fUse_peeffect

G4bool G4AdjointPhysicsList::fUse_peeffect

private

Definition at line 104 of file G4AdjointPhysicsList.hh.

fUse_pionisation

G4bool G4AdjointPhysicsList::fUse_pionisation

private

Definition at line 99 of file G4AdjointPhysicsList.hh.

---

The documentation for this class was generated from the following files:

• G4AdjointPhysicsList.hh
• G4AdjointPhysicsList.cc