Import Geant4 4.1.0 source tree

This commit is contained in:
Gabriele Cosmo
2016-06-08 16:39:52 +02:00
parent 921d3b1cda
commit 330b82b769
4524 changed files with 178689 additions and 43575 deletions
+9 -1
View File
@@ -1,4 +1,4 @@
# $Id: GNUmakefile,v 1.1 1999/01/07 16:14:09 gunter Exp $
# $Id: GNUmakefile,v 1.4 2002/05/17 07:08:58 gcosmo Exp $
# ------------------------------------------------------------
# GNUmakefile for transportation library. G.Folger 10-Dec-97.
# ------------------------------------------------------------
@@ -17,10 +17,18 @@ CPPFLAGS += -I$(G4BASE)/global/management/include \
-I$(G4BASE)/geometry/management/include \
-I$(G4BASE)/geometry/volumes/include \
-I$(G4BASE)/geometry/magneticfield/include \
-I$(G4BASE)/geometry/biasing/include \
-I$(G4BASE)/track/include \
-I$(G4BASE)/processes/management/include \
-I$(G4BASE)/processes/electromagnetic/utils/include \
-I$(G4BASE)/particles/management/include \
-I$(G4BASE)/materials/include
ifdef G4DEBUG_TRANSPORT
CPPFLAGS += -DG4DEBUG_TRANSPORT
endif
ifdef G4DEBUG_POSTSTEP_TRANSPORT
CPPFLAGS += -DG4DEBUG_POSTSTEP_TRANSPORT
endif
include $(G4INSTALL)/config/common.gmk
+126 -53
View File
@@ -1,4 +1,4 @@
$Id: History,v 1.22 2001/12/08 15:22:44 japost Exp $
$Id: History,v 1.38 2002/05/31 14:52:01 dressel Exp $
-------------------------------------------------------------------
=========================================================
@@ -16,37 +16,115 @@ committal in the CVS repository !
----------------------------------------------------------
* Reverse chronological order (last date on top), please *
----------------------------------------------------------
May 31, 2002 M.Dressel transport-V04-00-08
--------------------------------------------------------
- made weight window sampling to apply only at inital track step 1.
May 31, 2002 M.Dressel transport-V04-00-07
--------------------------------------------------------
- bug fix in G4PArallelScoreSampler.cc and remove Warning from ParallelTransport
May 31, 2002 M.Dressel transport-V04-00-06
--------------------------------------------------------
- renaming of the Manager classes to Sampler classes
- substitution of G4ParallelManager inside the Sampler classes
May 30, 2002 M.Dressel
--------------------------------------------------------
- chamged G4VImportanceScoreConstructor to G4VSampler
May 30, 2002 M.Dressel
--------------------------------------------------------
- all the ImportanceScoreManagers derive form
G4VImportanceScoreConstructor
May 30, 2002 M.Dressel internal-3-transport-V04-00-05
--------------------------------------------------------
- changes in Importance Manager constructors, G4ImportanceAlgorithm as
pointer
May 29, 2002 M.Dressel internal-2-transport-V04-00-05
--------------------------------------------------------
- bug fix in G4PImportanceWWindowScoreManager.cc
and G4ParallelImportanceManager.hh.
May 24, 2002 M.Dressel internal-1-transport-V04-00-05
-------------------------
- Change in G4VProcessPlacer and G4ProcessPlacer: add member function
RemoveProcess to properly remove a process.
- Add classes for wieght window biasing.
May 02, 2002 M.Dressel
-------------------------
- Change in G4ProcessPlacer: set process vector via process manager not
directly.
- Change in G4ParallelTranport: use StartTracking to signal inital step.
This should help to locate "suspended" tracks.
April 24, 2002 G.Cosmo - transport-V04-00-05
-----------------------
- Added G4DEBUG_TRANSPORT flag in GNUmakefile and (on suggestionh of
J.Apostolakis) replaced to G4VERBOSE in G4Transportation::PostStepDoIt()
for extra-check on volume boundary.
Issues addressed by problem report #130 should now be resolved.
April 10, 2002 M.Dressel - transport-V04-00-04
-------------------------
- Added comments to headers of transportation classes and managers for
importance biasing, to fullfill Software Reference Manual.
Apr 9, 2002 G.Cosmo
-------------------
- Added liability disclaimer to scorer classes and minor cosmetics.
Apr 8, 2002 M.Dressel - transport-V04-00-03
---------------------
- Resolved compilation problems on HP-aCC.
Apr 4, 2002 M.Dressel - transport-V04-00-02
---------------------
- Cleaned compilation problems for G4std/std.
Apr 4, 2002 M.Dressel - transport-V04-00-01
---------------------
- Resolved compilation problems on SUN-CC and Linux-egcs.
Mar 28, 2002 M.Dressel - transport-V04-00-00
-----------------------
- First implementation of transportation classes and managers for importance
biasing and scoring. Co-works with "geometry-V04-00-01".
Mar 25, 2002 G.Cosmo
---------------------
- Added dependency to new module geometry/biasing in GNUmakefile.
Dec 8, 2001 J.Apostolakis - transport-V03-02-07
---------------------------
Activated the killing of 'looping' particles -- to be used also to
abandon (kill) particles that are stuck (eg at boundaries).
[ Fix for problems of stuck particles reported by CMS (P.Arce),
and Atlas (A.Del'Acqua, A.Rimoldi) ]
- Activated the killing of 'looping' particles -- to be used also to
abandon (kill) particles that are stuck (eg at boundaries).
[ Fix for problems of stuck particles reported by CMS (P.Arce),
and Atlas (A.Del'Acqua, A.Rimoldi) ]
Nov 28, 2001 J.Apostolakis - transport-V03-02-06
---------------------------
Fix for the new updating of the time for fields -- correcting previous
- Fix for the new updating of the time for fields -- correcting previous
tag. By keeping account whether the field changes the energy (and
therefore the velocity) in the field manager.
Requires and co-works with
Requires and co-works with
- "field-V03-02-07"
- "geomvol-V03-02-02"
in order to compile (let alone have any effect.)
in order to compile (let alone have any effect.)
Nov 10, 2001 J.Apostolakis - transport-V03-02-05
---------------------------
- Motivated by the use case of an Electric Field,
* in order to achieve reasonable accuracy in time integration,
* and to enable fields that vary with the global time
changed Transportation to try to obtain the delta_time from FieldTrack.
Co-works with and requires "field-V03-02-03" to have any effect.
changed Transportation to try to obtain the delta_time from FieldTrack.
Co-works with and requires "field-V03-02-03" to have any effect.
Nov 9, 2001 G. Cosmo - transport-V03-02-04
------------------------
@@ -54,30 +132,28 @@ Nov 9, 2001 G. Cosmo - transport-V03-02-04
Nov 8, 2001 G. Cosmo - transport-V03-02-03
------------------------
Introduced changes to G4Transportation for reference-counted
touchables (R.Chytracek). Added methods GetFreeTouchable() and
SetTheOtherTouchableFree(G4VTouchable*).
- Introduced changes to G4Transportation for reference-counted
touchables (R.Chytracek). Added methods GetFreeTouchable() and
SetTheOtherTouchableFree(G4VTouchable*).
Nov 6, 2001 J. Apostolakis - transport-V03-02-02
------------------------------
Added protection in G4Transportation::AlongStepGPIL for messaging
"ResestStepEstimate" of ChordFinder for the case there is no global field.
** NOTE this is not a perfect resolution (see NOTE in log file). **
--> Thanks to Radovan Chytracek for reporting this problem (move to file log)
- Added protection in G4Transportation::AlongStepGPIL for messaging
"ResestStepEstimate" of ChordFinder for the case there is no global field.
** NOTE this is not a perfect resolution (see NOTE in log file). **
--> Thanks to Radovan Chytracek for reporting this problem (move to file log)
Aug 16, 2001 J. Apostolakis - transport-V03-02-01
------------------------------
Tagged.
(This tag requires field-V03-02-00)
- Tagged. (This tag requires field-V03-02-00)
Aug 16, 2001 J. Apostolakis
------------------------------
- Erasing state information from previous track at the first step of
each track. (-> this is required to ensure repeatability)
This should eliminate any non-repeatability due to the propagation
in field.
( Requires updated version of G4ChordFinder )
each track. (-> this is required to ensure repeatability)
This should eliminate any non-repeatability due to the propagation
in field.
( Requires updated version of G4ChordFinder )
Jul 19, 2001 G. Cosmo transport-V03-02-00
------------------------
@@ -86,33 +162,31 @@ Jul 19, 2001 G. Cosmo transport-V03-02-00
Apr 11, 2001 J. Apostolakis transport-V03-01-02
------------------------------
Corrected the last update of G4Transportation.cc, which overwrote the
value of the spin in the cases where a particle was not charged (eg photon) or
a charged particle was not in a field.
- Corrected the last update of G4Transportation.cc, which overwrote the
value of the spin in the cases where a particle was not charged (eg photon)
or a charged particle was not in a field.
Apr 11, 2001 P. Gumplinger transport-V03-01-01
-----------------------------
Updated G4Transportation.cc to make spin tracking work correctly:
- Replaced the line originally commented out:
// fTransportEndPolarization= aFieldTrack.GetSpin() ; // Not yet possible
with:
fTransportEndSpin = aFieldTrack.GetSpin();
- Added to the AlongStepDoIt() the following call:
fParticleChange.SetPolarizationChange(fTransportEndSpin);
- Updated G4Transportation.cc to make spin tracking work correctly:
o Replaced the line originally commented out:
// fTransportEndPolarization= aFieldTrack.GetSpin() ; // Not yet possible
with:
fTransportEndSpin = aFieldTrack.GetSpin();
o Added to the AlongStepDoIt() the following call:
fParticleChange.SetPolarizationChange(fTransportEndSpin);
Mar 19, 2001 J. Apostolakis transport-V03-00-01
------------------------------
G4Transportation modified to use new FieldTrack, and get Kinetic Energy from it.
This new FieldTrack together with changes in associated Equation of Motion
classes implement the momentum vector as independent variable in place of the
velocity.
So this tag requires
- new geometry/magneticfield tag "field-V03-00-01", and
- new geometry/volumes tag "geomvol-V03-00-03" for new G4PropagatorInField ().
- G4Transportation modified to use new FieldTrack, and get Kinetic
Energy from it.
This new FieldTrack together with changes in associated Equation of Motion
classes implement the momentum vector as independent variable in place of
the velocity.
So this tag requires
- new geometry/magneticfield tag "field-V03-00-01", and
- new geometry/volumes tag "geomvol-V03-00-03" for new
G4PropagatorInField ().
Feb 27, 2001 J. Apostolakis (transport-V03-00-00)
------------------------------
@@ -120,11 +194,10 @@ Feb 27, 2001 J. Apostolakis (transport-V03-00-00)
* Modified calculation of energy at the end of field step
to make it more accurate at low velocities,
(while remaining correct at high gammas).
This improves the energy determination.
Together with electromagnetic/standard tag "stand-V03-00-03"
this addresses the main problem in propagating in an electric field
(Problem report # 108 )
(Problem report # 108 )
Sep 22, 2000 V. Grichine (transport-V02-00-00) [recorded by G.Cosmo]
---------------------------
@@ -0,0 +1,71 @@
//
// ********************************************************************
// * 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: G4ImportancePostStepDoIt.hh,v 1.4 2002/05/31 08:06:34 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// Class G4ImportancePostStepDoIt
//
// Class description:
//
// Used internally by importance sampling.
// It is responsible for the common part of importance sampling
// for the "mass" and "parallel" geometry.
// Author: Michael Dressel (Michael.Dressel@cern.ch)
// ----------------------------------------------------------------------
#ifndef G4ImportancePostStepDoIt_hh
#define G4ImportancePostStepDoIt_hh G4ImportancePostStepDoIt_hh
class G4VImportanceSplitExaminer;
class G4ParticleChange;
class G4Track;
class G4Step;
class G4Nsplit_Weight;
class G4ImportancePostStepDoIt
{
public: // with description
G4ImportancePostStepDoIt();
// simply construct
~G4ImportancePostStepDoIt();
// simple destruct
void DoIt(const G4Track& aTrack,
G4ParticleChange *aParticleChange,
const G4Nsplit_Weight nw);
// Do the PostStepDoIt part common to importance sampling in the
// "mass" and "parallel" geometry.
private:
void Split(const G4Track &aTrack,
const G4Nsplit_Weight &nw,
G4ParticleChange *aParticleChange);
};
#endif
@@ -0,0 +1,98 @@
//
// ********************************************************************
// * 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: G4MScoreProcess.hh,v 1.3 2002/04/10 13:14:16 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// Class G4MScoreProcess
//
// Class description:
//
// Used internally by scoring in the "mass" world.
// This is a forced post step process messaging a "scorer"
// derived from G4VPScorer.
// Author: Michael Dressel (Michael.Dressel@cern.ch)
// ----------------------------------------------------------------------
#ifndef G4MScoreProcess_hh
#define G4MScoreProcess_hh G4MScoreProcess_hh
#include "G4VProcess.hh"
class G4VPScorer;
class G4MScoreProcess : public G4VProcess
{
public: // with description
G4MScoreProcess(G4VPScorer &aScorer,
const G4String &aName = "MScoreProcess");
// take reference to scorer and coppy particle name and
// create a G4ParticleChange
virtual ~G4MScoreProcess();
// delete the G4ParticleChange
virtual G4double
PostStepGetPhysicalInteractionLength(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition);
// make processed being forced
virtual G4VParticleChange * PostStepDoIt(const G4Track&, const G4Step&);
// message "scorer" with G4Step and a G4PStep from the "mass"
// geometry
public: // without description
// no operation in AtRestDoIt and AlongStepDoIt
G4double
AlongStepGetPhysicalInteractionLength(const G4Track&,
G4double ,
G4double ,
G4double& ,
G4GPILSelection*) {return -1.0;}
G4double
AtRestGetPhysicalInteractionLength(const G4Track&,
G4ForceCondition*) {return -1.0;}
G4VParticleChange* AtRestDoIt(const G4Track&,
const G4Step&) {return 0;}
G4VParticleChange* AlongStepDoIt(const G4Track&,
const G4Step&) {return 0;}
private:
G4MScoreProcess(const G4MScoreProcess &);
G4MScoreProcess &operator=(const G4MScoreProcess &);
private:
G4VPScorer &fScorer;
};
#endif
@@ -0,0 +1,99 @@
//
// ********************************************************************
// * 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: G4MassImportanceProcess.hh,v 1.3 2002/04/10 13:14:16 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// Class G4MassImportanceProcess
//
// Class description:
//
// Used internally by importance sampling in the "mass" geometry.
// This process is a forced post step process. I will apply
// importance sampling if the particle crosses a boundary in the
// "mass" geometry.
// Author: Michael Dressel (Michael.Dressel@cern.ch)
// ----------------------------------------------------------------------
#ifndef G4MassImportanceProcess_hh
#define G4MassImportanceProcess_hh G4MassImportanceProcess_hh
#include "G4VProcess.hh"
#include "G4ImportancePostStepDoIt.hh"
class G4VImportanceAlgorithm;
class G4ImportanceFinder;
class G4VIStore;
class G4MassImportanceProcess : public G4VProcess
{
public: // with description
G4MassImportanceProcess(const G4VImportanceAlgorithm &aImportanceAlgorithm,
const G4VIStore &aIstore,
const G4String &aName = "MassImportanceProcess");
// creates a G4ParticleChange
~G4MassImportanceProcess();
// delete the G4ParticleChange
virtual G4double
PostStepGetPhysicalInteractionLength(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition);
// make process beeing forced
virtual G4VParticleChange *PostStepDoIt(const G4Track&, const G4Step&);
// manage the importance sampling in the "mass" geometry
public: // without description
// no operation in AtRestDoIt and AlongStepDoIt
G4double AlongStepGetPhysicalInteractionLength(const G4Track&,
G4double ,
G4double ,
G4double& ,
G4GPILSelection*) {return -1.0;}
G4double AtRestGetPhysicalInteractionLength(const G4Track& ,
G4ForceCondition*) {return -1.0;}
G4VParticleChange* AtRestDoIt(const G4Track&, const G4Step&) {return 0;}
G4VParticleChange* AlongStepDoIt(const G4Track&, const G4Step&) {return 0;}
private:
G4MassImportanceProcess(const G4MassImportanceProcess &);
G4MassImportanceProcess &operator=(const G4MassImportanceProcess &);
private:
G4ParticleChange *fParticleChange;
G4ImportancePostStepDoIt fImportancePostStepDoIt;
const G4VImportanceAlgorithm &fImportanceAlgorithm;
G4ImportanceFinder *fImportanceFinder;
};
#endif
@@ -0,0 +1,89 @@
//
// ********************************************************************
// * 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: G4MassImportanceSampler.hh,v 1.1 2002/05/31 10:16:01 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// Class G4MassImportanceSampler
//
// Class description:
//
// A user should use this class to set up importance sampling
// in the "mass" geometry.
// The user must create an object of this kind and initialise it.
// Author: Michael Dressel (Michael.Dressel@cern.ch)
// ----------------------------------------------------------------------
#ifndef G4MassImportanceSampler_hh
#define G4MassImportanceSampler_hh G4MassImportanceSampler_hh
#include "globals.hh"
#include "G4VSampler.hh"
class G4VIStore;
class G4MassImportanceProcess;
class G4VImportanceAlgorithm;
class G4VProcess;
class G4MassImportanceSampler : public G4VSampler
{
public: // with description
G4MassImportanceSampler(G4VIStore &aIstore,
const G4String &particlename,
const G4VImportanceAlgorithm *algorithm = 0);
// if *algorithm = 0: use the G4ImportanceAlgorithm
// else: use a customised importance algorithm derived from
// G4VImportanceAlgorithm
~G4MassImportanceSampler();
// delete G4MassImportanceProcess and G4VImportanceAlgorithm
// if constructed by this object
G4MassImportanceProcess *CreateMassImportanceProcess();
// create the mass importance process
// don't use it if you use Initialize()
void Initialize();
// the G4MassImportanceSampler has to be initialised after
// the initialisation of the G4RunManager !
private:
G4MassImportanceSampler(const G4MassImportanceSampler &);
G4MassImportanceSampler &operator=(const G4MassImportanceSampler &);
private:
G4VIStore &fIStore;
G4String fParticleName;
G4MassImportanceProcess *fMassImportanceProcess;
G4bool fCreatedAlgorithm;
const G4VImportanceAlgorithm *fAlgorithm;
};
#endif
@@ -0,0 +1,85 @@
//
// ********************************************************************
// * 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: G4MassImportanceScoreSampler.hh,v 1.1 2002/05/31 10:16:01 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// Class G4MassImportanceScoreSampler
//
// Class description:
//
// A user should use this class to set up importance sampling and scoring
// in the "mass" geometry.
// The user must create an object of this kind and initialise it.
// Author: Michael Dressel (Michael.Dressel@cern.ch)
// ----------------------------------------------------------------------
#ifndef G4MassImportanceScoreSampler_hh
#define G4MassImportanceScoreSampler_hh G4MassImportanceScoreSampler_hh
#include "globals.hh"
#include "G4VSampler.hh"
class G4VIStore;
class G4VPScorer;
class G4VImportanceAlgorithm;
class G4MassImportanceSampler;
class G4MassScoreSampler;
class G4MassImportanceScoreSampler : public G4VSampler
{
public: // with description
G4MassImportanceScoreSampler(G4VIStore &aIstore,
G4VPScorer &ascorer,
const G4String &particlename,
const G4VImportanceAlgorithm
*algorithm = 0);
// if *algorithm = 0: use the G4ImportanceAlgorithm
// else : use a customised importance algorithm derived from
// G4VImportanceAlgorithm
~G4MassImportanceScoreSampler();
// delete G4MassScoreSampler and G4MassImportanceSampler if created
void Initialize();
// the G4MassImportanceScoreSampler has to be initialised after
// the initialisation of the G4RunManager !
private:
G4MassImportanceScoreSampler(const G4MassImportanceScoreSampler &);
G4MassImportanceScoreSampler &
operator=(const G4MassImportanceScoreSampler &);
private:
G4MassImportanceSampler *fMassImportanceSampler;
G4MassScoreSampler *fMassScoreSampler;
};
#endif
@@ -0,0 +1,78 @@
//
// ********************************************************************
// * 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: G4MassScoreSampler.hh,v 1.1 2002/05/31 10:16:01 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// Class G4MassScoreSampler
//
// Class description:
//
// A user should use this class to set up scoring in the "mass" geometry.
// The user must create an object of this kind and initialise it.
// Author: Michael Dressel (Michael.Dressel@cern.ch)
// ----------------------------------------------------------------------
#ifndef G4MassScoreSampler_hh
#define G4MassScoreSampler_hh G4MassScoreSampler_hh
#include "globals.hh"
#include "G4VSampler.hh"
class G4VProcess;
class G4VPScorer;
class G4MScoreProcess;
class G4MassScoreSampler : public G4VSampler
{
public: // with description
G4MassScoreSampler(G4VPScorer &ascorer, const G4String &particlename);
// a G4MassScoreSampler for a particle type
~G4MassScoreSampler();
// delete G4MScoreProcess if constructed
G4MScoreProcess *CreateMassScoreProcess();
// create the mass score process
// don't use it if you use Initialize()
void Initialize();
// the G4MassScoreSampler has to be initialised after
// the initialisation of the G4RunManager !
private:
G4MassScoreSampler(const G4MassScoreSampler &);
G4MassScoreSampler &operator=(const G4MassScoreSampler &);
private:
G4VPScorer &fScorer;
G4String fParticleName;
G4MScoreProcess *fMScoreProcess;
};
#endif
@@ -0,0 +1,95 @@
//
// ********************************************************************
// * 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.hh,v 1.5 2002/04/10 13:14:16 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// Class G4PIScorer
//
// Class description:
//
// A scorer delegating the scoring to G4PScorer. It performs
// a check for consistency between the importance value
// assigned to a post G4PTouchableKey and the weight of a track.
// The relation should be importance value * weight = 1.
// CAUTION: This holds only in well defined situations:
// A track starts in a "cell" with importance 1 and has a weight of 1.
// The particle can not be produced by other not importance sampled
// particles.
// Author: Michael Dressel (Michael.Dressel@cern.ch)
// ----------------------------------------------------------------------
#ifndef G4PIScorer_hh
#define G4PIScorer_hh G4PIScorer_hh
#include "g4std/iostream"
#include "G4VPScorer.hh"
#include "G4PMapPtkTallys.hh"
#include "G4PScorer.hh"
class G4Step;
class G4PStep;
class G4VIStore;
class G4PIScorer : public G4VPScorer
{
public: // with description
G4PIScorer(const G4VIStore &IStore);
// simple construction
~G4PIScorer();
// simple destruction
void Score(const G4Step &aStep, const G4PStep &aPStep);
// perform scoring for the G4Step and G4PStep
const G4PMapPtkTallys &GetMapPtkTallys() const
{return fPScorer.GetMapPtkTallys();}
// get a reference to the G4PMapPtkTallys containing
// the tallies
G4bool CorrectWeight() const {return fCorrectWeight;}
// returns false if the weight was not correct
// a user might want to get this information
// to mark the event a incorrect weight occurred
void ResetCorrectWeight() {fCorrectWeight = true;}
// reset fCorrectWeight
// the user has to reset the flag fCorrectWeight
// if he wants to use CorrectWeight()
private:
const G4VIStore &fIStore;
G4PScorer fPScorer;
G4int fNerr;
G4bool fCorrectWeight;
};
G4std::ostream& operator<<(G4std::ostream &out, const G4PIScorer &ps);
#endif
@@ -0,0 +1,99 @@
//
// ********************************************************************
// * 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.hh,v 1.1 2002/05/31 10:16:01 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// Class G4PImportanceWWindowScoreSampler
//
// Class description:
//
// This class manages the importance sampling and importance weight window
// sampling together with scoring in a parallel geometry.
// The user must create an object of this kind and initialise it.
// Author: Michael Dressel (Michael.Dressel@cern.ch)
// ----------------------------------------------------------------------
#ifndef G4PImportanceWWindowScoreSampler_hh
#define G4PImportanceWWindowScoreSampler_hh G4PImportanceWWindowScoreSampler_hh
#include "globals.hh"
#include "G4VSampler.hh"
class G4VIStore;
class G4VPScorer;
class G4VImportanceAlgorithm;
class G4PScoreProcess;
class G4ParallelWorld;
class G4ParallelImportanceSampler;
class G4VProcess;
class G4VWeightWindowAlgorithm;
class G4PImportanceWWindowScoreSampler :
public G4VSampler
{
public: // with description
G4PImportanceWWindowScoreSampler(G4VIStore &iw,
G4VPScorer &ascorer,
const G4String &particlename,
G4VWeightWindowAlgorithm &wwalg,
const G4VImportanceAlgorithm *ialg = 0);
// if *ialg = 0: use G4ImportanceAlgorithm
// use a customised importance algorithm derived from
// G4VImportanceAlgorithm
~G4PImportanceWWindowScoreSampler();
// delete constructed objects
G4PScoreProcess *CreateParallelScoreProcess();
// create the parallel score process
// don't use it if you use Initialize()
G4VProcess *CreateWeightWindowProcess();
void Initialize();
// the G4MassImportanceScoreSampler has to be initialised after
// the initialisation of the G4RunManager !
private:
G4PImportanceWWindowScoreSampler(const G4PImportanceWWindowScoreSampler &);
G4PImportanceWWindowScoreSampler &
operator=(const G4PImportanceWWindowScoreSampler &);
private:
G4String fParticleName;
G4ParallelWorld &fParallelWorld;
G4ParallelImportanceSampler &fParallelImportanceSampler;
G4VPScorer &fPScorer;
G4VIStore &fIstore;
G4PScoreProcess *fPScoreProcess;
G4VProcess *fPWeightWindowProcess;
G4VWeightWindowAlgorithm &fWWAlgorithm;
};
#endif
@@ -0,0 +1,102 @@
//
// ********************************************************************
// * 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: G4PScoreProcess.hh,v 1.3 2002/04/10 13:14:16 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// Class G4PIScoreProcess
//
// Class description:
//
// Used internally by scoring in a "parallel" geometry.
// This forced process messages a "scorer" derived from G4VPScorer.
// The scorer is messaged with the current G4Step and G4PStep.
// This post step process is supposed to be placed as the
// process following directly after transportation and the
// importance sampling process if applied and before all physical
// post step processes.
// Author: Michael Dressel (Michael.Dressel@cern.ch)
// ----------------------------------------------------------------------
#ifndef G4PScoreProcess_hh
#define G4PScoreProcess_hh G4PScoreProcess_hh
#include "G4VProcess.hh"
class G4VParallelStepper;
class G4VPScorer;
class G4PScoreProcess : public G4VProcess
{
public: // with description
G4PScoreProcess(G4VParallelStepper &astepper,
G4VPScorer &aScorer,
const G4String &aName = "PScoreProcess");
// create a G4ParticleChange
virtual ~G4PScoreProcess();
// delete the G4ParticleChange
virtual G4double
PostStepGetPhysicalInteractionLength(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition);
// make the process beeing forced
virtual G4VParticleChange * PostStepDoIt(const G4Track&,
const G4Step&);
// get G4PStep and G4Step and message "scorer"
public: // without description
// no operation in AtRestDoIt and AlongStepDoIt
G4double AlongStepGetPhysicalInteractionLength(const G4Track&,
G4double ,
G4double ,
G4double& ,
G4GPILSelection*) {return -1.0;}
G4double AtRestGetPhysicalInteractionLength(const G4Track& ,
G4ForceCondition*) {return -1.0;}
G4VParticleChange* AtRestDoIt(const G4Track&, const G4Step&) {return 0;}
G4VParticleChange* AlongStepDoIt(const G4Track&, const G4Step&) {return 0;}
private:
G4PScoreProcess(const G4PScoreProcess &);
G4PScoreProcess &operator=(const G4PScoreProcess &);
G4VParallelStepper &fPstepper;
G4VPScorer &fScorer;
};
#endif
@@ -0,0 +1,76 @@
//
// ********************************************************************
// * 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: G4PScorer.hh,v 1.5 2002/04/10 13:14:16 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// Class G4PScorer
//
// Class description:
//
// A scorer for standard tallies. Under development.
// See also G4VPScorer.
// It scores using informations form G4Step and G4PStep.
// The tallies are contained and related with "cells"
// in the container G4PMapPtkTallys (see G4PMapPtkTallys.hh)
// Author: Michael Dressel (Michael.Dressel@cern.ch)
// ----------------------------------------------------------------------
#ifndef G4Pscorer_hh
#define G4Pscorer_hh G4Pscorer_hh
#include "g4std/iostream"
#include "G4VPScorer.hh"
#include "G4PMapPtkTallys.hh"
class G4Step;
class G4PStep;
class G4PScorer : public G4VPScorer
{
public: // with description
G4PScorer();
// simple construction
~G4PScorer();
// simple destruction
void Score(const G4Step &aStep, const G4PStep &aPStep);
// perform scoring for the G4Step and G4PStep
const G4PMapPtkTallys &GetMapPtkTallys() const {return fPtkTallys;}
// get a reference to the G4PMapPtkTallys containing
// the tallies
private:
G4PMapPtkTallys fPtkTallys;
};
G4std::ostream& operator<<(G4std::ostream &out, const G4PScorer &ps);
#endif
@@ -0,0 +1,76 @@
//
// ********************************************************************
// * 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: G4ParallelImportanceProcess.hh,v 1.5 2002/05/31 10:16:01 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// Class G4ParallelImportanceProcess
//
// Class description:
//
// Used internally by importance sampling in a "parallel" geometry.
// This is a G4ParallelTransport that also does importance
// sampling in the "parallel" geometry.
// Author: Michael Dressel (Michael.Dressel@cern.ch)
// ----------------------------------------------------------------------
#ifndef G4ParallelImportanceProcess_hh
#define G4ParallelImportanceProcess_hh G4ParallelImportanceProcess_hh
#include "G4ParallelTransport.hh"
#include "G4ImportancePostStepDoIt.hh"
class G4VImportanceSplitExaminer;
class G4Nsplit_Weight;
class G4ParallelImportanceProcess : public G4ParallelTransport
{
public: // with description
G4ParallelImportanceProcess(const G4VImportanceSplitExaminer &aImportanceSplitExaminer,
G4VPGeoDriver &pgeodriver,
G4VParallelStepper &aStepper,
const G4String &aName = "ParallelImportanceProcess");
// initialise G4ParallelTransport and members
G4VParticleChange *PostStepDoIt(const G4Track&,
const G4Step&);
// do the "parallel transport" and importance sampling.
private:
G4ParallelImportanceProcess(const G4ParallelImportanceProcess &);
G4ParallelImportanceProcess &operator=(const G4ParallelImportanceProcess &);
void Error(const G4String &m);
private:
G4ParticleChange *fParticleChange;
const G4VImportanceSplitExaminer &fImportanceSplitExaminer;
G4ImportancePostStepDoIt fImportancePostStepDoIt;
};
#endif
@@ -0,0 +1,104 @@
//
// ********************************************************************
// * 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.hh,v 1.1 2002/05/31 10:16:01 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// Class G4ParallelImportanceSampler
//
// Class description:
//
// A user should use this class to set up importance sampling
// in a "parallel" geometry.
// The user must create an object of this kind and initialise it.
// Author: Michael Dressel (Michael.Dressel@cern.ch)
// ----------------------------------------------------------------------
#ifndef G4ParallelImportanceSampler_hh
#define G4ParallelImportanceSampler_hh G4ParallelImportanceSampler_hh
#include "globals.hh"
#include "G4VSampler.hh"
class G4ParallelWorld;
class G4VIStore;
class G4VImportanceAlgorithm;
class G4VImportanceSplitExaminer;
class G4ParallelImportanceProcess;
class G4ParallelImportanceSampler : public G4VSampler
{
public: // with description
G4ParallelImportanceSampler(G4VIStore &is,
const G4String &particlename,
const G4VImportanceAlgorithm *ialg = 0);
// if *ialg = 0: use the G4ImportanceAlgorithm
// use a customised importance algorithm derived from
// G4VImportanceAlgorithm
// create G4ParallelWorld and G4ImportanceSplitExaminer
public: // used internally by importance sampling
G4ParallelImportanceSampler(G4VIStore &is,
const G4String &particlename,
G4ParallelWorld &pworld,
const G4VImportanceAlgorithm *ialg = 0);
~G4ParallelImportanceSampler();
// delete G4ParallelWorld and G4ImportanceSplitExaminer
// and G4ImportanceAgorithm and G4ParallelImportanceProcess
// if created
public: // with description
G4ParallelImportanceProcess *CreateParallelImportanceProcess();
// create the parallel importance process
// don't use it if you use Initialize()
void Initialize();
// the G4ParallelImportanceSampler has to be initialised after
// the initialisation of the G4RunManager !
private:
G4ParallelImportanceSampler(const G4ParallelImportanceSampler &);
G4ParallelImportanceSampler &operator=(const G4ParallelImportanceSampler &);
private:
G4String fParticleName;
G4ParallelWorld &fParallelWorld;
G4bool fCreatedPW;
G4bool fDeleteAlg;
const G4VImportanceAlgorithm *fIalgorithm;
G4VImportanceSplitExaminer *fExaminer;
G4ParallelImportanceProcess *fParallelImportanceProcess;
};
#endif
@@ -0,0 +1,92 @@
//
// ********************************************************************
// * 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: G4ParallelImportanceScoreSampler.hh,v 1.1 2002/05/31 10:16:01 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// Class G4ParallelImportanceScoreSampler
//
// Class description:
//
// A user should use this class to set up importance sampling and scoring
// in a "parallel" geometry.
// The user must create an object of this kind and initialise it.
// Author: Michael Dressel (Michael.Dressel@cern.ch)
// ----------------------------------------------------------------------
#ifndef G4ParallelImportanceScoreSampler_hh
#define G4ParallelImportanceScoreSampler_hh G4ParallelImportanceScoreSampler_hh
#include "globals.hh"
#include "G4VSampler.hh"
class G4VIStore;
class G4VPScorer;
class G4VImportanceAlgorithm;
class G4PScoreProcess;
class G4ParallelWorld;
class G4ParallelImportanceSampler;
class G4ParallelImportanceScoreSampler :
public G4VSampler
{
public: // with description
G4ParallelImportanceScoreSampler(G4VIStore &iw,
G4VPScorer &ascorer,
const G4String &particlename,
const G4VImportanceAlgorithm *ialg = 0);
// if *ialg = 0: use G4ImportanceAlgorithm,
// use a customised importance algorithm derived from
// G4VImportanceAlgorithm
~G4ParallelImportanceScoreSampler();
// delete constructed objects
G4PScoreProcess *CreateParallelScoreProcess();
// create the parallel score process
// don't use it if you use Initialize()
void Initialize();
// the G4MassImportanceScoreSampler has to be initialised after
// the initialisation of the G4RunManager !
private:
G4ParallelImportanceScoreSampler(const G4ParallelImportanceScoreSampler &);
G4ParallelImportanceScoreSampler &
operator=(const G4ParallelImportanceScoreSampler &);
private:
G4String fParticleName;
G4ParallelWorld &fParallelWorld;
G4ParallelImportanceSampler &fParallelImportanceSampler;
G4VPScorer &fPScorer;
G4PScoreProcess *fPScoreProcess;
};
#endif
@@ -0,0 +1,87 @@
//
// ********************************************************************
// * 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: G4ParallelScoreSampler.hh,v 1.1 2002/05/31 10:16:01 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// Class G4ParallelScoreSampler
//
// Class description:
//
// A user should use this class to set up scoring in a "parallel"
// geometry.
// The user must create an object of this kind and initialise it.
// Author: Michael Dressel (Michael.Dressel@cern.ch)
// ----------------------------------------------------------------------
#ifndef G4ParallelScoreSampler_hh
#define G4ParallelScoreSampler_hh G4ParallelScoreSampler_hh
#include "globals.hh"
#include "G4VSampler.hh"
class G4ParallelWorld;
class G4VPhysicalVolume;
class G4ParallelTransport;
class G4VPScorer;
class G4PScoreProcess;
class G4ParallelScoreSampler : public G4VSampler
{
public: // with description
G4ParallelScoreSampler(G4VPhysicalVolume &worldvolume,
const G4String &particlename,
G4VPScorer &scorer);
// create and initalise members
~G4ParallelScoreSampler();
// delete constructed members
G4PScoreProcess *CreateParallelScoreProcess();
// create the parallel score process
// don't use it if you use Initialize()
G4ParallelTransport *CreateParallelTransport();
// get the G4ParallelTransport
void Initialize();
// the G4ParallelScoreSampler has to be initialised after
// the initialisation of the G4RunManager !
private:
G4ParallelScoreSampler(const G4ParallelScoreSampler &);
G4ParallelScoreSampler &operator=(const G4ParallelScoreSampler&);
private:
G4String fParticleName;
G4ParallelWorld &fParallelWorld;
G4VPScorer &fPScorer;
G4PScoreProcess *fPScorerProcess;
G4ParallelTransport *fParallelTransport;
};
#endif
@@ -0,0 +1,122 @@
//
// ********************************************************************
// * 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: G4ParallelTransport.hh,v 1.4 2002/05/02 08:43:23 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// Class G4ParallelTransport
//
// Class description:
//
// Used internally by importance sampling and scoring in a "parallel"
// geometry.
// This process "moves" a particle in a "parallel" geometry.
// It should be placed in the post step process do it vector after the
// G4Transportation process.
// Author: Michael Dressel (Michael.Dressel@cern.ch)
// ----------------------------------------------------------------------
#ifndef G4ParallelTransport_hh
#define G4ParallelTransport_hh G4ParallelTransport_hh
#include "g4std/strstream"
#include "G4VProcess.hh"
#include "globals.hh"
class G4VPGeoDriver;
class G4VParallelStepper;
class G4ParallelTransport : public G4VProcess
{
public: // with description
G4ParallelTransport(G4VPGeoDriver &pgeodriver,
G4VParallelStepper &aStepper,
const G4String &aName = "ParallelTransport");
// create G4ParticleChange
virtual ~G4ParallelTransport();
// delete G4ParticleChange
// the post step pair of functions may be overwritten
// in certain derived classes like the importance process
virtual G4double
PostStepGetPhysicalInteractionLength(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition);
// straight distance to the boundary in the "parallel" geometry
// in the direction of the track
virtual G4VParticleChange *PostStepDoIt(const G4Track&, const G4Step&);
// move a track in a "parallel" geometry
// and update a G4PArallelStepper
virtual void StartTracking();
virtual void EndTracking();
G4VParallelStepper &GetPStepper(){return fPStepper;}
// get the fPStepper
public: // without description
// no operation in AtRestDoIt and AlongStepDoIt
G4double AlongStepGetPhysicalInteractionLength(const G4Track&,
G4double ,
G4double ,
G4double& ,
G4GPILSelection*) {return -1.0;}
G4double AtRestGetPhysicalInteractionLength(const G4Track& ,
G4ForceCondition*) {return -1.0;}
G4VParticleChange* AtRestDoIt(const G4Track&, const G4Step&) {return 0;}
G4VParticleChange* AlongStepDoIt(const G4Track&, const G4Step&) {return 0;}
protected:
virtual void Error(const G4String &m);
virtual void Warning(const G4String &m);
G4ParticleChange *fParticleChange;
private:
G4ParallelTransport(const G4ParallelTransport &);
G4ParallelTransport &operator=(const G4ParallelTransport &);
private:
G4VPGeoDriver &fPgeodriver;
G4VParallelStepper &fPStepper;
G4bool fCrossBoundary;
G4bool fInitStep;
};
#endif
@@ -0,0 +1,118 @@
//
// ********************************************************************
// * 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.hh,v 1.2 2002/05/31 10:16:01 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// Class G4ParallelWeightWindowProcess
//
// Class description:
//
// The process performing the weight window sampling according
// to an G4VWeightWindowAlgorithm
//
// Author: Michael Dressel (Michael.Dressel@cern.ch)
// ----------------------------------------------------------------------
#ifndef G4ParallelWeightWindowProcess_hh
#define G4ParallelWeightWindowProcess_hh G4ParallelWeightWindowProcess_hh
#include "g4std/strstream"
#include "G4VProcess.hh"
#include "globals.hh"
#include "G4Nsplit_Weight.hh"
#include "G4ImportancePostStepDoIt.hh"
class G4VIStore;;
class G4VParallelStepper;
class G4VWeightWindowAlgorithm;
class G4ParallelWeightWindowProcess : public G4VProcess
{
public: // with description
G4ParallelWeightWindowProcess(G4VIStore &aIstore,
G4VParallelStepper &aStepper,
G4VWeightWindowAlgorithm &aWWAlgorithm,
const G4String &aName = "ParallelWeightWindowProcess");
// create G4ParticleChange
virtual ~G4ParallelWeightWindowProcess();
// delete G4ParticleChange
virtual G4double
PostStepGetPhysicalInteractionLength(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition);
virtual G4VParticleChange *PostStepDoIt(const G4Track&, const G4Step&);
void StartTracking();
void EndTracking();
public: // without description
// no operation in AtRestDoIt and AlongStepDoIt
G4double AlongStepGetPhysicalInteractionLength(const G4Track&,
G4double ,
G4double ,
G4double& ,
G4GPILSelection*) {return -1.0;}
G4double AtRestGetPhysicalInteractionLength(const G4Track& ,
G4ForceCondition*) {return -1.0;}
G4VParticleChange* AtRestDoIt(const G4Track&, const G4Step&) {return 0;}
G4VParticleChange* AlongStepDoIt(const G4Track&, const G4Step&) {return 0;}
protected:
virtual void Error(const G4String &m);
virtual void Warning(const G4String &m);
G4ParticleChange *fParticleChange;
private:
G4ParallelWeightWindowProcess(const G4ParallelWeightWindowProcess &);
G4ParallelWeightWindowProcess &operator=(const G4ParallelWeightWindowProcess &);
private:
G4VIStore &fIStore;
G4VParallelStepper &fPStepper;
G4VWeightWindowAlgorithm &fWWAlgorithm;
G4Nsplit_Weight fNsplit_Weight;
G4ImportancePostStepDoIt fImportancePostStepDoIt;
G4bool fInitStep;
};
#endif
@@ -0,0 +1,89 @@
//
// ********************************************************************
// * 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: G4ProcessPlacer.hh,v 1.4 2002/05/24 08:17:19 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// Class G4ProcessPlacer
//
// Class description:
//
// Used internally by importance sampling and scoring.
// See G4VProcessPlacer.hh.
// Author: Michael Dressel (Michael.Dressel@cern.ch)
// ----------------------------------------------------------------------
#ifndef G4ProcessPlacer_hh
#define G4ProcessPlacer_hh G4ProcessPlacer_hh
#include "globals.hh"
#include "G4VProcessPlacer.hh"
class G4ProcessManager;
class G4ProcessVector;
class G4ProcessPlacer : public G4VProcessPlacer
{
public: // with description
G4ProcessPlacer(const G4String &particlename);
// create a process placer for a particle type
void AddProcessAsLastDoIt(G4VProcess *process);
// place a post step do it process such that the
// PostStepDoIt function is called last
// THE ORDER CHANGES BY SUBSEQUENT CALLS
void AddProcessAsSecondDoIt(G4VProcess *process);
// place a post step do it process such that the
// PostStepDoIt function is called second
// THE ORDER CHANGES BY SUBSEQUENT CALLS
void RemoveProcess(G4VProcess *process);
// removes a given process
private:
G4ProcessManager &GetProcessManager();
enum SecondOrLast
{
eSecond = 1,
eLast = 0
};
void AddProcessAs(G4VProcess *process, SecondOrLast);
void PrintProcVec(G4ProcessVector* processVec);
void PrintPostStepGPILVec();
void PrintPostStepDoItVec();
private:
G4String fParticleName;
};
#endif
@@ -22,7 +22,7 @@
//
//
// $Id: G4Transportation.hh,v 1.6 2001/11/28 18:27:50 japost Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
//
// ------------------------------------------------------------
@@ -22,7 +22,7 @@
//
//
// $Id: G4Transportation.icc,v 1.4 2001/11/06 01:38:19 radoone Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
//
@@ -22,7 +22,7 @@
//
//
// $Id: G4UserSpecialCuts.hh,v 1.4 2001/07/11 10:08:30 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
// ------------------------------------------------------------
// 15 April 1998 M.Maire
// ------------------------------------------------------------
@@ -0,0 +1,68 @@
//
// ********************************************************************
// * 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.hh,v 1.4 2002/05/24 08:17:19 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// Class G4VProcessPlacer
//
// Class description:
//
// Used internally by importance sampling and scoring to place
// processes as second or last PostStepDoit processes.
// Author: Michael Dressel (Michael.Dressel@cern.ch)
// ----------------------------------------------------------------------
#ifndef G4VProcessPlacer_hh
#define G4VProcessPlacer_hh G4VProcessPlacer_hh
#include "globals.hh"
class G4VProcess;
class G4VProcessPlacer
{
public: // with description
G4VProcessPlacer(const G4String &particlename){}
virtual ~G4VProcessPlacer(){}
virtual void AddProcessAsLastDoIt(G4VProcess *process) = 0;
// place a post step do it process such that the
// PostStepDoIt function is called last
// THE ORDER CHANGES BY SUBSEQUENT CALLS
virtual void AddProcessAsSecondDoIt(G4VProcess *process) = 0;
// place a post step do it process such that the
// PostStepDoIt function is called second
// THE ORDER CHANGES BY SUBSEQUENT CALLS
void RemoveProcess(G4VProcess *process);
// removes a given process
};
#endif
@@ -0,0 +1,48 @@
//
// ********************************************************************
// * 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.hh,v 1.1 2002/05/31 08:08:22 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// Class G4VSampler
//
// Class description:
// The base class for importance sampling and scoring.
//
// Author: Michael Dressel (Michael.Dressel@cern.ch)
// ----------------------------------------------------------------------
#ifndef G4VSampler_hh
#define G4VSampler_hh G4VSampler_hh
class G4VSampler
{
public:
virtual ~G4VSampler(){}
virtual void Initialize() = 0;
// the user must initialize the concrete object this interface
// covers afer the initialization of the G4RunManager
};
#endif
@@ -0,0 +1,91 @@
//
// ********************************************************************
// * 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: G4ImportancePostStepDoIt.cc,v 1.5 2002/05/31 08:06:34 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
//
// G4ImportancePostStepDoIt.cc
//
// ----------------------------------------------------------------------
#include "g4std/strstream"
#include "G4ImportancePostStepDoIt.hh"
#include "G4Track.hh"
#include "G4ParticleChange.hh"
#include "G4VImportanceSplitExaminer.hh"
#include "G4Nsplit_Weight.hh"
G4ImportancePostStepDoIt::G4ImportancePostStepDoIt(){}
G4ImportancePostStepDoIt::~G4ImportancePostStepDoIt(){}
void G4ImportancePostStepDoIt::DoIt(const G4Track& aTrack,
G4ParticleChange *aParticleChange,
const G4Nsplit_Weight nw)
{
// evaluate results from sampler
if (nw.fN>1) {
// split track
Split(aTrack, nw, aParticleChange);
}
else if (nw.fN==1) {
// don't split, but weight may be changed !
aParticleChange->SetWeightChange(nw.fW);
}
else if (nw.fN==0) {
// kill track
aParticleChange->SetStatusChange(fStopAndKill);
}
else {
// wrong answer
G4std::ostrstream os;
os << "G4ImportancePostStepDoIt::DoIt: sampler returned nw = "
<< nw << '\0' << G4endl;
G4Exception(os.str());
}
}
void G4ImportancePostStepDoIt::Split(const G4Track &aTrack,
const G4Nsplit_Weight &nw,
G4ParticleChange *aParticleChange)
{
aParticleChange->SetWeightChange(nw.fW);
aParticleChange->SetNumberOfSecondaries(nw.fN-1);
for (G4int i=1;i<nw.fN;i++) {
G4Track *ptrack = new G4Track(aTrack);
// ptrack->SetCreatorProcess(aTrack.GetCreatorProcess());
ptrack->SetWeight(nw.fW);
if (ptrack->GetMomentumDirection() != aTrack.GetMomentumDirection()) {
G4Exception("ERROR - G4ImportancePostStepDoIt::Split: (ptrack->GetMomentumDirection() != aTrack.GetMomentumDirection()");
}
aParticleChange->AddSecondary(ptrack);
}
return;
}
@@ -0,0 +1,84 @@
//
// ********************************************************************
// * 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: G4MScoreProcess.cc,v 1.3 2002/04/09 17:40:15 gcosmo Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
//
// G4MScoreProcess.cc
//
// ----------------------------------------------------------------------
#include "G4MScoreProcess.hh"
#include "G4VPScorer.hh"
#include "G4PStep.hh"
#include "G4VParallelStepper.hh"
G4MScoreProcess::G4MScoreProcess(G4VPScorer &aScorer,
const G4String &aName)
: G4VProcess(aName),
fScorer(aScorer)
{
G4VProcess::pParticleChange = new G4ParticleChange;
}
G4MScoreProcess::~G4MScoreProcess()
{
delete pParticleChange;
}
G4double G4MScoreProcess::
PostStepGetPhysicalInteractionLength(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition)
{
*condition = Forced;
return kInfinity;
}
G4VParticleChange *
G4MScoreProcess::PostStepDoIt(const G4Track& aTrack, const G4Step &aStep)
{
pParticleChange->Initialize(aTrack);
if (aStep.GetStepLength() > kCarTolerance) {
G4StepPoint *prepoint = aStep.GetPreStepPoint();
G4StepPoint *postpoint = aStep.GetPostStepPoint();
G4PTouchableKey prekey(*(prepoint->GetPhysicalVolume()),
prepoint->GetTouchable()->GetReplicaNumber());
G4PTouchableKey postkey(*(postpoint->GetPhysicalVolume()),
postpoint->GetTouchable()->GetReplicaNumber());
G4PStep pstep(prekey, postkey);
pstep.fCrossBoundary = false;
if (prekey != postkey) pstep.fCrossBoundary = true;
fScorer.Score(aStep, pstep);
}
return G4VProcess::pParticleChange;
}
@@ -0,0 +1,93 @@
//
// ********************************************************************
// * 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: G4MassImportanceProcess.cc,v 1.3 2002/04/09 17:40:15 gcosmo Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
//
// G4MassImportanceProcess.cc
//
// ----------------------------------------------------------------------
#include "G4MassImportanceProcess.hh"
#include "G4VImportanceAlgorithm.hh"
#include "G4ImportanceFinder.hh"
#include "G4PTouchableKey.hh"
G4MassImportanceProcess::
G4MassImportanceProcess(const G4VImportanceAlgorithm &aImportanceAlgorithm,
const G4VIStore &aIstore,
const G4String &aName)
: G4VProcess(aName),
fImportanceAlgorithm(aImportanceAlgorithm),
fImportanceFinder(new G4ImportanceFinder(aIstore))
{
fParticleChange = new G4ParticleChange;
G4VProcess::pParticleChange = fParticleChange;
}
G4MassImportanceProcess::~G4MassImportanceProcess()
{
delete fImportanceFinder;
delete fParticleChange;
}
G4double G4MassImportanceProcess::
PostStepGetPhysicalInteractionLength(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition)
{
*condition = Forced;
return kInfinity;
}
G4VParticleChange *
G4MassImportanceProcess::PostStepDoIt(const G4Track &aTrack,
const G4Step &aStep)
{
fParticleChange->Initialize(aTrack);
if (aStep.GetPostStepPoint()->GetStepStatus() == fGeomBoundary
&& aStep.GetStepLength() > kCarTolerance) {
if (aTrack.GetTrackStatus()==fStopAndKill) {
G4cout << "G4MassImportanceProcess::PostStepDoIt StopAndKill" << G4endl;
}
G4StepPoint *prepoint = aStep.GetPreStepPoint();
G4StepPoint *postpoint = aStep.GetPostStepPoint();
G4PTouchableKey prekey(*(prepoint->GetPhysicalVolume()),
prepoint->GetTouchable()->GetReplicaNumber());
G4PTouchableKey postkey(*(postpoint->GetPhysicalVolume()),
postpoint->GetTouchable()->GetReplicaNumber());
G4Nsplit_Weight nw = fImportanceAlgorithm.
Calculate(fImportanceFinder->
GetIPre_over_IPost(prekey, postkey),
aTrack.GetWeight());
fImportancePostStepDoIt.DoIt(aTrack, fParticleChange, nw);
}
return fParticleChange;
}
@@ -0,0 +1,76 @@
//
// ********************************************************************
// * 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: G4MassImportanceSampler.cc,v 1.1 2002/05/31 10:16:02 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
//
// G4MassImportanceSampler.cc
//
// ----------------------------------------------------------------------
#include "G4MassImportanceSampler.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))
{}
G4MassImportanceSampler::~G4MassImportanceSampler()
{
if (fMassImportanceProcess) {
G4ProcessPlacer placer(fParticleName);
placer.RemoveProcess(fMassImportanceProcess);
delete fMassImportanceProcess;
}
if (fCreatedAlgorithm) delete fAlgorithm;
}
G4MassImportanceProcess *G4MassImportanceSampler::CreateMassImportanceProcess()
{
if (!fMassImportanceProcess) {
fMassImportanceProcess =
new G4MassImportanceProcess(*fAlgorithm, fIStore);
}
return fMassImportanceProcess;
}
void G4MassImportanceSampler::Initialize()
{
G4ProcessPlacer placer(fParticleName);
placer.AddProcessAsSecondDoIt(CreateMassImportanceProcess());
}
@@ -0,0 +1,60 @@
//
// ********************************************************************
// * 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: G4MassImportanceScoreSampler.cc,v 1.1 2002/05/31 10:16:02 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
//
// G4MassImportanceScoreSampler.cc
//
// ----------------------------------------------------------------------
#include "G4MassImportanceScoreSampler.hh"
#include "G4MassImportanceSampler.hh"
#include "G4MassScoreSampler.hh"
G4MassImportanceScoreSampler::
G4MassImportanceScoreSampler(G4VIStore &aIstore,
G4VPScorer &ascorer,
const G4String &particlename,
const G4VImportanceAlgorithm *algorithm)
: fMassImportanceSampler(new G4MassImportanceSampler(aIstore,
particlename,
algorithm)),
fMassScoreSampler(new G4MassScoreSampler(ascorer, particlename))
{}
G4MassImportanceScoreSampler::~G4MassImportanceScoreSampler()
{
delete fMassScoreSampler;
delete fMassImportanceSampler;
}
void G4MassImportanceScoreSampler::Initialize()
{
fMassScoreSampler->Initialize();
fMassImportanceSampler->Initialize();
}
@@ -0,0 +1,67 @@
//
// ********************************************************************
// * 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: G4MassScoreSampler.cc,v 1.1 2002/05/31 10:16:02 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
//
// G4MassScoreSampler.cc
//
// ----------------------------------------------------------------------
#include "G4MassScoreSampler.hh"
#include "G4MScoreProcess.hh"
#include "G4ProcessPlacer.hh"
G4MassScoreSampler::G4MassScoreSampler(G4VPScorer &ascorer,
const G4String &particlename)
: fScorer(ascorer),
fParticleName(particlename),
fMScoreProcess(0)
{}
G4MassScoreSampler::~G4MassScoreSampler()
{
if (fMScoreProcess) {
G4ProcessPlacer placer(fParticleName);
placer.RemoveProcess(fMScoreProcess);
delete fMScoreProcess;
}
}
G4MScoreProcess *G4MassScoreSampler::CreateMassScoreProcess()
{
if (!fMScoreProcess) {
fMScoreProcess = new G4MScoreProcess(fScorer);
}
return fMScoreProcess;
}
void G4MassScoreSampler::Initialize()
{
G4ProcessPlacer placer(fParticleName);
placer.AddProcessAsSecondDoIt(CreateMassScoreProcess());
}
@@ -0,0 +1,92 @@
//
// ********************************************************************
// * 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;
}
@@ -0,0 +1,111 @@
//
// ********************************************************************
// * 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());
}
@@ -0,0 +1,70 @@
//
// ********************************************************************
// * 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: G4PScoreProcess.cc,v 1.2 2002/04/09 17:40:15 gcosmo Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
//
// G4PIScoreProcess.cc
//
// ----------------------------------------------------------------------
#include "G4PScoreProcess.hh"
#include "G4VPScorer.hh"
#include "G4PStep.hh"
#include "G4VParallelStepper.hh"
G4PScoreProcess::G4PScoreProcess(G4VParallelStepper &astepper,
G4VPScorer &aScorer,
const G4String &aName)
: G4VProcess(aName),
fPstepper(astepper),
fScorer(aScorer)
{
G4VProcess::pParticleChange = new G4ParticleChange;
}
G4PScoreProcess::~G4PScoreProcess()
{
delete pParticleChange;
}
G4double G4PScoreProcess::
PostStepGetPhysicalInteractionLength(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition)
{
*condition = Forced;
return kInfinity;
}
G4VParticleChange *
G4PScoreProcess::PostStepDoIt(const G4Track& aTrack, const G4Step &aStep)
{
pParticleChange->Initialize(aTrack);
fScorer.Score(aStep, fPstepper.GetPStep());
return G4VProcess::pParticleChange;
}
@@ -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: G4PScorer.cc,v 1.7 2002/04/09 17:40:15 gcosmo Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
//
// G4PScorer.cc
//
// ----------------------------------------------------------------------
#include "G4PScorer.hh"
#include "G4Step.hh"
#include "G4PStep.hh"
#include "G4Sigma.hh"
#include "G4StateManager.hh"
G4PScorer::G4PScorer(){}
G4PScorer::~G4PScorer(){}
void G4PScorer::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();
// 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);
}
}
}
}
G4std::ostream& operator<<(G4std::ostream &out, const G4PScorer &ps)
{
out << ps.GetMapPtkTallys();
return out;
}
@@ -0,0 +1,68 @@
//
// ********************************************************************
// * 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: G4ParallelImportanceProcess.cc,v 1.3 2002/05/31 08:06:34 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
//
// G4ParallelImportanceProcess.cc
//
// ----------------------------------------------------------------------
#include "G4ParallelImportanceProcess.hh"
#include "G4VImportanceSplitExaminer.hh"
#include "g4std/strstream"
G4ParallelImportanceProcess::
G4ParallelImportanceProcess(const G4VImportanceSplitExaminer &aImportanceSplitExaminer,
G4VPGeoDriver &pgeodriver,
G4VParallelStepper &aStepper,
const G4String &aName)
: G4ParallelTransport(pgeodriver, aStepper, aName),
fParticleChange(G4ParallelTransport::fParticleChange),
fImportanceSplitExaminer(aImportanceSplitExaminer)
{}
G4VParticleChange *G4ParallelImportanceProcess::
PostStepDoIt(const G4Track& aTrack, const G4Step &aStep)
{
if (aTrack.GetTrackStatus()==fStopAndKill) {
G4cout << "G4ParallelImportanceProcess::PostStepDoIt StopAndKill" << G4endl;
}
G4ParallelTransport::PostStepDoIt(aTrack, aStep);
// get new weight and number of clones
G4Nsplit_Weight nw(fImportanceSplitExaminer.Examine(aTrack.GetWeight()));
fImportancePostStepDoIt.DoIt(aTrack, fParticleChange, nw);
return fParticleChange;
}
void G4ParallelImportanceProcess::Error(const G4String &m)
{
G4cout << "ERROR - G4ImportanceProcess::" << m << G4endl;
G4Exception("Program aborted.");
}
@@ -0,0 +1,110 @@
//
// ********************************************************************
// * 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;
}
@@ -0,0 +1,86 @@
//
// ********************************************************************
// * 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: G4ParallelImportanceScoreSampler.cc,v 1.1 2002/05/31 10:16:02 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
//
// G4ParallelImportanceScoreSampler.cc
//
// ----------------------------------------------------------------------
#include "G4ParallelWorld.hh"
#include "G4ParallelImportanceScoreSampler.hh"
#include "G4ParallelImportanceSampler.hh"
#include "G4ParallelWorld.hh"
#include "G4ProcessPlacer.hh"
#include "G4VIStore.hh"
#include "G4VPScorer.hh"
#include "G4PScoreProcess.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),
fPScoreProcess(0)
{}
G4ParallelImportanceScoreSampler::~G4ParallelImportanceScoreSampler()
{
if (fPScoreProcess) {
G4ProcessPlacer placer(fParticleName);
placer.RemoveProcess(fPScoreProcess);
delete fPScoreProcess;
}
delete &fParallelImportanceSampler;
delete &fParallelWorld;
}
G4PScoreProcess *
G4ParallelImportanceScoreSampler::CreateParallelScoreProcess()
{
if (!fPScoreProcess) {
fPScoreProcess =
new G4PScoreProcess(fParallelWorld.
GetParallelStepper(), fPScorer);
}
return fPScoreProcess;
}
void G4ParallelImportanceScoreSampler::Initialize()
{
G4ProcessPlacer placer(fParticleName);
placer.AddProcessAsSecondDoIt(CreateParallelScoreProcess());
fParallelImportanceSampler.Initialize();
}
@@ -0,0 +1,88 @@
//
// ********************************************************************
// * 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: G4ParallelScoreSampler.cc,v 1.2 2002/05/31 13:49:46 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
//
// G4ParallelScoreSampler.cc
//
// ----------------------------------------------------------------------
#include "G4ParallelScoreSampler.hh"
#include "G4PScoreProcess.hh"
#include "G4ProcessPlacer.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),
fParallelTransport(0)
{}
G4ParallelScoreSampler::~G4ParallelScoreSampler()
{
if (fPScorerProcess) {
G4ProcessPlacer placer(fParticleName);
placer.RemoveProcess(fPScorerProcess);
delete fPScorerProcess;
}
delete &fParallelWorld;
}
G4PScoreProcess *G4ParallelScoreSampler::CreateParallelScoreProcess()
{
if (!fPScorerProcess) {
fPScorerProcess =
new G4PScoreProcess(fParallelWorld.GetParallelStepper(),
fPScorer);
}
return fPScorerProcess;
}
G4ParallelTransport *G4ParallelScoreSampler::CreateParallelTransport()
{
if (!fParallelTransport) {
fParallelTransport = new G4ParallelTransport(fParallelWorld.
GetGeoDriver(),
fParallelWorld.
GetParallelStepper());
}
return fParallelTransport;
}
void G4ParallelScoreSampler::Initialize()
{
G4ProcessPlacer placer(fParticleName);
placer.AddProcessAsSecondDoIt(CreateParallelScoreProcess());
placer.AddProcessAsSecondDoIt(CreateParallelTransport());
}
@@ -0,0 +1,131 @@
//
// ********************************************************************
// * 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: G4ParallelTransport.cc,v 1.4 2002/05/31 13:49:47 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
//
// G4ParallelTransport.cc
//
// ----------------------------------------------------------------------
#include "G4ParallelTransport.hh"
#include "G4VPGeoDriver.hh"
#include "G4VParallelStepper.hh"
#include "G4Pstring.hh"
G4ParallelTransport::G4ParallelTransport(G4VPGeoDriver &pgeodriver,
G4VParallelStepper &aStepper,
const G4String &aName)
: G4VProcess(aName),
fPgeodriver(pgeodriver),
fPStepper(aStepper),
fCrossBoundary(false),
fInitStep(false)
{
fParticleChange = new G4ParticleChange;
G4VProcess::pParticleChange = fParticleChange;
}
G4ParallelTransport::~G4ParallelTransport()
{
delete fParticleChange;
}
void G4ParallelTransport::StartTracking(){
fInitStep = true;
}
void G4ParallelTransport::EndTracking(){}
G4double
G4ParallelTransport::
PostStepGetPhysicalInteractionLength(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition)
{
G4double stepLength;
// if this function is called on a new track let the navigator
// know about it
// G4bool initStep = (aTrack.GetCurrentStepNumber() == 1);
if (fInitStep) {
fInitStep = false;
stepLength = fPgeodriver.
ComputeStepLengthInit(aTrack.GetPosition(),
aTrack.GetMomentumDirection());
fPStepper.Init(fPgeodriver.GetCurrentTouchableKey());
fCrossBoundary = false;
}
else if (fCrossBoundary) {
stepLength = fPgeodriver.
ComputeStepLengthCrossBoundary(aTrack.GetPosition(),
aTrack.GetMomentumDirection());
fPStepper.UnSetCrossBoundary();
fCrossBoundary = false;
}
else {
stepLength = fPgeodriver.
ComputeStepLengthInVolume(aTrack.GetPosition(),
aTrack.GetMomentumDirection());
}
*condition = NotForced;
return stepLength;
}
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";
Warning(m);
}
fParticleChange->Initialize(aTrack);
fCrossBoundary = true;
fPgeodriver.LocateOnBoundary(aTrack.GetPosition(),
aTrack.GetMomentumDirection());
fPStepper.Update(fPgeodriver.GetCurrentTouchableKey());
return fParticleChange;
}
void G4ParallelTransport::Error(const G4String &m)
{
G4cout << "ERROR - G4ParallelTransport::" << m << G4endl;
G4Exception("Program aborted.");
}
void G4ParallelTransport::Warning(const G4String &m)
{
G4cout << "WARNING - G4ParallelTransport: " << G4endl;
G4cout << m << G4endl;
}
@@ -0,0 +1,113 @@
//
// ********************************************************************
// * 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;
}
@@ -0,0 +1,178 @@
//
// ********************************************************************
// * 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: G4ProcessPlacer.cc,v 1.6 2002/05/31 10:16:02 dressel Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
//
// G4ProcessPlacer.cc
//
// ----------------------------------------------------------------------
#include "G4ProcessPlacer.hh"
#include "G4ProcessManager.hh"
#include "G4VProcess.hh"
#include "G4ParticleTable.hh"
G4ProcessPlacer::G4ProcessPlacer(const G4String &particlename)
: G4VProcessPlacer(particlename),
fParticleName(particlename)
{
G4cout << "+++ G4ProcessPlacer::G4ProcessPlacer: for: " << particlename
<< G4endl;
}
void G4ProcessPlacer::RemoveProcess(G4VProcess *process){
G4cout << " ProcessName: " << process->GetProcessName()
<< ", will be removed!" << G4endl;
G4cout << "The initial Vectors: " << G4endl;
PrintPostStepGPILVec();
PrintPostStepDoItVec();
GetProcessManager().RemoveProcess(process);
G4cout << "The final Vectors: " << G4endl;
PrintPostStepGPILVec();
PrintPostStepDoItVec();
}
void G4ProcessPlacer::AddProcessAs(G4VProcess *process, SecondOrLast sol)
{
G4cout << " ProcessName: " << process->GetProcessName() << G4endl;
G4cout << "The initial Vectors: " << G4endl;
PrintPostStepGPILVec();
PrintPostStepDoItVec();
if (sol == eLast) {
GetProcessManager().AddProcess(process,
ordInActive,
ordInActive,
ordLast);
}
else if (sol == eSecond) {
// get transportation process
G4VProcess *transportation =
(* (GetProcessManager().GetProcessList()))[0];
if (!transportation) {
G4Exception(" G4ProcessPlacer:: could not get process id=0");
}
if (transportation->GetProcessName() != "Transportation") {
G4cout << transportation->GetProcessName() << G4endl;
G4Exception(" G4ProcessPlacer:: process id=0 is not Transportation");
}
// place the given proces as first for the moment
GetProcessManager().AddProcess(process);
GetProcessManager().SetProcessOrderingToFirst(process,
idxPostStep);
// place transportation first again
GetProcessManager().SetProcessOrderingToFirst(transportation,
idxPostStep);
}
// for verification inly
G4cout << "The final Vectors: " << G4endl;
PrintPostStepGPILVec();
PrintPostStepDoItVec();
G4cout << "================================================" << G4endl;
}
void G4ProcessPlacer::AddProcessAsSecondDoIt(G4VProcess *process)
{
G4cout << "=== G4ProcessPlacer::AddProcessAsSecondDoIt ===" << G4endl;
AddProcessAs(process, eSecond);
}
void G4ProcessPlacer::AddProcessAsLastDoIt(G4VProcess *process)
{
G4cout << "=== G4ProcessPlacer::AddProcessAsLastDoIt ===" << G4endl;
AddProcessAs(process, eLast);
}
G4ProcessManager &G4ProcessPlacer::GetProcessManager()
{
// get particle iterator to add processes ---------------------
G4ParticleTable* theParticleTable;
G4ParticleTable::G4PTblDicIterator* theParticleIterator;
theParticleTable = G4ParticleTable::GetParticleTable();
theParticleIterator = theParticleTable->GetIterator();
// -------------------------------------------------------
G4ProcessManager *processmanager = 0;
// add parallel transport processe ---------------------------
theParticleIterator->reset();
while( (*theParticleIterator)() ){
G4ParticleDefinition* particle = theParticleIterator->value();
if (particle->GetParticleName() == fParticleName) {
processmanager = particle->GetProcessManager();
break;
}
}
// ---------------------------------------------------------
if (!processmanager) G4Exception(" G4ProcessPlacer::GetProcessManager: no ProcessSampler");
return *processmanager;
}
void G4ProcessPlacer::PrintPostStepGPILVec(){
G4cout << "GPIL Vector: " << G4endl;
G4ProcessVector* processGPILVec =
GetProcessManager().GetPostStepProcessVector(typeGPIL);
PrintProcVec(processGPILVec);
}
void G4ProcessPlacer::PrintPostStepDoItVec(){
G4cout << "DoIt Vector: " << G4endl;
G4ProcessVector* processDoItVec =
GetProcessManager().GetPostStepProcessVector(typeDoIt);
PrintProcVec(processDoItVec);
}
void G4ProcessPlacer::PrintProcVec(G4ProcessVector* processVec)
{
if (!processVec) G4Exception("G4ProcessPlacer::G4ProcessPlacer: no processVec");
G4int len = processVec->length();
if (len==0) G4Exception("G4ProcessPlacer::G4ProcessPlacer:processVec len = 0");
for (int pi=0; pi<len; pi++) {
G4VProcess *p = (*processVec)[pi];
if (p) {
G4cout << " " << p->GetProcessName() << G4endl;
}
else {
G4cout << " " << "no process found for position: " << pi
<< ", in vector of length: " << len << G4endl;
}
}
}
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4Transportation.cc,v 1.27 2001/12/08 15:20:30 japost Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4Transportation.cc,v 1.29 2002/05/17 07:10:23 gcosmo Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// ------------------------------------------------------------
// GEANT 4 include file implementation
@@ -497,8 +497,7 @@ G4VParticleChange* G4Transportation::PostStepDoIt( const G4Track& track,
}
else
{ // fGeometryLimitedStep is false
//#ifdef G4DEBUG
#ifdef G4VERBOSE
#ifdef G4DEBUG_POSTSTEP_TRANSPORT
// Although the location is changed, we know that the physical
// volume remains constant.
// In order to help in checking the user geometry
@@ -574,7 +573,7 @@ G4VParticleChange* G4Transportation::PostStepDoIt( const G4Track& track,
fLinearNavigator->LocateGlobalPointWithinVolume( track.GetPosition()) ;
#else
// ie #ifndef G4DEBUG does a quick relocation
// ie #ifndef G4DEBUG_POSTSTEP_TRANSPORT does a quick relocation
// The serves only to move the Navigator's location
@@ -22,7 +22,7 @@
//
//
// $Id: G4UserSpecialCuts.cc,v 1.4 2001/07/11 10:08:31 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
// --------------------------------------------------------------
// History