| 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 // G4BFieldIntegrationDriver 26 // G4BFieldIntegrationDriver
27 // 27 //
28 // Class description: 28 // Class description:
29 // 29 //
30 // Specialized integration driver for pure mag 30 // Specialized integration driver for pure magnetic field
31 31
32 // Author: D.Sorokin 32 // Author: D.Sorokin
33 // ------------------------------------------- 33 // --------------------------------------------------------------------
34 #ifndef G4BFIELD_INTEGRATION_DRIVER_HH 34 #ifndef G4BFIELD_INTEGRATION_DRIVER_HH
35 #define G4BFIELD_INTEGRATION_DRIVER_HH 35 #define G4BFIELD_INTEGRATION_DRIVER_HH
36 36
37 #include "G4VIntegrationDriver.hh" 37 #include "G4VIntegrationDriver.hh"
38 #include "G4Mag_EqRhs.hh" 38 #include "G4Mag_EqRhs.hh"
39 39
40 #include <memory> 40 #include <memory>
41 41
42 class G4BFieldIntegrationDriver : public G4VIn 42 class G4BFieldIntegrationDriver : public G4VIntegrationDriver
43 { 43 {
44 public: 44 public:
45 45
46 G4BFieldIntegrationDriver( 46 G4BFieldIntegrationDriver(
47 std::unique_ptr<G4VIntegrationDriver> 47 std::unique_ptr<G4VIntegrationDriver> smallStepDriver,
48 std::unique_ptr<G4VIntegrationDriver> 48 std::unique_ptr<G4VIntegrationDriver> largeStepDriver);
49 49
50 G4BFieldIntegrationDriver(const G4BFieldIn 50 G4BFieldIntegrationDriver(const G4BFieldIntegrationDriver &) = delete;
51 const G4BFieldIntegrationDriver& operator 51 const G4BFieldIntegrationDriver& operator =(const G4BFieldIntegrationDriver &) = delete;
52 52
53 G4double AdvanceChordLimited(G4FieldTrack& << 53 virtual G4double AdvanceChordLimited(G4FieldTrack& track,
54 G4double hste << 54 G4double hstep,
55 G4double eps, << 55 G4double eps,
56 G4double chor << 56 G4double chordDistance) override;
57 57
58 G4bool AccurateAdvance(G4FieldTrack& track << 58 virtual G4bool AccurateAdvance(G4FieldTrack& track,
59 G4double hstep, << 59 G4double hstep,
60 G4double eps, << 60 G4double eps,
61 G4double hinitial = << 61 G4double hinitial = 0) override
62 { 62 {
63 return fCurrDriver->AccurateAdvance(trac << 63 return fCurrDriver->AccurateAdvance(track, hstep, eps, hinitial);
64 } 64 }
65 65
66 G4bool DoesReIntegrate() const override << 66 virtual G4bool DoesReIntegrate() override
67 { 67 {
68 return fCurrDriver->DoesReIntegrate(); << 68 return fCurrDriver->DoesReIntegrate();
69 } 69 }
70 70
71 //[[deprecated("will be removed")]] 71 //[[deprecated("will be removed")]]
72 void GetDerivatives(const G4FieldTrack& tr << 72 virtual void GetDerivatives(const G4FieldTrack& track,
73 G4double dydx[]) << 73 G4double dydx[]) const override
74 { 74 {
75 fCurrDriver->GetDerivatives(track, dydx) << 75 fCurrDriver->GetDerivatives(track, dydx);
76 } 76 }
77 77
78 //[[deprecated("will be removed")]] 78 //[[deprecated("will be removed")]]
79 void GetDerivatives(const G4FieldTrack& tr << 79 virtual void GetDerivatives(const G4FieldTrack& track,
80 G4double dydx[], << 80 G4double dydx[],
81 G4double field[] << 81 G4double field[]) const override
82 { 82 {
83 fCurrDriver->GetDerivatives(track, dydx, << 83 fCurrDriver->GetDerivatives(track, dydx, field);
84 } 84 }
85 85
86 void SetEquationOfMotion(G4EquationOfMotio << 86 virtual void SetEquationOfMotion(G4EquationOfMotion* equation) override;
87 87
88 G4EquationOfMotion* GetEquationOfMotion() << 88 virtual G4EquationOfMotion* GetEquationOfMotion() override
89 { 89 {
90 return fCurrDriver->GetEquationOfMotion( << 90 return fCurrDriver->GetEquationOfMotion();
91 } 91 }
92 92
93 //[[deprecated("use GetEquationOfMotion() 93 //[[deprecated("use GetEquationOfMotion() instead of GetStepper()->GetEquationOfMotion()")]]
94 const G4MagIntegratorStepper* GetStepper() << 94 virtual const G4MagIntegratorStepper* GetStepper() const override
95 { 95 {
96 return fCurrDriver->GetStepper(); << 96 return fCurrDriver->GetStepper();
97 } 97 }
98 98
99 G4MagIntegratorStepper* GetStepper() overr << 99 virtual G4MagIntegratorStepper* GetStepper() override
100 { 100 {
101 return fCurrDriver->GetStepper(); << 101 return fCurrDriver->GetStepper();
102 } 102 }
103 103
104 G4double ComputeNewStepSize(G4double errMa << 104 virtual G4double ComputeNewStepSize(G4double errMaxNorm,
105 G4double hstep << 105 G4double hstepCurrent) override
106 { 106 {
107 return fCurrDriver->ComputeNewStepSize(e << 107 return fCurrDriver->ComputeNewStepSize(errMaxNorm, hstepCurrent);
108 } 108 }
109 109
110 void SetVerboseLevel(G4int level) override << 110 virtual void SetVerboseLevel(G4int level) override
111 { 111 {
112 fSmallStepDriver->SetVerboseLevel(level) << 112 fSmallStepDriver->SetVerboseLevel(level);
113 fLargeStepDriver->SetVerboseLevel(level) << 113 fLargeStepDriver->SetVerboseLevel(level);
114 } 114 }
115 115
116 G4int GetVerboseLevel() const override << 116 virtual G4int GetVerboseLevel() const override
117 { 117 {
118 return fCurrDriver->GetVerboseLevel(); << 118 return fCurrDriver->GetVerboseLevel();
119 } 119 }
120 120
121 void OnComputeStep(const G4FieldTrack* tra << 121 virtual void OnComputeStep() override
122 { 122 {
123 fSmallStepDriver->OnComputeStep(track); << 123 fSmallStepDriver->OnComputeStep();
124 fLargeStepDriver->OnComputeStep(track); << 124 fLargeStepDriver->OnComputeStep();
125 } 125 }
126 126
127 void OnStartTracking() override << 127 virtual void OnStartTracking() override
128 { 128 {
129 fSmallStepDriver->OnStartTracking(); << 129 fSmallStepDriver->OnStartTracking();
130 fLargeStepDriver->OnStartTracking(); << 130 fLargeStepDriver->OnStartTracking();
131 } 131 }
132 132
133 void StreamInfo( std::ostream& os ) const <<
134 { <<
135 os << "Small Step Driver Info: " << std: <<
136 fSmallStepDriver->StreamInfo(os); <<
137 os << "Large Step Driver Info: " << std: <<
138 fLargeStepDriver->StreamInfo(os); <<
139 } <<
140 // Write out the parameters / state of the <<
141 <<
142 void PrintStatistics() const; 133 void PrintStatistics() const;
143 134
144 private: 135 private:
145 136
146 G4double CurvatureRadius(const G4FieldTrac 137 G4double CurvatureRadius(const G4FieldTrack& track) const;
147 138
148 void GetFieldValue(const G4FieldTrack& tra 139 void GetFieldValue(const G4FieldTrack& track,
149 G4double Fie 140 G4double Field[] ) const;
150 141
151 std::unique_ptr<G4VIntegrationDriver> fSma 142 std::unique_ptr<G4VIntegrationDriver> fSmallStepDriver;
152 std::unique_ptr<G4VIntegrationDriver> fLar 143 std::unique_ptr<G4VIntegrationDriver> fLargeStepDriver;
153 G4VIntegrationDriver* fCurrDriver = nullpt 144 G4VIntegrationDriver* fCurrDriver = nullptr;
154 G4Mag_EqRhs* fEquation = nullptr; 145 G4Mag_EqRhs* fEquation = nullptr;
155 146
156 G4int fSmallDriverSteps = 0; 147 G4int fSmallDriverSteps = 0;
157 G4int fLargeDriverSteps = 0; 148 G4int fLargeDriverSteps = 0;
158 }; 149 };
159 150
160 #endif 151 #endif
161 152