Import Geant4 5.0.0 source tree

source/processes/transportation/src/G4ImportancePostStepDoIt.cc

@@ -21,8 +21,8 @@
 // ********************************************************************
 //
 //
-// $Id: G4ImportancePostStepDoIt.cc,v 1.5 2002/05/31 08:06:34 dressel Exp $
-// GEANT4 tag $Name: geant4-04-01 $
+// $Id: G4ImportancePostStepDoIt.cc,v 1.8 2002/11/04 10:47:56 dressel Exp $
+// GEANT4 tag $Name: geant4-05-00 $
 //
 // ----------------------------------------------------------------------
 // GEANT 4 class source file
@@ -31,20 +31,25 @@
 //
 // ----------------------------------------------------------------------
 
-#include "g4std/strstream"
-
 #include "G4ImportancePostStepDoIt.hh"
 #include "G4Track.hh"
 #include "G4ParticleChange.hh"
 #include "G4VImportanceSplitExaminer.hh"
 #include "G4Nsplit_Weight.hh"
+#include "G4VTrackTerminator.hh"
+#include "g4std/strstream"
 
-G4ImportancePostStepDoIt::G4ImportancePostStepDoIt(){}
+
+G4ImportancePostStepDoIt::
+G4ImportancePostStepDoIt(const G4VTrackTerminator &TrackTerminator)
+  :
+  fTrackTerminator(TrackTerminator)
+{}
 G4ImportancePostStepDoIt::~G4ImportancePostStepDoIt(){}
 
 void G4ImportancePostStepDoIt::DoIt(const G4Track& aTrack, 
 				    G4ParticleChange *aParticleChange,
-				    const G4Nsplit_Weight nw)
+				    const G4Nsplit_Weight &nw)
 {  
   // evaluate results from sampler
   if (nw.fN>1) {
@@ -57,14 +62,19 @@ void G4ImportancePostStepDoIt::DoIt(const G4Track& aTrack,
   }
   else if (nw.fN==0) {
     // kill track
-    aParticleChange->SetStatusChange(fStopAndKill);
+    fTrackTerminator.KillTrack();
   }
   else {
     // wrong answer
-    G4std::ostrstream os;
-    os << "G4ImportancePostStepDoIt::DoIt: sampler returned nw = " 
-       << nw << '\0' << G4endl;
-    G4Exception(os.str());
+    char st[200];
+    G4std::ostrstream os(st,200);
+    os << "G4ImportancePostStepDoIt::DoIt: sampler returned nw = "
+       << nw
+       << "\n"
+       << '\0';
+    G4String m(st);
+    
+    G4Exception(m);
   }
 }
 

source/processes/transportation/src/G4MImportanceConfigurator.cc

@@ -21,56 +21,64 @@
 // ********************************************************************
 //
 //
-// $Id: G4MassImportanceSampler.cc,v 1.1 2002/05/31 10:16:02 dressel Exp $
-// GEANT4 tag $Name: geant4-04-01 $
+// $Id: G4MImportanceConfigurator.cc,v 1.3 2002/11/04 10:47:56 dressel Exp $
+// GEANT4 tag $Name: geant4-05-00 $
 //
 // ----------------------------------------------------------------------
-// GEANT 4 class source file
-//
-// G4MassImportanceSampler.cc
+// Class G4MImportanceConfigurator
 //
+
+// Author: Michael Dressel (Michael.Dressel@cern.ch)
 // ----------------------------------------------------------------------
 
-#include "G4MassImportanceSampler.hh"
+
+#include "G4MImportanceConfigurator.hh"
+
 #include "G4MassImportanceProcess.hh"
 #include "G4ProcessPlacer.hh"
 #include "G4ImportanceAlgorithm.hh"
 
-
-G4MassImportanceSampler::
-G4MassImportanceSampler(G4VIStore &aIstore,
-			const G4String &particlename,
-			const G4VImportanceAlgorithm *algorithm)
- : fIStore(aIstore),
-   fParticleName(particlename),
-   fMassImportanceProcess(0),
-   fCreatedAlgorithm( ( ! algorithm) ),
-   fAlgorithm(( (fCreatedAlgorithm) ? 
-		new G4ImportanceAlgorithm : algorithm))
+G4MImportanceConfigurator::
+G4MImportanceConfigurator(const G4String &particlename,
+			  G4VIStore &istore,
+			  const G4VImportanceAlgorithm *ialg)
+  :
+  fPlacer(particlename),
+  fIStore(istore),
+  fDeleteIalg( ( ! ialg) ),
+  fIalgorithm(( (fDeleteIalg) ? 
+		new G4ImportanceAlgorithm : ialg)),
+  fMassImportanceProcess(0)
 {}
 
-G4MassImportanceSampler::~G4MassImportanceSampler()
-{
+G4MImportanceConfigurator::
+~G4MImportanceConfigurator(){
   if (fMassImportanceProcess) {
-    G4ProcessPlacer placer(fParticleName);
-    placer.RemoveProcess(fMassImportanceProcess);
+    fPlacer.RemoveProcess(fMassImportanceProcess);
     delete fMassImportanceProcess;
   }
-  if (fCreatedAlgorithm) delete fAlgorithm;
+  if (fDeleteIalg) {
+    delete fIalgorithm;
+  }
+}
+void  
+G4MImportanceConfigurator::Configure(G4VSamplerConfigurator *preConf){
+  const G4VTrackTerminator *terminator = 0;
+  if (preConf) {
+    terminator = preConf->GetTrackTerminator();
+  };
+
+  fMassImportanceProcess = 
+    new G4MassImportanceProcess(*fIalgorithm, 
+				fIStore, 
+				terminator);
+  if (!fMassImportanceProcess) {
+    G4Exception("ERROR: G4MImportanceConfigurator::Configure: new failed to create  G4MassImportanceProcess!");
+  }
+  fPlacer.AddProcessAsSecondDoIt(fMassImportanceProcess);
 }
 
-
-G4MassImportanceProcess *G4MassImportanceSampler::CreateMassImportanceProcess()
-{
-  if (!fMassImportanceProcess) {
-    fMassImportanceProcess =
-      new G4MassImportanceProcess(*fAlgorithm, fIStore);
-  }
+const G4VTrackTerminator *G4MImportanceConfigurator::
+GetTrackTerminator() const {
   return fMassImportanceProcess;
 }
-
-void G4MassImportanceSampler::Initialize()
-{
-  G4ProcessPlacer placer(fParticleName);
-  placer.AddProcessAsSecondDoIt(CreateMassImportanceProcess());
-}

source/processes/transportation/src/G4MScoreConfigurator.cc

@@ -21,47 +21,46 @@
 // ********************************************************************
 //
 //
-// $Id: G4MassScoreSampler.cc,v 1.1 2002/05/31 10:16:02 dressel Exp $
-// GEANT4 tag $Name: geant4-04-01 $
+// $Id: G4MScoreConfigurator.cc,v 1.4 2002/11/04 10:47:56 dressel Exp $
+// GEANT4 tag $Name: geant4-05-00 $
 //
 // ----------------------------------------------------------------------
-// GEANT 4 class source file
-//
-// G4MassScoreSampler.cc
+// Class G4MScoreConfigurator
 //
+
+// Author: Michael Dressel (Michael.Dressel@cern.ch)
 // ----------------------------------------------------------------------
 
-#include "G4MassScoreSampler.hh"
-#include "G4MScoreProcess.hh"
-#include "G4ProcessPlacer.hh"
+#include "G4MScoreConfigurator.hh"
+#include "G4VScorer.hh"
+#include "G4VTrackTerminator.hh"
 
-
-G4MassScoreSampler::G4MassScoreSampler(G4VPScorer &ascorer,
-                                       const G4String &particlename)
- : fScorer(ascorer),
-   fParticleName(particlename),
-   fMScoreProcess(0)
+G4MScoreConfigurator::
+G4MScoreConfigurator(const G4String &particlename,
+		       G4VScorer &scorer) 
+  :
+  fPlacer(particlename),
+  fScorer(scorer),
+  fMScoreProcess(0)
 {}
 
-G4MassScoreSampler::~G4MassScoreSampler()
-{
+G4MScoreConfigurator::~G4MScoreConfigurator(){
   if (fMScoreProcess) {
-    G4ProcessPlacer placer(fParticleName);
-    placer.RemoveProcess(fMScoreProcess);
+    fPlacer.RemoveProcess(fMScoreProcess);
     delete fMScoreProcess;
   }
 }
-
-G4MScoreProcess *G4MassScoreSampler::CreateMassScoreProcess()
-{
-  if (!fMScoreProcess) {
-    fMScoreProcess = new G4MScoreProcess(fScorer);
-  }
+  
+const G4VTrackTerminator *G4MScoreConfigurator::
+GetTrackTerminator() const{
   return fMScoreProcess;
 }
 
-void G4MassScoreSampler::Initialize()
+void G4MScoreConfigurator::Configure(G4VSamplerConfigurator *preConf)
 {
-  G4ProcessPlacer placer(fParticleName);
-  placer.AddProcessAsSecondDoIt(CreateMassScoreProcess());
+  fMScoreProcess = new G4MScoreProcess(fScorer);
+  if (!fMScoreProcess) {
+    G4Exception("ERROR: G4MScoreConfigurator::Configure: new failed to create G4MScoreProcess!");
+  }
+  fPlacer.AddProcessAsSecondDoIt(fMScoreProcess);
 }

source/processes/transportation/src/G4MScoreProcess.cc

@@ -21,8 +21,8 @@
 // ********************************************************************
 //
 //
-// $Id: G4MScoreProcess.cc,v 1.3 2002/04/09 17:40:15 gcosmo Exp $
-// GEANT4 tag $Name: geant4-04-01 $
+// $Id: G4MScoreProcess.cc,v 1.9 2002/11/04 10:47:56 dressel Exp $
+// GEANT4 tag $Name: geant4-05-00 $
 //
 // ----------------------------------------------------------------------
 // GEANT 4 class source file
@@ -32,16 +32,21 @@
 // ----------------------------------------------------------------------
 
 #include "G4MScoreProcess.hh"
-#include "G4VPScorer.hh"
-#include "G4PStep.hh"
+#include "G4VScorer.hh"
+#include "G4GeometryCellStep.hh"
 #include "G4VParallelStepper.hh"
 
-G4MScoreProcess::G4MScoreProcess(G4VPScorer &aScorer,
+G4MScoreProcess::G4MScoreProcess(G4VScorer &aScorer,
 				 const G4String &aName)
- : G4VProcess(aName), 
-   fScorer(aScorer)
+ : 
+  G4VProcess(aName), 
+  fScorer(aScorer),
+  fKillTrack(false)
 {
   G4VProcess::pParticleChange = new G4ParticleChange;
+  if (!G4VProcess::pParticleChange) {
+    G4Exception("ERROR:G4MScoreProcess::G4MScoreProcess new failed to create G4ParticleChange!");
+  }
 }
 
 G4MScoreProcess::~G4MScoreProcess()
@@ -68,17 +73,58 @@ G4MScoreProcess::PostStepDoIt(const G4Track& aTrack, const G4Step &aStep)
     G4StepPoint *postpoint = aStep.GetPostStepPoint();
   
 
-    G4PTouchableKey prekey(*(prepoint->GetPhysicalVolume()), 
+    G4GeometryCell prekey(*(prepoint->GetPhysicalVolume()), 
 			   prepoint->GetTouchable()->GetReplicaNumber());
-    G4PTouchableKey postkey(*(postpoint->GetPhysicalVolume()), 
+    G4GeometryCell postkey(*(postpoint->GetPhysicalVolume()), 
 			    postpoint->GetTouchable()->GetReplicaNumber());
 
-    G4PStep pstep(prekey, postkey);
-    pstep.fCrossBoundary = false;
+    G4GeometryCellStep pstep(prekey, postkey);
+    pstep.SetCrossBoundary(false);
     
-    if (prekey != postkey) pstep.fCrossBoundary = true;
-  
+    if (prekey != postkey) {
+      pstep.SetCrossBoundary(true);
+    } 
     fScorer.Score(aStep, pstep); 
   }
+
+  if (fKillTrack) {
+    fKillTrack = false;
+    pParticleChange->SetStatusChange(fStopAndKill);
+  }
+
   return G4VProcess::pParticleChange;
 }
+
+const G4String &G4MScoreProcess::GetName() const {
+  return theProcessName;
+}
+
+
+G4double G4MScoreProcess::
+AlongStepGetPhysicalInteractionLength(const G4Track&,
+				      G4double  ,
+				      G4double  ,
+				      G4double& ,
+				      G4GPILSelection*) {
+  return -1.0;
+}
+
+G4double G4MScoreProcess::
+AtRestGetPhysicalInteractionLength(const G4Track&,
+				   G4ForceCondition*) {
+  return -1.0;
+}
+
+G4VParticleChange* G4MScoreProcess::AtRestDoIt(const G4Track&,
+					       const G4Step&) {
+  return 0;
+}
+
+G4VParticleChange* G4MScoreProcess::AlongStepDoIt(const G4Track&,
+						  const G4Step&) {
+  return 0;
+}
+
+void G4MScoreProcess::KillTrack() const{
+  fKillTrack = true;
+}

source/processes/transportation/src/G4MassGCellFinder.cc

@@ -21,40 +21,39 @@
 // ********************************************************************
 //
 //
-// $Id: G4MassImportanceScoreSampler.cc,v 1.1 2002/05/31 10:16:02 dressel Exp $
-// GEANT4 tag $Name: geant4-04-01 $
+// $Id: G4MassGCellFinder.cc,v 1.1 2002/10/16 16:27:41 dressel Exp $
+// GEANT4 tag $Name: geant4-05-00 $
 //
 // ----------------------------------------------------------------------
 // GEANT 4 class source file
 //
-// G4MassImportanceScoreSampler.cc
+// G4MassGCellFinder.cc
 //
 // ----------------------------------------------------------------------
 
-#include "G4MassImportanceScoreSampler.hh"
-#include "G4MassImportanceSampler.hh"
-#include "G4MassScoreSampler.hh"
+#include "G4MassGCellFinder.hh"
+#include "G4TouchableHandle.hh"
+#include "G4Step.hh"
 
-
-G4MassImportanceScoreSampler::
-G4MassImportanceScoreSampler(G4VIStore &aIstore,
-			     G4VPScorer &ascorer,
-			     const G4String &particlename,
-			     const G4VImportanceAlgorithm *algorithm)
- : fMassImportanceSampler(new G4MassImportanceSampler(aIstore, 
-                                                      particlename,
-                                                      algorithm)),
-   fMassScoreSampler(new G4MassScoreSampler(ascorer, particlename))
+G4MassGCellFinder::G4MassGCellFinder()
 {}
 
-G4MassImportanceScoreSampler::~G4MassImportanceScoreSampler()
-{
-  delete fMassScoreSampler;
-  delete fMassImportanceSampler;
+G4MassGCellFinder::~G4MassGCellFinder()
+{}
+
+G4GeometryCell G4MassGCellFinder::
+GetPreGeometryCell(const G4Step &aStep) const {
+  const G4TouchableHandle& th =
+    aStep.GetPreStepPoint()->GetTouchableHandle();
+  G4GeometryCell g(*th->GetVolume(), th->GetReplicaNumber()); 
+  return g;
 }
 
-void G4MassImportanceScoreSampler::Initialize()
-{
-  fMassScoreSampler->Initialize();
-  fMassImportanceSampler->Initialize();
+G4GeometryCell G4MassGCellFinder::
+GetPostGeometryCell(const G4Step &aStep) const {
+  const G4TouchableHandle& th =
+    aStep.GetPostStepPoint()->GetTouchableHandle();
+  G4GeometryCell g(*th->GetVolume(), th->GetReplicaNumber());    
+  return g;
 }
+

source/processes/transportation/src/G4MassGeometrySampler.cc

@@ -0,0 +1,173 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * 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.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4MassGeometrySampler.cc,v 1.7 2002/11/04 10:47:56 dressel Exp $
+// GEANT4 tag $Name: geant4-05-00 $
+//
+// ----------------------------------------------------------------------
+// GEANT 4 class source file
+//
+// G4MassGeometrySampler.cc
+//
+// ----------------------------------------------------------------------
+
+
+
+#include "G4MassGeometrySampler.hh"
+
+#include "G4VIStore.hh"
+#include "G4VScorer.hh"
+
+#include "G4MScoreConfigurator.hh"
+#include "G4MImportanceConfigurator.hh"
+#include "G4WeightCutOffConfigurator.hh"
+#include "G4MassGCellFinder.hh"
+
+G4MassGeometrySampler::
+G4MassGeometrySampler(const G4String &particlename)
+  :
+  fParticleName(particlename),
+  fMImportanceConfigurator(0),
+  fMScoreConfigurator(0),
+  fGCellFinder(0),
+  fWeightCutOffConfigurator(0),
+  fIStore(0),
+  fIsConfigured(false)
+{}
+
+G4MassGeometrySampler::~G4MassGeometrySampler(){
+  ClearSampling();
+};
+
+void G4MassGeometrySampler::ClearSampling() {
+
+  if (fMImportanceConfigurator) {
+    delete fMImportanceConfigurator;
+    fMImportanceConfigurator = 0;
+  }
+  if (fMScoreConfigurator) {
+    delete fMScoreConfigurator;
+    fMScoreConfigurator = 0;
+  }
+  if (fWeightCutOffConfigurator) {
+    delete fWeightCutOffConfigurator;
+    fWeightCutOffConfigurator = 0;
+  }
+  if (fGCellFinder) {
+    delete fGCellFinder;
+    fGCellFinder = 0;
+  }
+  fIStore = 0;
+  fConfigurators.clear();
+  fIsConfigured = false;
+};
+
+G4bool G4MassGeometrySampler::IsConfigured() const{
+
+  G4bool isconf = false;
+  if (fIsConfigured) {
+   G4cout << "G4MassGeometrySampler::CheckIfInit some initalization exists, use  ClearSampling() before a new initialization" << G4endl;
+   isconf = true;
+  }
+  return isconf;
+}
+
+void G4MassGeometrySampler::
+PrepareScoring(G4VScorer *scorer){
+  fMScoreConfigurator = 
+    new G4MScoreConfigurator(fParticleName, *scorer);
+  if (!fMScoreConfigurator) {
+    G4Exception("ERROR:G4MassGeometrySampler::PrepareScoring: new failed to ccreate G4MScoreConfigurator!");
+  }
+}
+
+void G4MassGeometrySampler::
+PrepareImportanceSampling(G4VIStore *istore,
+			  const G4VImportanceAlgorithm 
+			  *ialg) {
+  fIStore = istore;
+
+  fMImportanceConfigurator =
+    new G4MImportanceConfigurator(fParticleName,
+				    *fIStore,
+				    ialg);
+  if (!fMImportanceConfigurator) {
+    G4Exception("ERROR:G4MassGeometrySampler::PrepareImportanceSampling: new failed to ccreate G4MImportanceConfigurator!");
+  }
+  
+}
+
+void G4MassGeometrySampler::
+PrepareWeightRoulett(G4double wsurvive, 
+		     G4double wlimit,
+		     G4double isource) {
+  fGCellFinder = new G4MassGCellFinder;
+  if (!fGCellFinder) {
+    G4Exception("ERROR:G4MassGeometrySampler::PrepareWeightRoulett: new failed to create G4MassGCellFinder!");
+  }
+  
+  fWeightCutOffConfigurator = 
+    new G4WeightCutOffConfigurator(fParticleName,
+				   wsurvive,
+				   wlimit,
+				   isource,
+				   fIStore,
+				   *fGCellFinder);
+  if (!fWeightCutOffConfigurator) {
+    G4Exception("ERROR:G4MassGeometrySampler::PrepareWeightRoulett: new failed to ccreate G4WeightCutOffConfigurator!");
+  }
+  
+
+}
+
+void G4MassGeometrySampler::Configure(){
+  if (!IsConfigured()) {
+    fIsConfigured = true;
+
+    if (fMScoreConfigurator) {
+      fConfigurators.push_back(fMScoreConfigurator);
+    }
+    if (fMImportanceConfigurator) {
+      fConfigurators.push_back(fMImportanceConfigurator);
+    }
+    
+    G4VSamplerConfigurator *preConf = 0;
+    for (G4Configurators::iterator it = fConfigurators.begin();
+	 it != fConfigurators.end(); it++) {
+      G4VSamplerConfigurator *currConf =*it;
+      currConf->Configure(preConf);
+      preConf = *it;
+    }
+    if (fWeightCutOffConfigurator) {
+      fWeightCutOffConfigurator->Configure(0);
+    }
+    
+  }
+  return;
+}
+
+
+
+
+
+

source/processes/transportation/src/G4MassImportanceProcess.cc

@@ -21,8 +21,8 @@
 // ********************************************************************
 //
 //
-// $Id: G4MassImportanceProcess.cc,v 1.3 2002/04/09 17:40:15 gcosmo Exp $
-// GEANT4 tag $Name: geant4-04-01 $
+// $Id: G4MassImportanceProcess.cc,v 1.10 2002/11/04 10:47:56 dressel Exp $
+// GEANT4 tag $Name: geant4-05-00 $
 //
 // ----------------------------------------------------------------------
 // GEANT 4 class source file
@@ -33,24 +33,28 @@
 
 #include "G4MassImportanceProcess.hh"
 #include "G4VImportanceAlgorithm.hh"
-#include "G4ImportanceFinder.hh"
-#include "G4PTouchableKey.hh"
+#include "G4GeometryCell.hh"
 
 G4MassImportanceProcess::
 G4MassImportanceProcess(const G4VImportanceAlgorithm &aImportanceAlgorithm,
 			const G4VIStore &aIstore,
+			const G4VTrackTerminator *TrackTerminator,
 			const G4String &aName)
  : G4VProcess(aName),
+   fParticleChange(new G4ParticleChange),
+   fTrackTerminator(TrackTerminator ? TrackTerminator : this),
    fImportanceAlgorithm(aImportanceAlgorithm),
-   fImportanceFinder(new G4ImportanceFinder(aIstore))
+   fImportanceFinder(aIstore),
+   fImportancePostStepDoIt(*fTrackTerminator)
 {
-  fParticleChange = new G4ParticleChange;
+  if (!fParticleChange) {
+    G4Exception("ERROR:G4MassImportanceProcess::G4MassImportanceProcess: new failed to create G4ParticleChange!");
+  }
   G4VProcess::pParticleChange = fParticleChange;
 }
 
 G4MassImportanceProcess::~G4MassImportanceProcess()
 {
-  delete fImportanceFinder;
   delete fParticleChange;
 }
 
@@ -78,16 +82,52 @@ G4MassImportanceProcess::PostStepDoIt(const G4Track &aTrack,
     G4StepPoint *postpoint = aStep.GetPostStepPoint();
   
 
-    G4PTouchableKey prekey(*(prepoint->GetPhysicalVolume()), 
+    G4GeometryCell prekey(*(prepoint->GetPhysicalVolume()), 
 			 prepoint->GetTouchable()->GetReplicaNumber());
-    G4PTouchableKey postkey(*(postpoint->GetPhysicalVolume()), 
+    G4GeometryCell postkey(*(postpoint->GetPhysicalVolume()), 
 			  postpoint->GetTouchable()->GetReplicaNumber());
 
     G4Nsplit_Weight nw = fImportanceAlgorithm.
-      Calculate(fImportanceFinder->
-		GetIPre_over_IPost(prekey, postkey),
+      Calculate(fImportanceFinder.GetImportance(prekey),
+		fImportanceFinder.GetImportance(postkey), 
 		aTrack.GetWeight());
     fImportancePostStepDoIt.DoIt(aTrack, fParticleChange, nw);
   }
   return fParticleChange;
 }
+
+void G4MassImportanceProcess::KillTrack() const {
+  fParticleChange->SetStatusChange(fStopAndKill);
+}
+
+const G4String &G4MassImportanceProcess::GetName() const {
+  return theProcessName;
+}
+
+G4double G4MassImportanceProcess::
+AlongStepGetPhysicalInteractionLength(const G4Track&,
+				      G4double  ,
+				      G4double  ,
+				      G4double& ,
+				      G4GPILSelection*) {
+  return -1.0;
+}
+
+G4double G4MassImportanceProcess::
+AtRestGetPhysicalInteractionLength(const G4Track& ,
+				   G4ForceCondition*) 
+{
+  return -1.0;
+}
+  
+G4VParticleChange* G4MassImportanceProcess::
+AtRestDoIt(const G4Track&, const G4Step&) 
+{
+  return 0;
+}
+
+G4VParticleChange* G4MassImportanceProcess::
+AlongStepDoIt(const G4Track&, const G4Step&) {
+  return 0;
+}
+

source/processes/transportation/src/G4PIScorer.cc

@@ -1,92 +0,0 @@
-//
-// ********************************************************************
-// * DISCLAIMER                                                       *
-// *                                                                  *
-// * The following disclaimer summarizes all the specific disclaimers *
-// * of contributors to this software. The specific disclaimers,which *
-// * govern, are listed with their locations in:                      *
-// *   http://cern.ch/geant4/license                                  *
-// *                                                                  *
-// * 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.                                                             *
-// *                                                                  *
-// * This  code  implementation is the  intellectual property  of the *
-// * GEANT4 collaboration.                                            *
-// * By copying,  distributing  or modifying the Program (or any work *
-// * based  on  the Program)  you indicate  your  acceptance of  this *
-// * statement, and all its terms.                                    *
-// ********************************************************************
-//
-//
-// $Id: G4PIScorer.cc,v 1.4 2002/04/09 17:40:15 gcosmo Exp $
-// GEANT4 tag $Name: geant4-04-01 $
-//
-// ----------------------------------------------------------------------
-// GEANT 4 class source file
-//
-// G4PIScorer.cc
-//
-// ----------------------------------------------------------------------
-
-#include "G4PIScorer.hh"
-#include "G4Step.hh"
-#include "G4PStep.hh"
-#include "G4Sigma.hh"
-#include "G4StateManager.hh"
-#include "G4VIStore.hh"
-#include "G4PStepStream.hh"
-#include "G4StepPoint.hh"
-
-G4PIScorer::G4PIScorer(const G4VIStore &IStore)
-  : fIStore(IStore), fNerr(0),fCorrectWeight(true)
-{}
-
-G4PIScorer::~G4PIScorer()
-{}
-
-void G4PIScorer::Score(const G4Step &aStep, const G4PStep &aPstep)
-{
-  G4Track *track = aStep.GetTrack();
-
-  if (track->GetTrackStatus()==fStopAndKill) {
-    G4cout << "      track status is StopAndKill -> do nothing" << G4endl;
-  }
-  // do the scoring
-  else {    
-    G4double weight = track->GetWeight();
-    G4double import = fIStore.GetImportance(aPstep.fPostTouchableKey);
-    G4double i_w =import  * weight;
-    if (i_w != 1.) {
-      fNerr++;
-      G4StepPoint* prepoint = aStep.GetPreStepPoint();
-      G4StepPoint* postpoint = aStep.GetPostStepPoint();
-      
-      G4cout << "G4PIScorer::Score:" << G4endl;
-      G4cout << "  Stepnumber = " << aStep.GetTrack()->GetCurrentStepNumber() 
-	     << G4endl;
-      G4cout << "  TrackID = " << aStep.GetTrack()->GetTrackID() << G4endl;
-      G4cout << "  ParentID = " << aStep.GetTrack()->GetParentID() << G4endl;
-      G4cout << "  Track wieght = " << weight << G4endl;
-      G4cout << "  Importance = " << import << G4endl;
-      G4cout << "  i_w = " << i_w << G4endl;
-      G4cout << "  aPstep: " << aPstep << G4endl;
-      G4cout << "  steplength = " << aStep.GetStepLength() << G4endl;
-      G4cout << "  pre_pos = " << prepoint->GetPosition()
-	     << ", pre_dir = " << prepoint->GetMomentumDirection() << G4endl;
-      G4cout << "  post_pos = " << postpoint->GetPosition()
-	     << ", post_dir = " << postpoint->GetMomentumDirection() << G4endl;
-      G4cout << "  vxt mom: " << track->GetVertexMomentumDirection() << G4endl;
-      fCorrectWeight = false;
-    }
-    fPScorer.Score(aStep, aPstep);
-  }
-}
-
-G4std::ostream& operator<<(G4std::ostream &out, const G4PIScorer &ps)
-{
-  out << ps.GetMapPtkTallys();
-  return out;
-}

source/processes/transportation/src/G4PImportanceConfigurator.cc

@@ -0,0 +1,94 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * 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.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4PImportanceConfigurator.cc,v 1.3 2002/11/04 10:47:56 dressel Exp $
+// GEANT4 tag $Name: geant4-05-00 $
+//
+// ----------------------------------------------------------------------
+// Class G4PImportanceConfigurator
+//
+
+// Author: Michael Dressel (Michael.Dressel@cern.ch)
+// ----------------------------------------------------------------------
+
+#include "G4PImportanceConfigurator.hh"
+
+#include "G4ParallelWorld.hh"
+#include "G4ImportanceAlgorithm.hh"
+
+G4PImportanceConfigurator::
+G4PImportanceConfigurator(const G4String &particlename,
+			  G4ParallelWorld &parallelWorld,
+			  G4VIStore &istore,
+			  const G4VImportanceAlgorithm *ialg) 
+  :
+  fPlacer(particlename),
+  fPWorld(parallelWorld),
+  fDeleteIalg( ( ! ialg) ),
+  fIalgorithm(( (fDeleteIalg) ? 
+		new G4ImportanceAlgorithm : ialg)),
+  fExaminer(*fIalgorithm, 
+	    parallelWorld.GetParallelStepper(),  
+	    istore),
+  fParallelImportanceProcess(0)
+{
+  if (!fIalgorithm) {
+    G4Exception("ERROR:G4PImportanceConfigurator::G4PImportanceConfigurator: no fIalgorithm!");
+  }
+}
+
+
+G4PImportanceConfigurator::~G4PImportanceConfigurator(){
+  if (fParallelImportanceProcess) {
+    fPlacer.RemoveProcess(fParallelImportanceProcess);
+    delete fParallelImportanceProcess;
+  }
+  if (fDeleteIalg) {
+    delete fIalgorithm;
+  }
+}
+
+void G4PImportanceConfigurator::
+Configure(G4VSamplerConfigurator *preConf){
+  const G4VTrackTerminator *terminator = 0;
+  if (preConf) {
+    terminator = preConf->GetTrackTerminator();
+  };
+
+  fParallelImportanceProcess = 
+    new G4ParallelImportanceProcess(fExaminer, 
+				    fPWorld.GetGeoDriver(), 
+				    fPWorld.GetParallelStepper(),
+				    terminator);
+  if (!fParallelImportanceProcess) {
+    G4Exception("ERROR:G4PImportanceConfigurator::Configure: new failed to create G4ParallelImportanceProcess!");
+  }
+  
+  fPlacer.AddProcessAsSecondDoIt(fParallelImportanceProcess); 
+}
+
+const G4VTrackTerminator *G4PImportanceConfigurator::
+GetTrackTerminator() const {
+  return fParallelImportanceProcess;
+}
+

source/processes/transportation/src/G4PImportanceWWindowScoreSampler.cc

@@ -1,111 +0,0 @@
-//
-// ********************************************************************
-// * DISCLAIMER                                                       *
-// *                                                                  *
-// * The following disclaimer summarizes all the specific disclaimers *
-// * of contributors to this software. The specific disclaimers,which *
-// * govern, are listed with their locations in:                      *
-// *   http://cern.ch/geant4/license                                  *
-// *                                                                  *
-// * 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.                                                             *
-// *                                                                  *
-// * This  code  implementation is the  intellectual property  of the *
-// * GEANT4 collaboration.                                            *
-// * By copying,  distributing  or modifying the Program (or any work *
-// * based  on  the Program)  you indicate  your  acceptance of  this *
-// * statement, and all its terms.                                    *
-// ********************************************************************
-//
-//
-// $Id: G4PImportanceWWindowScoreSampler.cc,v 1.1 2002/05/31 10:16:02 dressel Exp $
-// GEANT4 tag $Name: geant4-04-01 $
-//
-// ----------------------------------------------------------------------
-// GEANT 4 class source file
-//
-// G4PImportanceWWindowScoreSampler.cc
-//
-// ----------------------------------------------------------------------
-
-#include "G4ParallelWorld.hh"
-#include "G4PImportanceWWindowScoreSampler.hh"
-#include "G4ParallelImportanceSampler.hh"
-#include "G4ParallelWorld.hh"
-#include "G4ProcessPlacer.hh"
-#include "G4VIStore.hh"
-#include "G4VPScorer.hh"
-#include "G4PScoreProcess.hh"
-#include "G4ParallelWeightWindowProcess.hh"
-#include "G4WeightWindowAlgorithm.hh"
-
-G4PImportanceWWindowScoreSampler::
-G4PImportanceWWindowScoreSampler(G4VIStore &is, 
-				 G4VPScorer &ascorer,
-				 const G4String &particlename,
-				 G4VWeightWindowAlgorithm &wwalg,
-				 const G4VImportanceAlgorithm *ialg) : 
-  fParticleName(particlename),
-  fParallelWorld(*(new G4ParallelWorld(is.GetWorldVolume()))),
-  fParallelImportanceSampler(*(new 
-			       G4ParallelImportanceSampler(is,
-							   fParticleName,
-							   fParallelWorld,
-							   ialg))),
-   fPScorer(ascorer),
-   fIstore(is),
-   fPScoreProcess(0),
-   fPWeightWindowProcess(0),
-   fWWAlgorithm(wwalg)
-{}
-
-G4PImportanceWWindowScoreSampler::~G4PImportanceWWindowScoreSampler()
-{
-  if (fPScoreProcess) {
-    G4ProcessPlacer placer(fParticleName);
-    placer.RemoveProcess(fPScoreProcess);
-    delete  fPScoreProcess;
-  }
-  if (fPWeightWindowProcess) {
-    G4ProcessPlacer placer(fParticleName);
-    placer.RemoveProcess(fPWeightWindowProcess);
-    delete fPWeightWindowProcess;
-  }
-  delete &fParallelImportanceSampler;
-  delete &fParallelWorld;
-}
-
-G4PScoreProcess *
-G4PImportanceWWindowScoreSampler::CreateParallelScoreProcess()
-{
-  if (!fPScoreProcess) {
-    fPScoreProcess = 
-      new G4PScoreProcess(fParallelWorld.GetParallelStepper(), 
-			  fPScorer);
-  }
-  return fPScoreProcess;
-}
-
-G4VProcess *
-G4PImportanceWWindowScoreSampler::CreateWeightWindowProcess()
-{
-  if (!fPWeightWindowProcess) {
-    fPWeightWindowProcess = 
-      new G4ParallelWeightWindowProcess(fIstore,
-					fParallelWorld.
-					GetParallelStepper(),
-					fWWAlgorithm);
-  }
-  return fPWeightWindowProcess;
-}
-
-void G4PImportanceWWindowScoreSampler::Initialize()
-{
-  G4ProcessPlacer placer(fParticleName);
-  placer.AddProcessAsSecondDoIt(CreateParallelScoreProcess());
-  fParallelImportanceSampler.Initialize();
-  placer.AddProcessAsSecondDoIt(CreateWeightWindowProcess());
-}

source/processes/transportation/src/G4PScoreConfigurator.cc

@@ -21,66 +21,50 @@
 // ********************************************************************
 //
 //
-// $Id: G4ParallelImportanceScoreSampler.cc,v 1.1 2002/05/31 10:16:02 dressel Exp $
-// GEANT4 tag $Name: geant4-04-01 $
+// $Id: G4PScoreConfigurator.cc,v 1.4 2002/11/04 10:47:56 dressel Exp $
+// GEANT4 tag $Name: geant4-05-00 $
 //
 // ----------------------------------------------------------------------
-// GEANT 4 class source file
-//
-// G4ParallelImportanceScoreSampler.cc
+// Class G4PScoreConfigurator
 //
+
+// Author: Michael Dressel (Michael.Dressel@cern.ch)
 // ----------------------------------------------------------------------
 
-#include "G4ParallelWorld.hh"
-#include "G4ParallelImportanceScoreSampler.hh"
-#include "G4ParallelImportanceSampler.hh"
-#include "G4ParallelWorld.hh"
-#include "G4ProcessPlacer.hh"
-#include "G4VIStore.hh"
-#include "G4VPScorer.hh"
-#include "G4PScoreProcess.hh"
+#include "G4PScoreConfigurator.hh"
 
-G4ParallelImportanceScoreSampler::
-G4ParallelImportanceScoreSampler(G4VIStore &is, 
-				 G4VPScorer &ascorer,
-				 const G4String &particlename,
-				 const G4VImportanceAlgorithm *ialg) : 
-  fParticleName(particlename),
-  fParallelWorld(*(new G4ParallelWorld(is.GetWorldVolume()))),
-  fParallelImportanceSampler(*(new 
-			       G4ParallelImportanceSampler(is,
-							   fParticleName,
-							   fParallelWorld,
-							   ialg))),
-  fPScorer(ascorer),
+#include "G4VTrackTerminator.hh"
+
+
+G4PScoreConfigurator::
+G4PScoreConfigurator(const G4String &particlename,
+		       G4VParallelStepper &pstepper,
+		       G4VScorer &scorer) 
+  :
+  fPlacer(particlename),
+  fPStepper(pstepper),
+  fScorer(scorer),
   fPScoreProcess(0)
 {}
 
-G4ParallelImportanceScoreSampler::~G4ParallelImportanceScoreSampler()
-{
+G4PScoreConfigurator::~G4PScoreConfigurator(){
   if (fPScoreProcess) {
-    G4ProcessPlacer placer(fParticleName);
-    placer.RemoveProcess(fPScoreProcess);
-    delete  fPScoreProcess;
+    fPlacer.RemoveProcess(fPScoreProcess);
+    delete fPScoreProcess;
   }
-  delete &fParallelImportanceSampler;
-  delete &fParallelWorld;
+}
+ 
+void G4PScoreConfigurator::Configure(G4VSamplerConfigurator *preConf){
+  fPScoreProcess = new G4PScoreProcess(fPStepper, fScorer);
+  if (!fPScoreProcess) {
+    G4Exception("ERROR:G4PScoreConfigurator::Configure: new failed to create G4PScoreProcess!");
+  }
+  fPlacer.AddProcessAsSecondDoIt(fPScoreProcess);
 }
 
-G4PScoreProcess *
-G4ParallelImportanceScoreSampler::CreateParallelScoreProcess()
-{
-  if (!fPScoreProcess) {
-    fPScoreProcess = 
-      new G4PScoreProcess(fParallelWorld.
-			  GetParallelStepper(), fPScorer);
-  }
+
+const G4VTrackTerminator *G4PScoreConfigurator:: 
+GetTrackTerminator() const {
   return fPScoreProcess;
 }
-
-void G4ParallelImportanceScoreSampler::Initialize()
-{
-  G4ProcessPlacer placer(fParticleName);
-  placer.AddProcessAsSecondDoIt(CreateParallelScoreProcess());
-  fParallelImportanceSampler.Initialize();
-}
+  

source/processes/transportation/src/G4PScoreProcess.cc

@@ -21,29 +21,34 @@
 // ********************************************************************
 //
 //
-// $Id: G4PScoreProcess.cc,v 1.2 2002/04/09 17:40:15 gcosmo Exp $
-// GEANT4 tag $Name: geant4-04-01 $
+// $Id: G4PScoreProcess.cc,v 1.6 2002/11/04 10:47:56 dressel Exp $
+// GEANT4 tag $Name: geant4-05-00 $
 //
 // ----------------------------------------------------------------------
 // GEANT 4 class source file
 //
-// G4PIScoreProcess.cc
+// G4PScoreProcess.cc
 //
 // ----------------------------------------------------------------------
 
 #include "G4PScoreProcess.hh"
-#include "G4VPScorer.hh"
-#include "G4PStep.hh"
+#include "G4VScorer.hh"
+#include "G4GeometryCellStep.hh"
 #include "G4VParallelStepper.hh"
 
 G4PScoreProcess::G4PScoreProcess(G4VParallelStepper &astepper,
-				 G4VPScorer &aScorer,
+				 G4VScorer &aScorer,
 				 const G4String &aName)
- : G4VProcess(aName), 
-   fPstepper(astepper),
-   fScorer(aScorer)
+ : 
+  G4VProcess(aName), 
+  fPstepper(astepper),
+  fScorer(aScorer),
+  fKillTrack(false)
 {
   G4VProcess::pParticleChange = new G4ParticleChange;
+  if (!G4VProcess::pParticleChange) {
+    G4Exception("ERROR:G4PScoreProcess::G4PScoreProcess: new failed to create G4ParticleChange!");
+  }
 }
 
 G4PScoreProcess::~G4PScoreProcess()
@@ -65,6 +70,44 @@ G4PScoreProcess::PostStepDoIt(const G4Track& aTrack, const G4Step &aStep)
 {
   pParticleChange->Initialize(aTrack);
   fScorer.Score(aStep, fPstepper.GetPStep()); 
-  
+  if (fKillTrack) {
+    fKillTrack = false;
+    pParticleChange->SetStatusChange(fStopAndKill);
+  }
   return G4VProcess::pParticleChange;
 }
+
+void G4PScoreProcess::KillTrack() const {
+  fKillTrack = true;
+}
+
+const G4String &G4PScoreProcess::GetName() const {
+  return theProcessName;
+}
+
+
+
+G4double G4PScoreProcess::
+AlongStepGetPhysicalInteractionLength(const G4Track&,
+				      G4double  ,
+				      G4double  ,
+				      G4double& ,
+				      G4GPILSelection*) {
+  return -1.0;
+}
+
+G4double G4PScoreProcess::
+AtRestGetPhysicalInteractionLength(const G4Track& ,
+				   G4ForceCondition*) {
+  return -1.0;
+}
+
+G4VParticleChange* G4PScoreProcess::
+AtRestDoIt(const G4Track&, const G4Step&) {
+  return 0;
+}
+
+G4VParticleChange* G4PScoreProcess::
+AlongStepDoIt(const G4Track&, const G4Step&) {
+  return 0;
+}

source/processes/transportation/src/G4ParallelGCellFinder.cc

@@ -21,57 +21,36 @@
 // ********************************************************************
 //
 //
-// $Id: G4PScorer.cc,v 1.7 2002/04/09 17:40:15 gcosmo Exp $
-// GEANT4 tag $Name: geant4-04-01 $
+// $Id: G4ParallelGCellFinder.cc,v 1.1 2002/10/16 16:27:41 dressel Exp $
+// GEANT4 tag $Name: geant4-05-00 $
 //
 // ----------------------------------------------------------------------
 // GEANT 4 class source file
 //
-// G4PScorer.cc
+// G4ParallelGCellFinder.cc
 //
 // ----------------------------------------------------------------------
 
-#include "G4PScorer.hh"
-#include "G4Step.hh"
-#include "G4PStep.hh"
-#include "G4Sigma.hh"
-#include "G4StateManager.hh"
+#include "G4ParallelGCellFinder.hh"
+#include "G4VParallelStepper.hh"
 
-G4PScorer::G4PScorer(){}
-G4PScorer::~G4PScorer(){}
 
-void G4PScorer::Score(const G4Step &aStep, const G4PStep &aPstep)
-{
-  G4Track *track = aStep.GetTrack();
+G4ParallelGCellFinder::
+G4ParallelGCellFinder(const G4VParallelStepper &astepper):
+  fPStepper(astepper)
+{}
 
-  if (track->GetTrackStatus()==fStopAndKill) {
-    G4cout << "      track status is StopAndKill -> do nothing" << G4endl;
-  }
-  // do the scoring
-  else {    
-    G4double weight = track->GetWeight();
-    // the map fPtkTallys, the map nametallys and the "G4Sigma" will
-    // be setup the first time they are accesed. 
-    G4PTouchableKey post_ptk(aPstep.fPostTouchableKey); 
-    if (aPstep.fCrossBoundary) { 
-      // Pstep crosses boundary
-      fPtkTallys[post_ptk]["WeighteOfHistorysEntering"].Xin(weight);
-      fPtkTallys[post_ptk]["HistorysEnteringWeighted"].Xin(1,weight);
-      fPtkTallys[post_ptk]["EnergyEnteringHistoryWeighted"].
-	Xin(track->GetKineticEnergy(), weight);
-    } 
-    else { 
-      // Pstep with both points in the same I volume
-      if (aStep.GetPostStepPoint()->GetStepStatus() != fGeomBoundary) {
-	fPtkTallys[post_ptk]["WeighteOfCollisions"].Xin(weight);
-	fPtkTallys[post_ptk]["CollisionsWeighted"].Xin(1,weight);
-      }
-    }
-  }
+G4ParallelGCellFinder::~G4ParallelGCellFinder()
+{}
+
+G4GeometryCell G4ParallelGCellFinder::
+GetPreGeometryCell(const G4Step &aStep) const {
+  G4GeometryCell g(fPStepper.GetPStep().GetPreGeometryCell());
+  return g;
 }
 
-G4std::ostream& operator<<(G4std::ostream &out, const G4PScorer &ps)
-{
-  out << ps.GetMapPtkTallys();
-  return out;
+G4GeometryCell G4ParallelGCellFinder::
+GetPostGeometryCell(const G4Step &aStep) const {
+  G4GeometryCell g(fPStepper.GetPStep().GetPostGeometryCell());
+  return g;
 }

source/processes/transportation/src/G4ParallelGeometrySampler.cc

@@ -0,0 +1,186 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * 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.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4ParallelGeometrySampler.cc,v 1.6 2002/11/04 10:47:56 dressel Exp $
+// GEANT4 tag $Name: geant4-05-00 $
+//
+// ----------------------------------------------------------------------
+// GEANT 4 class source file
+//
+// G4ParallelGeometrySampler.cc
+//
+// ----------------------------------------------------------------------
+
+
+#include "G4ParallelGeometrySampler.hh"
+
+#include "G4VIStore.hh"
+#include "G4VScorer.hh"
+
+#include "G4ParallelTransportConfigurator.hh"
+#include "G4PScoreConfigurator.hh"
+#include "G4PImportanceConfigurator.hh"
+#include "G4WeightCutOffConfigurator.hh"
+#include "G4ParallelGCellFinder.hh"
+
+G4ParallelGeometrySampler::
+G4ParallelGeometrySampler(G4VPhysicalVolume &worldvolume,
+			  const G4String &particlename)
+  :
+  fParticleName(particlename),
+  fParallelWorld(worldvolume),
+  fParallelTransportConfigurator(0),
+  fPImportanceConfigurator(0),
+  fPScoreConfigurator(0),
+  fGCellFinder(0),
+  fWeightCutOffConfigurator(0),
+  fIStore(0),
+  fIsConfigured(false)
+{}
+
+G4ParallelGeometrySampler::~G4ParallelGeometrySampler(){
+  ClearSampling();
+};
+
+void G4ParallelGeometrySampler::ClearSampling() {
+  if (fParallelTransportConfigurator) {
+    delete fParallelTransportConfigurator;
+    fParallelTransportConfigurator = 0;
+  }
+  if (fPImportanceConfigurator) {
+    delete fPImportanceConfigurator;
+    fPImportanceConfigurator = 0;
+  }
+  if (fPScoreConfigurator) {
+    delete fPScoreConfigurator;
+    fPScoreConfigurator = 0;
+  }
+  if (fWeightCutOffConfigurator) {
+    delete fWeightCutOffConfigurator;
+    fWeightCutOffConfigurator = 0;
+  }
+  if (fGCellFinder) {
+    delete fGCellFinder;
+    fGCellFinder = 0;
+  }
+  fIStore = 0;
+  fConfigurators.clear();
+  fIsConfigured = false;
+};
+
+G4bool G4ParallelGeometrySampler::IsConfigured() const{
+  G4bool isconf = false;
+  if (fIsConfigured) {
+    G4cout << "G4ParallelGeometrySampler::CheckIfInit some initalization exists, use  ClearSampling() before a new initialization" << G4endl;
+    isconf =  true;
+  }
+  return isconf;
+}
+
+void G4ParallelGeometrySampler::
+PrepareImportanceSampling(G4VIStore *istore,
+			  const G4VImportanceAlgorithm 
+			  *ialg) {
+  fIStore = istore;
+  fPImportanceConfigurator = 
+    new G4PImportanceConfigurator(fParticleName,
+				  fParallelWorld,
+				  *istore,
+				  ialg);
+  if (!fPImportanceConfigurator) {
+    G4Exception("ERROR:G4ParallelGeometrySampler::PrepareImportanceSampling: new failed to create G4PImportanceConfigurator!");
+  }
+}
+
+void G4ParallelGeometrySampler::PrepareScoring(G4VScorer *scorer){
+  fPScoreConfigurator = 
+    new G4PScoreConfigurator(fParticleName,
+			     fParallelWorld.
+			     GetParallelStepper(), 
+			     *scorer);
+  if (!fPScoreConfigurator) {
+    G4Exception("ERROR:G4ParallelGeometrySampler::PrepareScoring: new failed to create G4PScoreConfigurator!");
+  }
+  
+}
+
+void G4ParallelGeometrySampler::
+PrepareWeightRoulett(G4double wsuvive, G4double wlimit, G4double isource){
+  fGCellFinder = new G4ParallelGCellFinder(fParallelWorld.
+					   GetParallelStepper());
+  if (!fGCellFinder) {
+    G4Exception("ERROR:G4ParallelGeometrySampler::PrepareWeightRoulett: new failed to create G4ParallelGCellFinder!");
+  }
+
+  fWeightCutOffConfigurator = 
+    new G4WeightCutOffConfigurator(fParticleName,
+				   wsuvive,
+				   wlimit,
+				   isource,
+				   fIStore,
+				   *fGCellFinder);
+  if (!fWeightCutOffConfigurator) {
+    G4Exception("ERROR:G4ParallelGeometrySampler::PrepareWeightRoulett: new failed to create G4WeightCutOffConfigurator!");
+  }
+  
+}
+
+void G4ParallelGeometrySampler::Configure(){
+
+  if (!IsConfigured()) {
+    fIsConfigured = true;
+
+    if (fPScoreConfigurator) {
+      fConfigurators.push_back(fPScoreConfigurator);
+    }
+    if (fPImportanceConfigurator) {
+      fConfigurators.push_back(fPImportanceConfigurator);
+    }
+    else {
+      fParallelTransportConfigurator = 
+	new G4ParallelTransportConfigurator(fParticleName,
+					    fParallelWorld);
+      if (!fParallelTransportConfigurator) {
+	G4Exception("ERROR:G4ParallelGeometrySampler::Configure: new failed to create G4ParallelTransportConfigurator!");
+      }
+      fConfigurators.push_back(fParallelTransportConfigurator);
+    }
+    G4VSamplerConfigurator *preConf = 0;
+    for (G4Configurators::iterator it = fConfigurators.begin();
+	 it != fConfigurators.end(); it++) {
+      G4VSamplerConfigurator *currConf =*it;
+      currConf->Configure(preConf);
+      preConf = *it;
+    }
+    
+    if (fWeightCutOffConfigurator) {
+      fWeightCutOffConfigurator->Configure(0);
+    }
+  }
+  return;
+}
+
+
+
+
+

source/processes/transportation/src/G4ParallelImportanceProcess.cc

@@ -21,8 +21,8 @@
 // ********************************************************************
 //
 //
-// $Id: G4ParallelImportanceProcess.cc,v 1.3 2002/05/31 08:06:34 dressel Exp $
-// GEANT4 tag $Name: geant4-04-01 $
+// $Id: G4ParallelImportanceProcess.cc,v 1.8 2002/11/04 10:47:56 dressel Exp $
+// GEANT4 tag $Name: geant4-05-00 $
 //
 // ----------------------------------------------------------------------
 // GEANT 4 class source file
@@ -34,15 +34,23 @@
 #include "G4ParallelImportanceProcess.hh"
 #include "G4VImportanceSplitExaminer.hh"
 #include "g4std/strstream"
+#include "G4VTrackTerminator.hh"
 
 G4ParallelImportanceProcess::
 G4ParallelImportanceProcess(const G4VImportanceSplitExaminer &aImportanceSplitExaminer,
-		    G4VPGeoDriver &pgeodriver,
-		    G4VParallelStepper &aStepper, 
-		    const G4String &aName)
- : G4ParallelTransport(pgeodriver, aStepper, aName),
-   fParticleChange(G4ParallelTransport::fParticleChange),
-   fImportanceSplitExaminer(aImportanceSplitExaminer)
+			    G4VPGeoDriver &pgeodriver,
+			    G4VParallelStepper &aStepper, 
+			    const G4VTrackTerminator *TrackTerminator,
+			    const G4String &aName)
+ : 
+  G4ParallelTransport(pgeodriver, aStepper, aName),
+  fTrackTerminator(TrackTerminator ? TrackTerminator : this),
+  fParticleChange(G4ParallelTransport::fParticleChange),
+  fImportanceSplitExaminer(aImportanceSplitExaminer),
+  fImportancePostStepDoIt(*fTrackTerminator)
+{}
+
+G4ParallelImportanceProcess::~G4ParallelImportanceProcess()
 {}
 
 
@@ -66,3 +74,14 @@ void G4ParallelImportanceProcess::Error(const G4String &m)
   G4cout << "ERROR - G4ImportanceProcess::" << m << G4endl;
   G4Exception("Program aborted.");
 }
+
+
+
+void G4ParallelImportanceProcess::KillTrack() const{
+  fParticleChange->SetStatusChange(fStopAndKill);
+}
+
+
+const G4String &G4ParallelImportanceProcess::GetName() const {
+  return G4ParallelTransport::GetProcessName();
+}

source/processes/transportation/src/G4ParallelImportanceSampler.cc

@@ -1,110 +0,0 @@
-//
-// ********************************************************************
-// * DISCLAIMER                                                       *
-// *                                                                  *
-// * The following disclaimer summarizes all the specific disclaimers *
-// * of contributors to this software. The specific disclaimers,which *
-// * govern, are listed with their locations in:                      *
-// *   http://cern.ch/geant4/license                                  *
-// *                                                                  *
-// * 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.                                                             *
-// *                                                                  *
-// * This  code  implementation is the  intellectual property  of the *
-// * GEANT4 collaboration.                                            *
-// * By copying,  distributing  or modifying the Program (or any work *
-// * based  on  the Program)  you indicate  your  acceptance of  this *
-// * statement, and all its terms.                                    *
-// ********************************************************************
-//
-//
-// $Id: G4ParallelImportanceSampler.cc,v 1.1 2002/05/31 10:16:02 dressel Exp $
-// GEANT4 tag $Name: geant4-04-01 $
-//
-// ----------------------------------------------------------------------
-// GEANT 4 class source file
-//
-// G4ParallelImportanceSampler.cc
-//
-// ----------------------------------------------------------------------
-
-#include "G4ParallelImportanceSampler.hh"
-#include "G4ParallelWorld.hh"
-#include "G4ParallelWorld.hh"
-#include "G4IStore.hh"
-#include "G4ImportanceSplitExaminer.hh"
-#include "G4ParallelImportanceProcess.hh"
-#include "G4ProcessPlacer.hh"
-#include "G4ImportanceAlgorithm.hh"
-
-G4ParallelImportanceSampler::
-G4ParallelImportanceSampler(G4VIStore &is,
-			    const G4String &particlename,
-			    const G4VImportanceAlgorithm *ialg)
-  :fParticleName(particlename), 
-  fParallelWorld(*(new G4ParallelWorld(is.GetWorldVolume()))),
-  fCreatedPW(true),
-  fDeleteAlg( ( ! ialg) ),
-  fIalgorithm(( (fDeleteAlg) ? 
-		new G4ImportanceAlgorithm : ialg)),
-  fExaminer(new G4ImportanceSplitExaminer(*fIalgorithm, 
-					  fParallelWorld.
-					  GetParallelStepper(),  
-					  is)),
-   fParallelImportanceProcess(0)
-{}
-
-G4ParallelImportanceSampler::
-G4ParallelImportanceSampler(G4VIStore &is,
-			    const G4String &pname,
-			    G4ParallelWorld &pworld,
-			    const G4VImportanceAlgorithm *ialg) : 
-  fParticleName(pname), 
-  fParallelWorld(pworld),
-  fCreatedPW(false),
-  fDeleteAlg( ( ! ialg) ),
-  fIalgorithm(( (fDeleteAlg) ? 
-		new G4ImportanceAlgorithm : ialg)),
-  fExaminer(new G4ImportanceSplitExaminer(*fIalgorithm, 
-					  fParallelWorld.
-					  GetParallelStepper(),  
-					  is)),
-   fParallelImportanceProcess(0)
-{}
-  
-  
-  
-G4ParallelImportanceProcess *
-G4ParallelImportanceSampler::CreateParallelImportanceProcess()
-{
-  if (!fParallelImportanceProcess) {
-    fParallelImportanceProcess = 
-      new G4ParallelImportanceProcess(*fExaminer, 
-				      fParallelWorld.
-				      GetGeoDriver(), 
-				      fParallelWorld.
-				      GetParallelStepper());
-  }
-  return fParallelImportanceProcess;
-}
-
-void G4ParallelImportanceSampler::Initialize()
-{
-  G4ProcessPlacer placer(fParticleName);
-  placer.AddProcessAsSecondDoIt(CreateParallelImportanceProcess());
-}
-
-G4ParallelImportanceSampler::~G4ParallelImportanceSampler()
-{
-  if (fParallelImportanceProcess) {
-    G4ProcessPlacer placer(fParticleName);
-    placer.RemoveProcess(fParallelImportanceProcess);
-    delete fParallelImportanceProcess;
-  }
-  if (fCreatedPW) delete &fParallelWorld;
-  if (fDeleteAlg) delete fIalgorithm;
-  delete fExaminer;
-}

source/processes/transportation/src/G4ParallelTransport.cc

@@ -21,8 +21,8 @@
 // ********************************************************************
 //
 //
-// $Id: G4ParallelTransport.cc,v 1.4 2002/05/31 13:49:47 dressel Exp $
-// GEANT4 tag $Name: geant4-04-01 $
+// $Id: G4ParallelTransport.cc,v 1.8 2002/11/04 10:47:56 dressel Exp $
+// GEANT4 tag $Name: geant4-05-00 $
 //
 // ----------------------------------------------------------------------
 // GEANT 4 class source file
@@ -34,18 +34,24 @@
 #include "G4ParallelTransport.hh"
 #include "G4VPGeoDriver.hh"
 #include "G4VParallelStepper.hh"
-#include "G4Pstring.hh"
+#include "g4std/strstream"
+
 
 G4ParallelTransport::G4ParallelTransport(G4VPGeoDriver &pgeodriver,
 					 G4VParallelStepper &aStepper,
 					 const G4String &aName)
- : G4VProcess(aName), 
-   fPgeodriver(pgeodriver),
-   fPStepper(aStepper),
+ : 
+  G4VProcess(aName), 
+  fParticleChange(new G4ParticleChange),
+  fPgeodriver(pgeodriver),
+  fPStepper(aStepper),
   fCrossBoundary(false),
   fInitStep(false)
 {
-  fParticleChange = new G4ParticleChange;
+  if (!fParticleChange) {
+    G4Exception("ERROR:G4ParallelTransport::G4ParallelTransport: new failed to create G4ParticleChange!");
+  }
+
   G4VProcess::pParticleChange = fParticleChange;
 }
 
@@ -66,7 +72,7 @@ PostStepGetPhysicalInteractionLength(const G4Track& aTrack,
 				     G4double   previousStepSize,
 				     G4ForceCondition* condition)
 {
-  G4double stepLength;
+  G4double stepLength = 0;
 
   // if this function is called on a new track let the navigator 
   // know about it
@@ -77,7 +83,7 @@ PostStepGetPhysicalInteractionLength(const G4Track& aTrack,
     stepLength = fPgeodriver.
       ComputeStepLengthInit(aTrack.GetPosition(),
 			    aTrack.GetMomentumDirection());
-    fPStepper.Init(fPgeodriver.GetCurrentTouchableKey());
+    fPStepper.Init(fPgeodriver.GetCurrentGeometryCell());
     fCrossBoundary = false;
   }
   else if (fCrossBoundary) {
@@ -101,10 +107,15 @@ G4VParticleChange *
 G4ParallelTransport::PostStepDoIt(const G4Track& aTrack,
 				  const G4Step& aStep)
 {
-  if (aStep.GetStepLength() == 0.) {
-    G4String m = "G4PArallelTransport::PostStepDoIt: StepLength() == 0.\n";
-    m += "pos: " + str(aTrack.GetPosition()) + ", " 
-      + "dir: " +  str(aTrack.GetMomentumDirection()) + "\n";
+  if (!(aStep.GetStepLength() > 0.)) {
+    char st[1000];
+    G4std::ostrstream os(st,1000);
+    os << "G4PArallelTransport::InitPostDoIt: StepLength() == 0.\n"
+       << "pos: " << aTrack.GetPosition() << ", " 
+       << "dir: " << aTrack.GetMomentumDirection() << "\n"
+       << '\0';
+    G4String m(st);
+
     Warning(m);
   }
 
@@ -113,7 +124,7 @@ G4ParallelTransport::PostStepDoIt(const G4Track& aTrack,
   fCrossBoundary = true;
   fPgeodriver.LocateOnBoundary(aTrack.GetPosition(), 
 			       aTrack.GetMomentumDirection());
-  fPStepper.Update(fPgeodriver.GetCurrentTouchableKey());
+  fPStepper.Update(fPgeodriver.GetCurrentGeometryCell());
 
   return fParticleChange;
 }
@@ -129,3 +140,30 @@ void G4ParallelTransport::Warning(const G4String &m)
   G4cout << "WARNING - G4ParallelTransport: " << G4endl;
   G4cout << m << G4endl;
 }
+
+G4double G4ParallelTransport::
+AlongStepGetPhysicalInteractionLength(const G4Track&,
+				      G4double  ,
+				      G4double  ,
+				      G4double& ,
+				      G4GPILSelection*) {
+  return -1.0;
+}
+
+G4double G4ParallelTransport::
+AtRestGetPhysicalInteractionLength(const G4Track& ,
+				   G4ForceCondition*) {
+  return -1.0;
+}
+  
+G4VParticleChange*  G4ParallelTransport::
+AtRestDoIt(const G4Track&, const G4Step&) {
+  return 0;
+}
+  
+G4VParticleChange* G4ParallelTransport::
+AlongStepDoIt(const G4Track&, const G4Step&) {
+  return 0;
+}
+  
+ 

source/processes/transportation/src/G4ParallelTransportConfigurator.cc

@@ -21,68 +21,48 @@
 // ********************************************************************
 //
 //
-// $Id: G4ParallelScoreSampler.cc,v 1.2 2002/05/31 13:49:46 dressel Exp $
-// GEANT4 tag $Name: geant4-04-01 $
+// $Id: G4ParallelTransportConfigurator.cc,v 1.3 2002/11/04 10:47:56 dressel Exp $
+// GEANT4 tag $Name: geant4-05-00 $
 //
 // ----------------------------------------------------------------------
-// GEANT 4 class source file
-//
-// G4ParallelScoreSampler.cc
+// Class G4ParallelTransportConfigurator
 //
+
+// Author: Michael Dressel (Michael.Dressel@cern.ch)
 // ----------------------------------------------------------------------
 
-#include "G4ParallelScoreSampler.hh"
-#include "G4PScoreProcess.hh"
-#include "G4ProcessPlacer.hh"
+#include "G4ParallelTransportConfigurator.hh"
 #include "G4ParallelWorld.hh"
-#include "G4ParallelTransport.hh"
 
-G4ParallelScoreSampler::
-G4ParallelScoreSampler(G4VPhysicalVolume &worldvolume,
-		       const G4String &particlename,
-		       G4VPScorer &scorer) : 
-  fParticleName(particlename),
-  fParallelWorld(*(new G4ParallelWorld(worldvolume))),
-  fPScorer(scorer),
-  fPScorerProcess(0),
+G4ParallelTransportConfigurator::
+G4ParallelTransportConfigurator(const G4String &particlename,
+			   G4ParallelWorld &pworld)
+  :
+  fPlacer(particlename),
+  fPWorld(pworld),
   fParallelTransport(0)
 {}
 
-G4ParallelScoreSampler::~G4ParallelScoreSampler()
-{
-  if (fPScorerProcess) {
-    G4ProcessPlacer placer(fParticleName);
-    placer.RemoveProcess(fPScorerProcess);
-    delete  fPScorerProcess;
+G4ParallelTransportConfigurator::
+~G4ParallelTransportConfigurator(){
+  if (fParallelTransport) {
+    fPlacer.RemoveProcess(fParallelTransport);
+    delete fParallelTransport;
   }
-  delete &fParallelWorld;
 }
 
-
-G4PScoreProcess *G4ParallelScoreSampler::CreateParallelScoreProcess()
-{
-  if (!fPScorerProcess) {
-    fPScorerProcess = 
-      new G4PScoreProcess(fParallelWorld.GetParallelStepper(), 
-			  fPScorer);
-  }
-  return fPScorerProcess;
-}
-
-G4ParallelTransport *G4ParallelScoreSampler::CreateParallelTransport()
-{
+void G4ParallelTransportConfigurator::
+Configure(G4VSamplerConfigurator *preConf){
+  fParallelTransport = new 
+    G4ParallelTransport(fPWorld.GetGeoDriver(), 
+			fPWorld.GetParallelStepper());
   if (!fParallelTransport) {
-    fParallelTransport = new G4ParallelTransport(fParallelWorld.
-						 GetGeoDriver(), 
-						 fParallelWorld.
-						 GetParallelStepper());
+    G4Exception("ERROR:G4ParallelTransportConfigurator::Configure new failed to create G4ParallelTransport!");
   }
-  return fParallelTransport;
+  fPlacer.AddProcessAsSecondDoIt(fParallelTransport);
 }
 
-void G4ParallelScoreSampler::Initialize()
-{
-  G4ProcessPlacer placer(fParticleName);
-  placer.AddProcessAsSecondDoIt(CreateParallelScoreProcess());
-  placer.AddProcessAsSecondDoIt(CreateParallelTransport());
+const G4VTrackTerminator *G4ParallelTransportConfigurator::
+GetTrackTerminator() const {
+  return 0;
 }

source/processes/transportation/src/G4ParallelWeightWindowProcess.cc

@@ -1,113 +0,0 @@
-//
-// ********************************************************************
-// * DISCLAIMER                                                       *
-// *                                                                  *
-// * The following disclaimer summarizes all the specific disclaimers *
-// * of contributors to this software. The specific disclaimers,which *
-// * govern, are listed with their locations in:                      *
-// *   http://cern.ch/geant4/license                                  *
-// *                                                                  *
-// * 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.                                                             *
-// *                                                                  *
-// * This  code  implementation is the  intellectual property  of the *
-// * GEANT4 collaboration.                                            *
-// * By copying,  distributing  or modifying the Program (or any work *
-// * based  on  the Program)  you indicate  your  acceptance of  this *
-// * statement, and all its terms.                                    *
-// ********************************************************************
-//
-//
-// $Id: G4ParallelWeightWindowProcess.cc,v 1.3 2002/05/31 14:50:38 dressel Exp $
-// GEANT4 tag $Name: geant4-04-01 $
-//
-// ----------------------------------------------------------------------
-// GEANT 4 class source file
-//
-// G4ParallelWeightWindowProcess.cc
-//
-// ----------------------------------------------------------------------
-
-#include "G4ParallelWeightWindowProcess.hh"
-#include "G4VIStore.hh"
-#include "G4VParallelStepper.hh"
-#include "G4VWeightWindowAlgorithm.hh"
-
-#include "G4Pstring.hh"
-
-G4ParallelWeightWindowProcess::G4ParallelWeightWindowProcess(G4VIStore &aIstore,
-					       G4VParallelStepper &aStepper,
-					       G4VWeightWindowAlgorithm &aWWAlgorithm,
-					       const G4String &aName)
-  : G4VProcess(aName), 
-  fIStore(aIstore),
-  fPStepper(aStepper),
-  fWWAlgorithm(aWWAlgorithm),
-  fNsplit_Weight(G4Nsplit_Weight(0,0)),
-  fInitStep(false)
-{
-  fParticleChange = new G4ParticleChange;
-  G4VProcess::pParticleChange = fParticleChange;
-}
-
-G4ParallelWeightWindowProcess::~G4ParallelWeightWindowProcess()
-{
-  delete fParticleChange;
-}
-
-void G4ParallelWeightWindowProcess::StartTracking(){
-  fInitStep = true;
-}
-void G4ParallelWeightWindowProcess::EndTracking(){}
-
-G4double 
-G4ParallelWeightWindowProcess::
-PostStepGetPhysicalInteractionLength(const G4Track& aTrack,
-				     G4double   previousStepSize,
-				     G4ForceCondition* condition)
-{
-  *condition = NotForced;
-  G4double stepLength = kInfinity;
-
-  if (aTrack.GetCurrentStepNumber() == 1
-      && aTrack.GetTrackStatus() != fStopAndKill) {
-    fInitStep = false;
-    G4double importance = fIStore.GetImportance(fPStepper.GetPStep().fPostTouchableKey);
-    G4double weight = aTrack.GetWeight();
-    
-    fNsplit_Weight = fWWAlgorithm.Calculate(weight, importance);
-    
-    if (aTrack.GetWeight() != fNsplit_Weight.fW || 
-	fNsplit_Weight.fN != 1) {
-      stepLength = 0.;
-    }
-  }
-  
-  return stepLength;
-}
-
-G4VParticleChange * 
-G4ParallelWeightWindowProcess::PostStepDoIt(const G4Track& aTrack,
-				  const G4Step& aStep)
-{
-  fParticleChange->Initialize(aTrack);
-
-  fImportancePostStepDoIt.DoIt(aTrack, fParticleChange, fNsplit_Weight);
-  
-  return fParticleChange;
-}
-    
-void G4ParallelWeightWindowProcess::Error(const G4String &m)
-{
-  G4cout << "ERROR - G4ParallelWeightWindowProcess::" << m << G4endl;
-  G4Exception("Program aborted.");
-}
-
-void G4ParallelWeightWindowProcess::Warning(const G4String &m)
-{
-  G4cout << "WARNING - G4ParallelWeightWindowProcess: " << G4endl;
-  G4cout << m << G4endl;
-}

source/processes/transportation/src/G4ProcessPlacer.cc

@@ -21,8 +21,8 @@
 // ********************************************************************
 //
 //
-// $Id: G4ProcessPlacer.cc,v 1.6 2002/05/31 10:16:02 dressel Exp $
-// GEANT4 tag $Name: geant4-04-01 $
+// $Id: G4ProcessPlacer.cc,v 1.11 2002/11/04 10:47:56 dressel Exp $
+// GEANT4 tag $Name: geant4-05-00 $
 //
 // ----------------------------------------------------------------------
 // GEANT 4 class source file
@@ -37,28 +37,30 @@
 #include "G4ParticleTable.hh"
 
 G4ProcessPlacer::G4ProcessPlacer(const G4String &particlename)
- : G4VProcessPlacer(particlename),
-   fParticleName(particlename)
-{
-   G4cout << "+++ G4ProcessPlacer::G4ProcessPlacer: for: " <<  particlename 
-	  << G4endl;
-}
+ : fParticleName(particlename)
+{}
+
+G4ProcessPlacer::~G4ProcessPlacer()
+{}
 
 void G4ProcessPlacer::RemoveProcess(G4VProcess *process){
+  G4cout << "=== G4ProcessPlacer::RemoveProcess: for: " <<  fParticleName 
+	 << G4endl;
   G4cout << "  ProcessName: " << process->GetProcessName() 
 	 << ", will be removed!" << G4endl;
 
-  G4cout << "The initial Vectors: " << G4endl;
+  G4cout << "  The initial Vectors: " << G4endl;
   PrintPostStepGPILVec();
   PrintPostStepDoItVec();
 
-  GetProcessManager().RemoveProcess(process);
+  GetProcessManager()->RemoveProcess(process);
 
-  G4cout << "The final Vectors: " << G4endl;
+  G4cout << "  The final Vectors: " << G4endl;
   PrintPostStepGPILVec();
   PrintPostStepDoItVec();
+
+  G4cout << "================================================" << G4endl;
   
-
 }
 
 void G4ProcessPlacer::AddProcessAs(G4VProcess *process, SecondOrLast sol)
@@ -71,7 +73,7 @@ void G4ProcessPlacer::AddProcessAs(G4VProcess *process, SecondOrLast sol)
 
 
   if (sol == eLast) {  
-    GetProcessManager().AddProcess(process,
+    GetProcessManager()->AddProcess(process,
 				   ordInActive,
 				   ordInActive,
 				   ordLast);
@@ -79,7 +81,7 @@ void G4ProcessPlacer::AddProcessAs(G4VProcess *process, SecondOrLast sol)
   else if (sol == eSecond) {
     // get transportation process
     G4VProcess *transportation = 
-     (* (GetProcessManager().GetProcessList()))[0];
+     (* (GetProcessManager()->GetProcessList()))[0];
 
     if (!transportation) {
       G4Exception(" G4ProcessPlacer:: could not get process id=0");
@@ -90,11 +92,11 @@ void G4ProcessPlacer::AddProcessAs(G4VProcess *process, SecondOrLast sol)
     }
 
     // place the given proces as first for the moment
-    GetProcessManager().AddProcess(process);
-    GetProcessManager().SetProcessOrderingToFirst(process, 
+    GetProcessManager()->AddProcess(process);
+    GetProcessManager()->SetProcessOrderingToFirst(process, 
 						  idxPostStep);
     // place transportation first again
-    GetProcessManager().SetProcessOrderingToFirst(transportation, 
+    GetProcessManager()->SetProcessOrderingToFirst(transportation, 
 						  idxPostStep);
   }
   
@@ -109,21 +111,23 @@ void G4ProcessPlacer::AddProcessAs(G4VProcess *process, SecondOrLast sol)
 
 void G4ProcessPlacer::AddProcessAsSecondDoIt(G4VProcess *process)
 {
-  G4cout << "=== G4ProcessPlacer::AddProcessAsSecondDoIt ===" << G4endl;
+  G4cout << "=== G4ProcessPlacer::AddProcessAsSecondDoIt: for: " 
+	 << fParticleName << G4endl;
   AddProcessAs(process, eSecond);
 }
 
 void G4ProcessPlacer::AddProcessAsLastDoIt(G4VProcess *process)
 {
-  G4cout << "=== G4ProcessPlacer::AddProcessAsLastDoIt ===" << G4endl;
+  G4cout << "=== G4ProcessPlacer::AddProcessAsLastDoIt: for: " 
+	 << fParticleName << G4endl;
   AddProcessAs(process, eLast);
 }
 
-G4ProcessManager &G4ProcessPlacer::GetProcessManager()
+G4ProcessManager *G4ProcessPlacer::GetProcessManager()
 { 
   // get particle iterator to add processes ---------------------
-  G4ParticleTable* theParticleTable;
-  G4ParticleTable::G4PTblDicIterator* theParticleIterator;
+  G4ParticleTable* theParticleTable = 0;
+  G4ParticleTable::G4PTblDicIterator* theParticleIterator = 0;
   theParticleTable = G4ParticleTable::GetParticleTable();
   theParticleIterator = theParticleTable->GetIterator();
   // -------------------------------------------------------
@@ -138,31 +142,37 @@ G4ProcessManager &G4ProcessPlacer::GetProcessManager()
     }
   }
   // ---------------------------------------------------------
-  if (!processmanager) G4Exception(" G4ProcessPlacer::GetProcessManager: no ProcessSampler");
-  return *processmanager;
+  if (!processmanager) {
+    G4Exception(" G4ProcessPlacer::GetProcessManager: no ProcessSampler");
+  }
+  return processmanager;
 }
 
 
 void G4ProcessPlacer::PrintPostStepGPILVec(){
   G4cout << "GPIL Vector: " << G4endl;
   G4ProcessVector* processGPILVec = 
-    GetProcessManager().GetPostStepProcessVector(typeGPIL);
+    GetProcessManager()->GetPostStepProcessVector(typeGPIL);
   PrintProcVec(processGPILVec);
 } 
 
 void G4ProcessPlacer::PrintPostStepDoItVec(){
   G4cout << "DoIt Vector: " << G4endl;
   G4ProcessVector* processDoItVec = 
-    GetProcessManager().GetPostStepProcessVector(typeDoIt); 
+    GetProcessManager()->GetPostStepProcessVector(typeDoIt); 
   PrintProcVec(processDoItVec);
 }
 
 
 void G4ProcessPlacer::PrintProcVec(G4ProcessVector* processVec)
 {
-  if (!processVec) G4Exception("G4ProcessPlacer::G4ProcessPlacer: no processVec");
+  if (!processVec) {
+    G4Exception("G4ProcessPlacer::G4ProcessPlacer: no processVec");
+  }
   G4int len = processVec->length();
-  if (len==0) G4Exception("G4ProcessPlacer::G4ProcessPlacer:processVec len = 0");
+  if (len==0) {
+    G4Exception("G4ProcessPlacer::G4ProcessPlacer:processVec len = 0");
+  }
   for (int pi=0; pi<len; pi++) {
     G4VProcess *p = (*processVec)[pi];
     if (p) {

source/processes/transportation/src/G4Transportation.cc

@@ -21,8 +21,8 @@
 // ********************************************************************
 //
 //
-// $Id: G4Transportation.cc,v 1.29 2002/05/17 07:10:23 gcosmo Exp $
-// GEANT4 tag $Name: geant4-04-01 $
+// $Id: G4Transportation.cc,v 1.31 2002/11/08 23:52:34 jacek Exp $
+// GEANT4 tag $Name: geant4-05-00 $
 // 
 // ------------------------------------------------------------
 //	GEANT 4  include file implementation
@@ -435,6 +435,10 @@ G4VParticleChange* G4Transportation::AlongStepDoIt( const G4Track& track,
   // Another (sometimes better way) is to use a user-limit maximum Step size
   //  to alleviate this problem .. 
 
+  // Introducing smooth curved trajectories (jacek 31/10/2002)
+  fParticleChange.SetPointerToVectorOfAuxiliaryPoints
+    (fFieldPropagator->GimmeTrajectoryVectorAndForgetIt() );
+
   return &fParticleChange ;
 
 }

source/processes/transportation/src/G4UserSpecialCuts.cc

@@ -21,8 +21,8 @@
 // ********************************************************************
 //
 //
-// $Id: G4UserSpecialCuts.cc,v 1.4 2001/07/11 10:08:31 gunter Exp $
-// GEANT4 tag $Name: geant4-04-01 $
+// $Id: G4UserSpecialCuts.cc,v 1.7 2002/11/04 10:47:56 dressel Exp $
+// GEANT4 tag $Name: geant4-05-00 $
 // 
 // --------------------------------------------------------------
 // History

source/processes/transportation/src/G4VProcessPlacer.cc

@@ -0,0 +1,39 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * 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.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4VProcessPlacer.cc,v 1.1 2002/10/16 16:27:42 dressel Exp $
+// GEANT4 tag $Name: geant4-05-00 $
+//
+// ----------------------------------------------------------------------
+// GEANT 4 class source file
+//
+// G4VProcessPlacer.cc
+//
+// ----------------------------------------------------------------------
+
+#include "G4VProcessPlacer.hh"
+
+G4VProcessPlacer::G4VProcessPlacer()
+{}
+G4VProcessPlacer::~G4VProcessPlacer()
+{}

source/processes/transportation/src/G4VSampler.cc

@@ -0,0 +1,40 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * 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.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4VSampler.cc,v 1.1 2002/10/16 16:27:42 dressel Exp $
+// GEANT4 tag $Name: geant4-05-00 $
+//
+// ----------------------------------------------------------------------
+// GEANT 4 class source file
+//
+// G4VSampler.cc
+//
+// ----------------------------------------------------------------------
+
+#include "G4VSampler.hh"
+
+G4VSampler::G4VSampler()
+{}
+
+G4VSampler::~G4VSampler()
+{}

source/processes/transportation/src/G4VSamplerConfigurator.cc

@@ -0,0 +1,42 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * 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.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4VSamplerConfigurator.cc,v 1.1 2002/10/16 16:27:42 dressel Exp $
+// GEANT4 tag $Name: geant4-05-00 $
+//
+// ----------------------------------------------------------------------
+// GEANT 4 class source file
+//
+// G4VSamplerConfigurator.cc
+//
+// ----------------------------------------------------------------------
+
+
+#include "G4VSamplerConfigurator.hh"
+
+
+G4VSamplerConfigurator::G4VSamplerConfigurator()
+{}
+
+G4VSamplerConfigurator::~G4VSamplerConfigurator()
+{}

source/processes/transportation/src/G4VTrackTerminator.cc

@@ -0,0 +1,40 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * 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.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4VTrackTerminator.cc,v 1.1 2002/10/16 16:27:42 dressel Exp $
+// GEANT4 tag $Name: geant4-05-00 $
+//
+// ----------------------------------------------------------------------
+// GEANT 4 class source file
+//
+// G4VTrackTerminator.cc
+//
+// ----------------------------------------------------------------------
+
+
+#include "G4VTrackTerminator.hh"
+
+G4VTrackTerminator::G4VTrackTerminator()
+{}
+G4VTrackTerminator::~G4VTrackTerminator()
+{}

source/processes/transportation/src/G4WeightCutOffConfigurator.cc

@@ -0,0 +1,77 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * 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.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4WeightCutOffConfigurator.cc,v 1.3 2002/11/04 10:47:56 dressel Exp $
+// GEANT4 tag $Name: geant4-05-00 $
+//
+// ----------------------------------------------------------------------
+// Class G4WeightCutOffConfigurator
+//
+
+// Author: Michael Dressel (Michael.Dressel@cern.ch)
+// ----------------------------------------------------------------------
+
+#include "G4WeightCutOffConfigurator.hh"
+#include "G4WeightCutOffProcess.hh"
+
+
+G4WeightCutOffConfigurator::
+G4WeightCutOffConfigurator(const G4String &particlename,
+			   G4double wsurvival,
+			   G4double wlimit,
+			   G4double isource,
+			   G4VIStore *istore,
+			   const G4VGCellFinder  &aGCellfinder)
+  :
+  fPlacer(particlename),
+  fWeightCutOffProcess(new  G4WeightCutOffProcess(wsurvival,
+						  wlimit,
+						  isource,
+						  istore,
+						  aGCellfinder)),
+  fPlaced(false)
+{
+  if (!fWeightCutOffProcess) {
+    G4Exception("ERROR:G4WeightCutOffConfigurator::G4WeightCutOffConfigurator: new failed to create G4WeightCutOffProcess!");
+  }
+}
+
+
+G4WeightCutOffConfigurator::~G4WeightCutOffConfigurator(){
+  if (fPlaced) {
+    fPlacer.RemoveProcess(fWeightCutOffProcess);
+    delete fWeightCutOffProcess;
+  }
+}
+
+void G4WeightCutOffConfigurator::
+Configure(G4VSamplerConfigurator *preConf){
+  fPlacer.AddProcessAsLastDoIt(fWeightCutOffProcess); 
+  fPlaced = true;
+}
+
+const G4VTrackTerminator *G4WeightCutOffConfigurator::
+GetTrackTerminator() const {
+  return 0;
+}
+

source/processes/transportation/src/G4WeightCutOffProcess.cc

@@ -0,0 +1,134 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * 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.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4WeightCutOffProcess.cc,v 1.4 2002/11/04 10:47:56 dressel Exp $
+// GEANT4 tag $Name: geant4-05-00 $
+//
+// ----------------------------------------------------------------------
+// GEANT 4 class source file
+//
+// G4WeightCutOffProcess.cc
+//
+// ----------------------------------------------------------------------
+
+#include "G4WeightCutOffProcess.hh"
+#include "G4VScorer.hh"
+#include "G4GeometryCellStep.hh"
+#include "G4ParallelGCellFinder.hh"
+#include "G4MassGCellFinder.hh"
+#include "G4TouchableHandle.hh"
+#include "G4VIStore.hh"
+
+G4WeightCutOffProcess::
+G4WeightCutOffProcess(G4double wsurvival,
+		      G4double wlimit,
+		      G4double isource,
+		      G4VIStore *istore,
+		      const G4VGCellFinder &aGCellFinder,
+		      const G4String &aName)
+  : 
+  G4VProcess(aName), 
+  fParticleChange(new G4ParticleChange),
+  fWeightSurvival(wsurvival),
+  fWeightLimit(wlimit),
+  fSourceImportance(isource),
+  fIStore(istore),
+  fGCellFinder(aGCellFinder)
+{
+  if (!fParticleChange) {
+    G4Exception("ERROR:G4WeightCutOffProcess::G4WeightCutOffProcess: new failed to create G4ParticleChange!");
+  }
+  G4VProcess::pParticleChange = fParticleChange;
+}
+
+G4WeightCutOffProcess::~G4WeightCutOffProcess()
+{
+  delete fParticleChange;
+}
+
+G4double G4WeightCutOffProcess::
+PostStepGetPhysicalInteractionLength(const G4Track& aTrack,
+				     G4double   previousStepSize,
+				     G4ForceCondition* condition)
+{
+  *condition = Forced;
+  return kInfinity;
+}
+  
+G4VParticleChange * 
+G4WeightCutOffProcess::PostStepDoIt(const G4Track& aTrack, 
+				    const G4Step &aStep)
+{
+  fParticleChange->Initialize(aTrack);
+  G4GeometryCell postCell = fGCellFinder.GetPostGeometryCell(aStep);
+  G4double R = fSourceImportance;
+  if (fIStore) {
+    G4double i = fIStore->GetImportance(postCell);
+    if (i>0) {
+      R/=i;
+    }
+  }
+  G4double w = aTrack.GetWeight();
+  if (w<R*fWeightLimit) {
+    G4double ws = fWeightSurvival*R;
+    G4double p = w/(ws);
+    if (G4UniformRand()<p) {
+      fParticleChange->SetStatusChange(fStopAndKill);
+    }
+    else {
+      fParticleChange->SetWeightChange(ws);
+    }                  
+  }
+  return fParticleChange;
+}
+
+const G4String &G4WeightCutOffProcess::GetName() const {
+  return theProcessName;
+}
+
+
+G4double G4WeightCutOffProcess::
+AlongStepGetPhysicalInteractionLength(const G4Track&,
+				      G4double  ,
+				      G4double  ,
+				      G4double& ,
+				      G4GPILSelection*) {
+  return -1.0;
+}
+
+  
+G4double G4WeightCutOffProcess::
+AtRestGetPhysicalInteractionLength(const G4Track& ,
+				   G4ForceCondition*) {
+  return -1.0;
+}
+  
+G4VParticleChange* G4WeightCutOffProcess::
+AtRestDoIt(const G4Track&, const G4Step&) {
+  return 0;
+}
+
+G4VParticleChange* G4WeightCutOffProcess::
+AlongStepDoIt(const G4Track&, const G4Step&) {
+  return 0;
+}