| Geant4 Cross Reference |
>> 1 // This code implementation is the intellectual property of
>> 2 // the GEANT4 collaboration.
1 // 3 //
2 // ******************************************* << 4 // By copying, distributing or modifying the Program (or any work
3 // * License and Disclaimer << 5 // based on the Program) you indicate your acceptance of this statement,
4 // * << 6 // and all its terms.
5 // * The Geant4 software is copyright of th <<
6 // * the Geant4 Collaboration. It is provided <<
7 // * conditions of the Geant4 Software License <<
8 // * LICENSE and available at http://cern.ch/ <<
9 // * include a list of copyright holders. <<
10 // * <<
11 // * Neither the authors of this software syst <<
12 // * institutes,nor the agencies providing fin <<
13 // * work make any representation or warran <<
14 // * regarding this software system or assum <<
15 // * use. Please see the license in the file <<
16 // * for the full disclaimer and the limitatio <<
17 // * <<
18 // * This code implementation is the result <<
19 // * technical work of the GEANT4 collaboratio <<
20 // * By using, copying, modifying or distri <<
21 // * any work based on the software) you ag <<
22 // * use in resulting scientific publicati <<
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* <<
25 // 7 //
26 // G4MagInt_Driver inline methods implementati << 8 // $Id: G4MagIntegratorDriver.icc,v 1.4 2000/04/27 09:14:06 gcosmo Exp $
>> 9 // GEANT4 tag $Name: geant4-02-00 $
27 // 10 //
28 // V.Grichine, 07.10.1996 - Created <<
29 // ------------------------------------------- <<
30 11
31 inline << 12 inline G4double G4MagInt_Driver::GetHmin()
32 G4double G4MagInt_Driver:: <<
33 AdvanceChordLimited(G4FieldTrack& track, G4dou <<
34 G4double epsStep, G4double <<
35 { 13 {
36 return ChordFinderDelegate::AdvanceChordLimi << 14 return hminimum_val;
37 <<
38 } <<
39 <<
40 inline <<
41 void G4MagInt_Driver::OnStartTracking() <<
42 { <<
43 ChordFinderDelegate::ResetStepEstimate(); <<
44 } <<
45 <<
46 inline <<
47 G4double G4MagInt_Driver::GetHmin() const <<
48 { <<
49 return fMinimumStep; <<
50 } 15 }
51 16
52 inline << 17 inline G4double G4MagInt_Driver::Hmin()
53 G4double G4MagInt_Driver::Hmin() const <<
54 { 18 {
55 return fMinimumStep; << 19 return hminimum_val;
56 } 20 }
57 21
58 inline << 22 inline G4double G4MagInt_Driver::GetSafety()
59 G4double G4MagInt_Driver::GetSafety() const <<
60 { 23 {
61 return safety; << 24 return safety;
62 } 25 }
63 26
64 inline << 27 inline G4double G4MagInt_Driver::GetPshrnk()
65 G4double G4MagInt_Driver::GetPshrnk() const <<
66 { 28 {
67 return pshrnk; << 29 return pshrnk;
68 } 30 }
69 31
70 inline << 32 inline G4double G4MagInt_Driver::GetPgrow()
71 G4double G4MagInt_Driver::GetPgrow() const <<
72 { 33 {
73 return pgrow; << 34 return pgrow;
74 } 35 }
75 36
76 inline << 37 inline G4double G4MagInt_Driver::GetErrcon()
77 G4double G4MagInt_Driver::GetErrcon() const <<
78 { 38 {
79 return errcon; << 39 return errcon;
80 } 40 }
81 41
82 inline << 42 inline G4double G4MagInt_Driver::SetHmin(G4double newval)
83 void G4MagInt_Driver::SetHmin(G4double newval) <<
84 { 43 {
85 fMinimumStep = newval; << 44 return hminimum_val;
86 } 45 }
87 46
88 inline << 47 inline G4double G4MagInt_Driver::ComputeAndSetErrcon()
89 G4double G4MagInt_Driver::ComputeAndSetErrcon( <<
90 { 48 {
91 errcon = std::pow(max_stepping_increase/GetS << 49 errcon = pow(max_stepping_increase/GetSafety(),1.0/GetPgrow());
92 return errcon; << 50 return errcon;
93 } 51 }
94 52
95 inline << 53 inline void G4MagInt_Driver::ReSetParameters( G4double new_safety )
96 void G4MagInt_Driver::ReSetParameters(G4double <<
97 { 54 {
98 safety = new_safety; << 55 safety = new_safety;
99 pshrnk = -1.0 / pIntStepper->IntegratorOrder << 56 pshrnk = -1.0 / pIntStepper->IntegratorOrder();
100 pgrow = -1.0 / (1.0 + pIntStepper->Integrat << 57 pgrow = -1.0 / (1.0 + pIntStepper->IntegratorOrder());
101 ComputeAndSetErrcon(); << 58 ComputeAndSetErrcon();
102 } 59 }
103 60
104 inline << 61 inline void G4MagInt_Driver::SetSafety(G4double val)
105 void G4MagInt_Driver::SetSafety(G4double val) <<
106 { 62 {
107 safety = val; << 63 safety=val;
108 ComputeAndSetErrcon(); << 64 ComputeAndSetErrcon();
109 } 65 }
110 66
111 inline << 67 inline void G4MagInt_Driver::SetPgrow(G4double val)
112 void G4MagInt_Driver::SetPgrow(G4double val) <<
113 { 68 {
114 pgrow = val; << 69 pgrow=val;
115 ComputeAndSetErrcon(); << 70 ComputeAndSetErrcon();
116 } 71 }
117 72
118 inline << 73 inline void G4MagInt_Driver::SetErrcon(G4double val)
119 void G4MagInt_Driver::SetErrcon(G4double val) <<
120 { 74 {
121 errcon = val; << 75 errcon=val;
122 } 76 }
123 77
124 inline << 78 inline void G4MagInt_Driver::RenewStepperAndAdjust(G4MagIntegratorStepper *pItsStepper)
125 G4int G4MagInt_Driver::GetMaxNoSteps() const << 79 {
126 { << 80 pIntStepper = pItsStepper;
127 return fMaxNoSteps; << 81 ReSetParameters();
128 } 82 }
129 83
130 inline << 84 inline void G4MagInt_Driver:: SetChargeMomentumMass(
131 void G4MagInt_Driver::SetMaxNoSteps(G4int val) << 85 const G4double particleCharge, // in e+ units
132 { << 86 const G4double MomentumXc,
133 fMaxNoSteps = val; << 87 const G4double Mass )
>> 88 {
>> 89 pIntStepper->GetEquationOfMotion()
>> 90 ->SetChargeMomentumMass(particleCharge, MomentumXc, Mass);
134 } 91 }
135 92
136 inline << 93 // Constructor
137 G4int G4MagInt_Driver::GetVerboseLevel() const << 94 //
138 { << 95 inline G4MagInt_Driver::G4MagInt_Driver( G4double hminimum,
139 return fVerboseLevel; << 96 G4MagIntegratorStepper *pItsStepper,
140 } << 97 G4int numComponents)
141 << 98 : nvar(numComponents)
142 inline << 99 {
143 void G4MagInt_Driver::SetVerboseLevel(G4int ne << 100 RenewStepperAndAdjust( pItsStepper );
144 { << 101 hminimum_val= hminimum;
145 fVerboseLevel = newLevel; << 102 fMaxNoSteps = fMaxStepBase / pIntStepper->IntegratorOrder();
>> 103 }
>> 104
>> 105 inline G4MagIntegratorStepper* G4MagInt_Driver::GetStepper()
>> 106 { return pIntStepper; }
>> 107
>> 108 inline G4int G4MagInt_Driver::GetMaxNoSteps()
>> 109 { return fMaxNoSteps; }
>> 110
>> 111 inline void G4MagInt_Driver::SetMaxNoSteps(G4int val)
>> 112 { fMaxNoSteps= val; }
>> 113
>> 114 inline void G4MagInt_Driver::GetDerivatives(
>> 115 const G4FieldTrack y_curr, // const, INput
>> 116 G4double dydx[] ) // OUTput
>> 117 {
>> 118 G4double tmpValArr[G4FieldTrack::ncompSVEC];
>> 119 y_curr.DumpToArray( tmpValArr );
>> 120 pIntStepper -> RightHandSide( tmpValArr , dydx );
>> 121
146 } 122 }
147 123
148 inline <<
149 G4double G4MagInt_Driver::GetSmallestFraction( <<
150 { <<
151 return fSmallestFraction; <<
152 } <<
153 124