| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 /// \file GB02/src/GB02BOptrMultiParticleForce <<
27 /// \brief Implementation of the GB02BOptrMult <<
28 // <<
29 #include "GB02BOptrMultiParticleForceCollision 26 #include "GB02BOptrMultiParticleForceCollision.hh"
>> 27 #include "G4BiasingProcessInterface.hh"
30 28
31 #include "G4BOptrForceCollision.hh" 29 #include "G4BOptrForceCollision.hh"
32 #include "G4BiasingProcessInterface.hh" <<
33 #include "G4ParticleDefinition.hh" 30 #include "G4ParticleDefinition.hh"
34 #include "G4ParticleTable.hh" 31 #include "G4ParticleTable.hh"
35 32
36 //....oooOO0OOooo........oooOO0OOooo........oo <<
37 <<
38 GB02BOptrMultiParticleForceCollision::GB02BOpt 33 GB02BOptrMultiParticleForceCollision::GB02BOptrMultiParticleForceCollision()
39 : G4VBiasingOperator("TestManyForceCollision << 34 : G4VBiasingOperator("TestManyForceCollision")
40 {} << 35 {
41 << 36 }
42 //....oooOO0OOooo........oooOO0OOooo........oo <<
43 37
44 void GB02BOptrMultiParticleForceCollision::Add 38 void GB02BOptrMultiParticleForceCollision::AddParticle(G4String particleName)
45 { 39 {
46 const G4ParticleDefinition* particle = 40 const G4ParticleDefinition* particle =
47 G4ParticleTable::GetParticleTable()->FindP << 41 G4ParticleTable::GetParticleTable()->FindParticle( particleName );
48 42
49 if (particle == 0) { << 43 if ( particle == 0 )
50 G4ExceptionDescription ed; << 44 {
51 ed << "Particle `" << particleName << "' n << 45 G4ExceptionDescription ed;
52 G4Exception("GB02BOptrMultiParticleForceCo << 46 ed << "Particle `" << particleName << "' not found !" << G4endl;
53 ed); << 47 G4Exception("GB02BOptrMultiParticleForceCollision::AddParticle(...)",
54 return; << 48 "exGB02.01",
55 } << 49 JustWarning,
>> 50 ed);
>> 51 return;
>> 52 }
>> 53
>> 54 G4BOptrForceCollision* optr = new G4BOptrForceCollision(particleName,
>> 55 "ForceCollisionFor"+particleName);
>> 56 fParticlesToBias.push_back( particle );
>> 57 fBOptrForParticle[ particle ] = optr;
56 58
57 G4BOptrForceCollision* optr = <<
58 new G4BOptrForceCollision(particleName, "F <<
59 fParticlesToBias.push_back(particle); <<
60 fBOptrForParticle[particle] = optr; <<
61 } 59 }
62 60
63 //....oooOO0OOooo........oooOO0OOooo........oo << 61 G4VBiasingOperation*
64 << 62 GB02BOptrMultiParticleForceCollision::
65 G4VBiasingOperation* GB02BOptrMultiParticleFor << 63 ProposeOccurenceBiasingOperation(const G4Track* track,
66 const G4Track* track, const G4BiasingProcess << 64 const G4BiasingProcessInterface* callingProcess)
67 { 65 {
68 if (fCurrentOperator) << 66 if ( fCurrentOperator ) return fCurrentOperator->
69 return fCurrentOperator->GetProposedOccure << 67 GetProposedOccurenceBiasingOperation(track, callingProcess);
70 else << 68 else return 0;
71 return 0; <<
72 } 69 }
73 70
74 //....oooOO0OOooo........oooOO0OOooo........oo << 71 G4VBiasingOperation*
75 << 72 GB02BOptrMultiParticleForceCollision::
76 G4VBiasingOperation* GB02BOptrMultiParticleFor << 73 ProposeNonPhysicsBiasingOperation(const G4Track* track,
77 const G4Track* track, const G4BiasingProcess << 74 const G4BiasingProcessInterface* callingProcess)
78 { 75 {
79 if (fCurrentOperator) << 76 if ( fCurrentOperator ) return fCurrentOperator->
80 return fCurrentOperator->GetProposedNonPhy << 77 GetProposedNonPhysicsBiasingOperation(track, callingProcess);
81 else << 78 else return 0;
82 return 0; <<
83 } 79 }
84 80
85 //....oooOO0OOooo........oooOO0OOooo........oo << 81 G4VBiasingOperation*
86 << 82 GB02BOptrMultiParticleForceCollision::
87 G4VBiasingOperation* GB02BOptrMultiParticleFor << 83 ProposeFinalStateBiasingOperation(const G4Track* track,
88 const G4Track* track, const G4BiasingProcess << 84 const G4BiasingProcessInterface* callingProcess)
89 { 85 {
90 if (fCurrentOperator) << 86 if ( fCurrentOperator ) return fCurrentOperator->
91 return fCurrentOperator->GetProposedFinalS << 87 GetProposedFinalStateBiasingOperation(track, callingProcess);
92 else << 88 else return 0;
93 return 0; <<
94 } 89 }
95 90
96 //....oooOO0OOooo........oooOO0OOooo........oo <<
97 91
98 void GB02BOptrMultiParticleForceCollision::Sta << 92 void GB02BOptrMultiParticleForceCollision::StartTracking( const G4Track* track )
99 { 93 {
100 const G4ParticleDefinition* definition = tra 94 const G4ParticleDefinition* definition = track->GetParticleDefinition();
101 std::map<const G4ParticleDefinition*, G4BOpt << 95 std::map < const G4ParticleDefinition*, G4BOptrForceCollision* > :: iterator
102 fBOptrForParticle.find(definition); << 96 it = fBOptrForParticle.find( definition );
103 fCurrentOperator = 0; 97 fCurrentOperator = 0;
104 if (it != fBOptrForParticle.end()) fCurrentO << 98 if ( it != fBOptrForParticle.end() ) fCurrentOperator = (*it).second;
105 } 99 }
106 100
107 //....oooOO0OOooo........oooOO0OOooo........oo << 101 void
108 << 102 GB02BOptrMultiParticleForceCollision::
109 void GB02BOptrMultiParticleForceCollision::Ope << 103 OperationApplied( const G4BiasingProcessInterface* callingProcess,
110 const G4BiasingProcessInterface* callingProc << 104 G4BiasingAppliedCase biasingCase,
111 G4VBiasingOperation* operationApplied, const << 105 G4VBiasingOperation* operationApplied,
112 { << 106 const G4VParticleChange* particleChangeProduced )
113 if (fCurrentOperator) << 107 {
114 fCurrentOperator->ReportOperationApplied(c << 108 if ( fCurrentOperator ) fCurrentOperator->ReportOperationApplied( callingProcess,
115 p << 109 biasingCase,
116 } << 110 operationApplied,
117 << 111 particleChangeProduced );
118 //....oooOO0OOooo........oooOO0OOooo........oo << 112
119 << 113 }
120 void GB02BOptrMultiParticleForceCollision::Ope << 114
121 const G4BiasingProcessInterface* callingProc << 115 void
122 G4VBiasingOperation* occurenceOperationAppli << 116 GB02BOptrMultiParticleForceCollision::
123 G4VBiasingOperation* finalStateOperationAppl << 117 OperationApplied( const G4BiasingProcessInterface* callingProcess,
>> 118 G4BiasingAppliedCase biasingCase,
>> 119 G4VBiasingOperation* occurenceOperationApplied,
>> 120 G4double weightForOccurenceInteraction,
>> 121 G4VBiasingOperation* finalStateOperationApplied,
>> 122 const G4VParticleChange* particleChangeProduced )
>> 123 {
>> 124 if ( fCurrentOperator ) fCurrentOperator->ReportOperationApplied( callingProcess,
>> 125 biasingCase,
>> 126 occurenceOperationApplied,
>> 127 weightForOccurenceInteraction,
>> 128 finalStateOperationApplied,
>> 129 particleChangeProduced );
>> 130 }
>> 131
>> 132 void
>> 133 GB02BOptrMultiParticleForceCollision::
>> 134 ExitBiasing( const G4Track* track,
>> 135 const G4BiasingProcessInterface* callingProcess )
124 { 136 {
125 if (fCurrentOperator) << 137 if ( fCurrentOperator ) fCurrentOperator->ExitingBiasing( track, callingProcess );
126 fCurrentOperator->ReportOperationApplied(c <<
127 w <<
128 f <<
129 } 138 }
130 139
131 //....oooOO0OOooo........oooOO0OOooo........oo <<
132 <<
133 void GB02BOptrMultiParticleForceCollision::Exi <<
134 const G4Track* track, const G4BiasingProcess <<
135 { <<
136 if (fCurrentOperator) fCurrentOperator->Exit <<
137 } <<
138 140
139 //....oooOO0OOooo........oooOO0OOooo........oo <<
140 141