Message: Light nuclei inelastic process - a possible bug? Not Logged In (login)
 Next-in-Thread Next-in-Thread
 Next-in-Forum Next-in-Forum

Question Light nuclei inelastic process - a possible bug? 

Forum: Hadronic Processes
Date: 15 May, 2012
From: Aleksandr Nesterenok <Aleksandr Nesterenok>

Hello! I study interaction of cosmic ray nuclei with air. I use a physic's list for ions - is below. I have launched a primary alpha particle with energy 15 GeV and higher. G4LEAlphaInelastic process must work at these energies. Two versions of Geant have been used - 9.5p01 and 9.4. I have found, that output for this two versions is critically different. I look at secondary hadron production (neutrons, protons, tritium). In the case of 9.5p01, there is no hadron production at all contrary to version 9.4. In addition, the simulation in the first case is several times faster. It seems that, in the case of version 9.5, inelastic scattering for alpha particles is not implemented at all. Possible bug in my program or in Geant?

The ion physics of my physic's list:

void CRPhysicsList::ConstructInelasticNuclei()
{
	G4double DEnLim, TEnLim, AlphaEnLim, He3EnLim, GIEnLim, QMDEnMin;

	G4TripathiLightCrossSection* tripLightCS = new G4TripathiLightCrossSection();
	G4TripathiCrossSection* tripCS = new G4TripathiCrossSection();
	G4IonsShenCrossSection* shenCS = new G4IonsShenCrossSection();
	G4IonsSihverCrossSection* sihverCS = new G4IonsSihverCrossSection();
	G4IonProtonCrossSection *ionprCS = new G4IonProtonCrossSection();

	G4DeuteronInelasticProcess* d_inel_proc = new G4DeuteronInelasticProcess();
	G4TritonInelasticProcess* t_inel_proc = new G4TritonInelasticProcess();
	G4AlphaInelasticProcess* a_inel_proc = new G4AlphaInelasticProcess();
	G4HadronInelasticProcess* he3_inel_proc = new G4HadronInelasticProcess("He3Inelastic",G4He3::He3());
	G4HadronInelasticProcess* genericIon_proc = new G4HadronInelasticProcess("ionInelastic", G4GenericIon::GenericIon());

	if (MEIonPhysics == BinCmodel)
	{
		DEnLim = 2*MELimIon;
		G4BinaryLightIonReaction* d_ion_model = new G4BinaryLightIonReaction();
		d_ion_model->SetMaxEnergy(DEnLim);
		d_inel_proc->RegisterMe(d_ion_model);

		TEnLim = 3*MELimIon;
		G4BinaryLightIonReaction* t_ion_model = new G4BinaryLightIonReaction();
		t_ion_model->SetMaxEnergy(TEnLim);
		t_inel_proc->RegisterMe(t_ion_model);

		AlphaEnLim = 4*MELimIon;
		G4BinaryLightIonReaction* a_ion_model = new G4BinaryLightIonReaction();
		a_ion_model->SetMaxEnergy(AlphaEnLim);
		a_inel_proc->RegisterMe(a_ion_model);

		He3EnLim = 3*MELimIon;
		G4BinaryLightIonReaction* he3_ion_model = new G4BinaryLightIonReaction();
		he3_ion_model->SetMaxEnergy(He3EnLim);
		he3_inel_proc->RegisterMe(he3_ion_model);

		GIEnLim = 2*MELimIon;
		G4BinaryLightIonReaction* ion_casc_model = new G4BinaryLightIonReaction();
		ion_casc_model->SetMaxEnergy(GIEnLim);
		genericIon_proc->RegisterMe(ion_casc_model);
	}
	else if (MEIonPhysics == QMDmodel)
	{
		DEnLim = TEnLim = He3EnLim = GIEnLim = MELimIon;
		QMDEnMin = 100.*MeV;

		G4QMDReaction *ion_QMD = new G4QMDReaction();
		ion_QMD->SetMaxEnergy(MELimIon);
		ion_QMD->SetMinEnergy(0.9*QMDEnMin);

		d_inel_proc->RegisterMe(ion_QMD);
		t_inel_proc->RegisterMe(ion_QMD);
		a_inel_proc->RegisterMe(ion_QMD);
		he3_inel_proc->RegisterMe(ion_QMD);
		genericIon_proc->RegisterMe(ion_QMD);

		G4BinaryLightIonReaction* casc_model = new G4BinaryLightIonReaction();
		casc_model->SetMaxEnergy(QMDEnMin);

		d_inel_proc->RegisterMe(casc_model);
		t_inel_proc->RegisterMe(casc_model);
		a_inel_proc->RegisterMe(casc_model);
		he3_inel_proc->RegisterMe(casc_model);
		genericIon_proc->RegisterMe(casc_model);

		AlphaEnLim = 4*MELimIon;
		G4BinaryLightIonReaction* a_casc_model = new G4BinaryLightIonReaction();
		a_casc_model->SetMinEnergy(0.9*MELimIon);
		a_casc_model->SetMaxEnergy(AlphaEnLim);
		a_inel_proc->RegisterMe(a_casc_model);
	}
	else
	{
		DEnLim = 2*MELimIon;
		G4InclAblaLightIonInterface* d_ion_model = new G4InclAblaLightIonInterface();
		d_ion_model->SetMaxEnergy(DEnLim);
		d_inel_proc->RegisterMe(d_ion_model);

		TEnLim = 3*MELimIon;
		G4InclAblaLightIonInterface* t_ion_model = new G4InclAblaLightIonInterface();
		t_ion_model->SetMaxEnergy(TEnLim);
		t_inel_proc->RegisterMe(t_ion_model);

		AlphaEnLim = 4*MELimIon;
		G4InclAblaLightIonInterface* a_ion_model = new G4InclAblaLightIonInterface();
		a_ion_model->SetMaxEnergy(AlphaEnLim);
		a_inel_proc->RegisterMe(a_ion_model);

		He3EnLim = 3*MELimIon;
		G4InclAblaLightIonInterface* he3_ion_model = new G4InclAblaLightIonInterface();
		he3_ion_model->SetMaxEnergy(He3EnLim);
		he3_inel_proc->RegisterMe(he3_ion_model);

		GIEnLim = 2*MELimIon;
		G4BinaryLightIonReaction* ion_casc_model = new G4BinaryLightIonReaction();
		ion_casc_model->SetMaxEnergy(GIEnLim);
		genericIon_proc->RegisterMe(ion_casc_model);
	}

	G4LEDeuteronInelastic* d_inel_model = new G4LEDeuteronInelastic();
	d_inel_model->SetMinEnergy(0.9*DEnLim);
	d_inel_model->SetMaxEnergy(1.*TeV);
	d_inel_proc->RegisterMe(d_inel_model);

	G4LETritonInelastic* t_inel_model = new G4LETritonInelastic();
	t_inel_model->SetMinEnergy(0.9*TEnLim);
	t_inel_model->SetMaxEnergy(1.*TeV);
	t_inel_proc->RegisterMe(t_inel_model);

	G4LEAlphaInelastic* a_inel_model = new G4LEAlphaInelastic;	
	a_inel_model->SetMinEnergy(0.9*AlphaEnLim);
	a_inel_model->SetMaxEnergy(1.*TeV);
	a_inel_proc->RegisterMe(a_inel_model);

	G4EMDissociation* GI_EMDmodel = new G4EMDissociation();
	GI_EMDmodel->SetMinEnergy(0.9*GIEnLim);
	genericIon_proc->RegisterMe(GI_EMDmodel);

	d_inel_proc->AddDataSet(tripLightCS);
	d_inel_proc->AddDataSet(tripCS);
	d_inel_proc->AddDataSet(shenCS);
	d_inel_proc->AddDataSet(sihverCS);

	t_inel_proc->AddDataSet(tripLightCS);
	t_inel_proc->AddDataSet(tripCS);
	t_inel_proc->AddDataSet(shenCS);
	t_inel_proc->AddDataSet(sihverCS);

	a_inel_proc->AddDataSet(tripLightCS);
	a_inel_proc->AddDataSet(tripCS);
	a_inel_proc->AddDataSet(shenCS);
	a_inel_proc->AddDataSet(sihverCS);
	a_inel_proc->AddDataSet(ionprCS);

	he3_inel_proc->AddDataSet(tripLightCS);
	he3_inel_proc->AddDataSet(tripCS);
	he3_inel_proc->AddDataSet(shenCS);
	he3_inel_proc->AddDataSet(sihverCS);
	he3_inel_proc->AddDataSet(ionprCS);

	genericIon_proc->AddDataSet(tripLightCS);
	genericIon_proc->AddDataSet(tripCS);
	genericIon_proc->AddDataSet(shenCS);
	genericIon_proc->AddDataSet(sihverCS);
	genericIon_proc->AddDataSet(ionprCS);

//Deuteron
	G4ProcessManager *pmanager = G4Deuteron::Deuteron()->GetProcessManager();
	pmanager->AddDiscreteProcess(d_inel_proc);

//Triton
	pmanager = G4Triton::Triton()->GetProcessManager();
	pmanager->AddDiscreteProcess(t_inel_proc);

// Alpha
	pmanager = G4Alpha::Alpha()->GetProcessManager();
	pmanager->AddDiscreteProcess(a_inel_proc);

//He3
	pmanager = G4He3::He3()->GetProcessManager();
	pmanager->AddDiscreteProcess(he3_inel_proc);

//Generic ion	
	pmanager = G4GenericIon::GenericIon()->GetProcessManager();
	pmanager->AddDiscreteProcess(genericIon_proc);
}

Inline Depth:
 1 1
 All All
Outline Depth:
 1 1
 2 2
 All All
Add message: (add)

1 Idea: Re: Light nuclei inelastic process - a possible bug?   (Vladimir Ivanchenko - 23 May, 2012)
1 None: Re: Light nuclei inelastic process - a possible bug?   (Aleksandr Nesterenok - 25 May, 2012)
2 Idea: Re: Light nuclei inelastic process - a possible bug?   (Lucas Norberto Burigo - 27 Sep, 2012)
1 Ok: Re: Light nuclei inelastic process - a possible bug?   (Aleksandr Nesterenok - 27 Sep, 2012)
 Add Message Add Message
to: "Light nuclei inelastic process - a possible bug?"

 Subscribe Subscribe

This site runs SLAC HyperNews version 1.11-slac-98, derived from the original HyperNews


[ Geant 4 Home | Geant 4 HyperNews | Search | Request New Forum | Feedback ]