Re: AlongStep DoIt ordering for G4eplusAnnihilation process

Help: Forums, postings and threads

Forums, postings and threads

Click on the Forum title, e.g. on the "Forums by Category" page, to read a sequence of postings to the Forum and its threads all in one page. If you are only interested in one thread or the thread following a specific posting, click the thread or the posting, which takes you to a smaller page, which contains only the part you are interested in and may be easier to navigate.

Layout of the posting thread(s)

The posting threads can be shown with/without the text of the postings ("Inline depth"). In addition the depth of the thread can be controlled ("Outline depth"). For both cases several values are provided, which can be toggled. Note that the displayed values are those, which can be chosen, they do not correspond to the actual display status of the thread(s).

Add message

Add a new posting thread to this Forum

Show subscribers

Click "Show subscribers" to get the List of all subscribers, who receive e-mail from postings to this Forum, if they have not explictly unsubscribed from a posting thread. This includes:

Subscribers to the forum
Explicit subscribers to the posting or any of its ancestors
The author of the posting (if he has not unsubscribed)
The authors of any ancestor posting (if they have not unsubscribed)

Some browsers display old pages from the cache

Some browsers (e.g. Firefox) display a page from the cache even though the page has been updated. As a result, one may not get the latest messages in the forum's outline or the logon ID of the previous session appears on the upper right corner. If one suspects that he or she does not get the latest content of a page, try clearing up the personal data from the browser's cache as the following:

Tools -> Clear Private Data -> Clear Private Data (from browser Firefox)

Tools -> Delete Private Data (from browser Opera)

then reflesh the current page to get the latest content.

Details on "Inline depth" and "Outline depth"

Threads and the follow-up messages are numbered. There is one line per posting, normally starting with the posting number. The URLs of a posting and its responses reflect the depth of the follow-up postings. Watch the URLs to see how this is done. Depending on the chosen display options, the thread-display may be incomplete; the number of messages at the next level is, however, displayed, e.g. "…3 message(s)". You may not see all contributors unless you choose "All".

Messages are "chained" if there are only replies at the first level, i.e. 1/1.html, 1/1/1.html etc. In case of "chained" messages the message number is replaced by the icon and there is no indentation.

Inline: Display the subject line only or also the text of the posting(s); for the choice "All" the "Outline" choices are switched off.

Argument Default value Alternative Comment

1 0 1 no text / full text of posting

2 1 All text for level 1 only / text for All postings

Argument	Default value	Alternative		Comment
1	0	1		no text / full text of posting
2	1	All		text for level 1 only / text for All postings

Outline: Choose the depth of the posting thread, successive toggle controls provide increasing detail.

Argument Default value Alternative Comment

1 2 1 2 levels / 1 level (original posting)

2 3 2 3 levels / 2 levels

3 3 All 3 levels / all levels (all postings)

Argument	Default value	Alternative	Comment
1	2	1	2 levels / 1 level (original posting)
2	3	2	3 levels / 2 levels
3	3	All	3 levels / all levels (all postings)

Thanks Vladimir. I removed the line. Of course, like you anticipated, I also ran into other problems with my user Physics List file. First, K+ was not defined. I added K+ and K-, and now it complains that K0L is not defined. I do not see that K0L is defined in your G4EmStandardPhysics.cc either. I am running a neutron simulation and I am not really interested in kaons in this case. Why do I have to include them? Is there a way around the problem?

I know you said to use the predefined G4EmStandardPhysics.cc file, but the user Physics List that I have inherited includes a lot of custom stuff that I do not want to change. It runs fine with GEANT4.5.1. I add it to the end of this entry if you want to have a look.

Maria

*****************************************************

// Anders Hjalmarsson // // Construct/define particles and physics processes // 1999/12/02 GEANT4 program // // $Id: S1S2PhysList.cc

#include "S1S2PhysList.hh"
#include "globals.hh"
#include "G4ParticleDefinition.hh"
#include "G4ProcessManager.hh"
#include "G4ProcessVector.hh"
#include "G4ParticleTypes.hh"
#include "G4ParticleTable.hh"
#include "G4Material.hh"
#include "G4MaterialTable.hh"
#include "G4ios.hh"
#include "G4IonConstructor.hh"

S1S2PhysList::S1S2PhysList(): G4VUserPhysicsList(),
theNeutronElasticProcess(NULL), theNeutronInelasticProcess(NULL), 
aLENeutronElasticProcess(NULL), aLENeutronInelasticProcess(NULL),
theProtonInelasticProcess(NULL),
aLEProtonInelasticProcess(NULL), thePhotoElectricEffect(NULL),
theComptonScattering(NULL), eminusMultipleScattering(NULL),
eminusIonisation(NULL), ionIonisation(NULL),
aMultipleScattering(NULL), anIonisation(NULL),
theDecayProcess(NULL), theGammaConversion(NULL),
theAnnihilation(NULL), theBremsstrahlung(NULL),
eplusMultipleScattering(NULL),eplusIonisation(NULL),
eplusBremsstrahlung(NULL),theProtonElasticProcess(NULL)
{
  currentDefaultCut = defaultCutValue =0.01*mm;
  //currentDefaultCut = defaultCutValue =0.0001*mm;
  cutForGamma = defaultCutValue;
  cutForElectron = defaultCutValue;
  cutForProton = defaultCutValue;

  SetVerboseLevel(1);
}

S1S2PhysList::~S1S2PhysList()
{
    ;
}

void S1S2PhysList::ConstructParticle()
{
    ConstructBosons();
    ConstructLeptons();
    ConstructBarions();
    ConstructAllIons();
}

void S1S2PhysList::ConstructBosons()
{
    //gamma
    G4Gamma::GammaDefinition();

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

void S1S2PhysList::ConstructLeptons()
{
    //electron
    G4Electron::ElectronDefinition();
    G4Positron::PositronDefinition();
}

void S1S2PhysList::ConstructBarions()
{
    //neutron
    G4Neutron::NeutronDefinition();

    //proton
    G4Proton::ProtonDefinition();
    G4AntiProton::AntiProtonDefinition();
}

void S1S2PhysList::ConstructAllIons()
{
  //  Construct light ions
  G4IonConstructor pConstructor;
  pConstructor.ConstructParticle();  
}

void S1S2PhysList::ConstructProcess()
{
    AddTransportation();
    ConstructGeneral();
    ConstructEM();
    ConstructHad();
    ConstructOp();
}

#include "G4PhotoElectricEffect.hh"
#include "G4ComptonScattering.hh"
#include "G4MultipleScattering.hh"
#include "G4eplusAnnihilation.hh"
#include "G4eIonisation.hh"
#include "G4hIonisation.hh"
#include "G4eBremsstrahlung.hh"

//#include "G4hIonisation.hh"

void S1S2PhysList::ConstructEM()
{
    theParticleIterator -> reset();
    while((*theParticleIterator)())
    {
        G4ParticleDefinition* particle = theParticleIterator -> value();
        G4ProcessManager* pmanager = particle -> GetProcessManager();
        G4String particleName = particle -> GetParticleName();
	if(particleName == "gamma")
	  {
	    //Construct processes for gamma
	    thePhotoElectricEffect = new G4PhotoElectricEffect();
	    theComptonScattering = new G4ComptonScattering();
	    theGammaConversion = new G4GammaConversion();
	    //Add processes for gamm
	    pmanager -> AddDiscreteProcess(thePhotoElectricEffect);
	    pmanager -> AddDiscreteProcess(theComptonScattering);
	    pmanager -> AddProcess(theGammaConversion);
	  }
	else if(particleName == "e-")
	  {
	    //Construct processes for electron
	    eminusMultipleScattering = new G4MultipleScattering();
	    eminusIonisation = new G4eIonisation();
	    theBremsstrahlung = new G4eBremsstrahlung();

	    //Add processes for electron
	    pmanager -> AddProcess(eminusMultipleScattering);
	    pmanager -> AddProcess(eminusIonisation);
	    pmanager -> AddProcess(theBremsstrahlung);
	    //Set ordering for AlongStepDoIt
	    pmanager -> SetProcessOrdering(eminusMultipleScattering, idxAlongStep, 1);
	    pmanager -> SetProcessOrdering(eminusIonisation, idxAlongStep, 2);
	    pmanager -> SetProcessOrdering(theBremsstrahlung, idxAlongStep, 3);
	    //Set ordering for PostStepDoIt
	    pmanager -> SetProcessOrdering(eminusMultipleScattering, idxPostStep, 1);
	    pmanager -> SetProcessOrdering(eminusIonisation, idxPostStep, 2);
	    pmanager -> SetProcessOrdering(theBremsstrahlung, idxPostStep, 3);
	  }
	else if(particleName == "e+")
	{
	    //Construct processes for electron
	    eplusMultipleScattering = new G4MultipleScattering();
	    eplusIonisation = new G4eIonisation();
	    eplusBremsstrahlung = new G4eBremsstrahlung();
	    theAnnihilation = new G4eplusAnnihilation();
	    //Add processes for electron
	    pmanager -> AddProcess(eplusMultipleScattering);
	    pmanager -> AddProcess(eplusIonisation);
	    pmanager -> AddProcess(eplusBremsstrahlung);
	    pmanager -> AddProcess(theAnnihilation);
	    //Set ordering for AlongStepDoIt
	    pmanager -> SetProcessOrdering(eplusMultipleScattering, idxAlongStep, 1);
	    pmanager -> SetProcessOrdering(eplusIonisation, idxAlongStep, 2);
	    pmanager -> SetProcessOrdering(eplusBremsstrahlung, idxAlongStep, 3);
	    pmanager -> SetProcessOrdering(theAnnihilation, idxAlongStep, 4);
	    //Set ordering for PostStepDoIt
	    pmanager -> SetProcessOrdering(eplusMultipleScattering, idxPostStep, 1);
	    pmanager -> SetProcessOrdering(eplusIonisation, idxPostStep, 2);
	    pmanager -> SetProcessOrdering(eplusBremsstrahlung, idxPostStep, 3);
	    pmanager -> SetProcessOrdering(theAnnihilation, idxPostStep, 4);
	}	
	else if(particleName == "GenericIon")
	{
	    ionIonisation = new G4hIonisation();
	    aMultipleScattering = new G4MultipleScattering();
	    //Add processes
	    pmanager -> AddDiscreteProcess(ionIonisation);
	    pmanager -> AddDiscreteProcess(aMultipleScattering);
	    //Set ordering for AlongStepDoIt
	    pmanager -> SetProcessOrdering(ionIonisation, idxAlongStep, 2);
	    pmanager -> SetProcessOrdering(aMultipleScattering, idxAlongStep, 1);
	    //Set ordering for PostStepDoIt
	    pmanager -> SetProcessOrdering(ionIonisation, idxPostStep, 2);
	    pmanager -> SetProcessOrdering(aMultipleScattering, idxPostStep, 1);
	}
	else if((!particle -> IsShortLived()) &&
		 (particle -> GetPDGCharge() != 0.0)) 
	{
	    //All other charged particles
	    aMultipleScattering = new G4MultipleScattering();
	    anIonisation = new G4hIonisation();
	    //Add processes
	    pmanager -> AddDiscreteProcess(aMultipleScattering);
	    pmanager -> AddDiscreteProcess(anIonisation);
	    //Set ordering for AlongStepDoIt
	    pmanager -> SetProcessOrdering(aMultipleScattering, idxAlongStep, 1);
	    pmanager -> SetProcessOrdering(anIonisation, idxAlongStep, 2);
	    //Set ordering for PostStepDoIt
	    pmanager -> SetProcessOrdering(aMultipleScattering, idxPostStep, 1);
	    pmanager -> SetProcessOrdering(anIonisation, idxPostStep, 2);
	}
    }
    G4cout<<"Construct EM over"<<G4endl;
}

#include "G4HadronElasticProcess.hh"
#include "G4NeutronHPElastic.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4NeutronHPInelastic.hh"
#include "G4LElastic.hh"
#include "G4ProtonInelasticProcess.hh"
#include "G4LEProtonInelastic.hh"
#include "G4HadronInelasticProcess.hh"
#include "G4LENeutronInelastic.hh"

void S1S2PhysList::ConstructHad()
{
  theParticleIterator -> reset();
  while((*theParticleIterator)())
    {
      G4ParticleDefinition* particle = theParticleIterator -> value();
      G4ProcessManager* pmanager = particle -> GetProcessManager();
      G4String particleName = particle -> GetParticleName();

      if(particleName == "neutron")
	{
	  //Construct elastic processes for neutrons
	  theNeutronElasticProcess = new G4HadronElasticProcess();
	  aLENeutronElasticProcess = new G4NeutronHPElastic();
	  aNeutronEleaticProcess = new G4LElastic();
	  aNeutronEleaticProcess -> SetMinEnergy(20.0*MeV);
	  theNeutronElasticProcess -> RegisterMe(aNeutronEleaticProcess);
	  theNeutronElasticProcess -> RegisterMe(aLENeutronElasticProcess);
	  //Add elastic process
	  pmanager -> AddDiscreteProcess(theNeutronElasticProcess);
	  //Construct inelastic process for neutrons
	  theNeutronInelasticProcess = new G4NeutronInelasticProcess();
	  //aLENeutronInelasticProcess = new G4NeutronHPInelastic();
	  aLENeutronInelasticProcess = new G4LENeutronInelastic();
	  theNeutronInelasticProcess -> RegisterMe(aLENeutronInelasticProcess);
	  //Add inelastic process
	  pmanager -> AddDiscreteProcess(theNeutronInelasticProcess);
	  //Construct capture process for neutrons
	  theNeutronCaptureProcess = new G4HadronCaptureProcess();
	  aNeutronCaptureProcess = new G4NeutronHPCapture();
	  //Add capture process
	  theNeutronCaptureProcess -> RegisterMe(aNeutronCaptureProcess);
	}
      else if(particleName == "proton")
	{
	  //Construct processes for protons;
	  theProtonElasticProcess = new G4HadronElasticProcess();
	  aLEProtonElasticProcess = new G4LElastic();
	  theProtonElasticProcess -> RegisterMe(aLEProtonElasticProcess);
	  //Add elastic process
	  pmanager -> AddDiscreteProcess(theProtonElasticProcess);
	  //Construct inelastic process for protons
	  theProtonInelasticProcess = new G4ProtonInelasticProcess();
	  aLEProtonInelasticProcess = new G4LEProtonInelastic();
	  theProtonInelasticProcess -> RegisterMe(aLEProtonInelasticProcess);
	  //Add process
	  pmanager -> AddDiscreteProcess(theProtonInelasticProcess);
	}
    }
  G4cout<<"Construct Had Over"<<G4endl;
}

#include "G4Scintillation.hh"
#include "G4OpAbsorption.hh"
#include "G4OpRayleigh.hh"
#include "G4OpBoundaryProcess.hh"

void S1S2PhysList::ConstructOp()
{
  /**
     G4Scintillation *theScintillationProcess = new G4Scintillation("Scintillation");
     G4OpAbsorption* theAbsorptionProcess = new G4OpAbsorption();
     //G4OpRayleigh*   theRayleighScatteringProcess = new G4OpRayleigh();
     G4OpBoundaryProcess* theBoundaryProcess = new G4OpBoundaryProcess();

     //theScintillationProcess->SetVerboseLevel(1);
     //theAbsorptionProcess->SetVerboseLevel(1);
     //theRayleighScatteringProcess->SetVerboseLevel(1);
     //theBoundaryProcess->SetVerboseLevel(1);

     theScintillationProcess->SetTrackSecondariesFirst(true);
     theScintillationProcess->SetScintillationYield(100./MeV);
     theScintillationProcess->SetResolutionScale(1.0);
     theScintillationProcess->SetScintillationTime(1.5*ns);

     G4OpticalSurfaceModel themodel = unified;
     theBoundaryProcess -> SetModel(themodel);

     theParticleIterator -> reset();
     while((*theParticleIterator)())
     {
     G4ParticleDefinition* particle = theParticleIterator -> value();
     G4ProcessManager* pmanager =  particle -> GetProcessManager();
     G4String particleName = particle -> GetParticleName();
     if(theScintillationProcess->IsApplicable(*particle))
     {
     pmanager->AddProcess(theScintillationProcess);
     pmanager->SetProcessOrderingToLast(theScintillationProcess, idxAtRest);
     pmanager->SetProcessOrderingToLast(theScintillationProcess, idxPostStep);
     }
     if(particleName == "opticalphoton")
     {
     pmanager->AddDiscreteProcess(theAbsorptionProcess);
     //pmanager->AddDiscreteProcess(theRayleighScatteringProcess);
     pmanager->AddDiscreteProcess(theBoundaryProcess);
     }
     }
  **/
}

#include "G4Decay.hh"

void S1S2PhysList::ConstructGeneral()
{
    theDecayProcess = new G4Decay();
    theParticleIterator -> reset();
    while((*theParticleIterator)())
    {
        G4ParticleDefinition* particle = theParticleIterator -> 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);
	}
    }
    G4cout<<"Construct General Over"<<G4endl;
}

void S1S2PhysList::SetCuts()
{
  if(currentDefaultCut != defaultCutValue)
    {
      if(cutForGamma == currentDefaultCut)
	{
	  cutForGamma = defaultCutValue;
	}
      if(cutForElectron == currentDefaultCut)
	{
	  cutForElectron = defaultCutValue;
	}
      if(cutForProton == currentDefaultCut)
	{
	  cutForProton = defaultCutValue;
	}
      currentDefaultCut = defaultCutValue;
    }
 if(verboseLevel>0)
    {
      G4cout<<"S1S2PhysicList::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(cutForGamma, "gamma");
      G4cout<<"Cut For Gamma Over"<<G4endl;
      SetCutValue(cutForElectron, "e-");
      SetCutValue(cutForElectron, "e+");
      G4cout<<"Cut For Electron Over"<<G4endl;
	// set cut values for proton and anti_proton before all other hadrons
        // because some processes for hadrons need cut values for proton/anti_proton
      SetCutValue(cutForProton, "proton");
      SetCutValue(cutForProton, "anti_proton");

        // set a cut value to all particles
        SetCutValueForOthers(defaultCutValue);
        if(verboseLevel>0)
	{
	    DumpCutValuesTable();
	}
    }
 G4cout<<"Set Cuts Over"<<G4endl;
}