| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer << 3 // * DISCLAIMER *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th << 5 // * The following disclaimer summarizes all the specific disclaimers *
6 // * the Geant4 Collaboration. It is provided << 6 // * of contributors to this software. The specific disclaimers,which *
7 // * conditions of the Geant4 Software License << 7 // * govern, are listed with their locations in: *
8 // * LICENSE and available at http://cern.ch/ << 8 // * http://cern.ch/geant4/license *
9 // * include a list of copyright holders. <<
10 // * 9 // * *
11 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file << 14 // * use. *
16 // * for the full disclaimer and the limitatio <<
17 // * 15 // * *
18 // * This code implementation is the result << 16 // * This code implementation is the intellectual property of the *
19 // * technical work of the GEANT4 collaboratio << 17 // * GEANT4 collaboration. *
20 // * By using, copying, modifying or distri << 18 // * By copying, distributing or modifying the Program (or any work *
21 // * any work based on the software) you ag << 19 // * based on the Program) you indicate your acceptance of this *
22 // * use in resulting scientific publicati << 20 // * statement, and all its terms. *
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* 21 // ********************************************************************
25 // 22 //
26 // 23 //
27 // ------------------------------------------- 24 // -----------------------------------------------------------------------------
28 // GEANT 4 class implementation file 25 // GEANT 4 class implementation file
29 // 26 //
30 // History: first implementation, A. Feli 27 // History: first implementation, A. Feliciello, 30th June 1998
31 // ------------------------------------------- 28 // -----------------------------------------------------------------------------
32 29
33 #include "G4CollisionInitialState.hh" 30 #include "G4CollisionInitialState.hh"
34 #include "G4SystemOfUnits.hh" <<
35 #include "G4BCAction.hh" 31 #include "G4BCAction.hh"
36 // Class G4CollisionInitialState << 32 // Class G4CollisionInitialState
37 33
38 G4CollisionInitialState::G4CollisionInitialSta 34 G4CollisionInitialState::G4CollisionInitialState() :
39 theCollisionTime(DBL_MAX), thePrimary(0), t 35 theCollisionTime(DBL_MAX), thePrimary(0), theTarget(0), theFSGenerator(0)
40 { 36 {
41 } 37 }
42 38
43 39
44 G4CollisionInitialState::G4CollisionInitialSta << 40 G4CollisionInitialState::G4CollisionInitialState(G4double time,
45 G4KineticTrack * aPrimary, G4KineticTrack * 41 G4KineticTrack * aPrimary, G4KineticTrack * aTarget)
46 { 42 {
47 theCollisionTime = time; 43 theCollisionTime = time;
48 thePrimary = aPrimary; 44 thePrimary = aPrimary;
49 theTarget = aTarget; 45 theTarget = aTarget;
50 theTs.clear(); 46 theTs.clear();
51 theFSGenerator = 0; 47 theFSGenerator = 0;
52 } 48 }
53 49
54 // +new interface post pion: 50 // +new interface post pion:
55 G4CollisionInitialState::G4CollisionInitialSta << 51 G4CollisionInitialState::G4CollisionInitialState(G4double time,
56 G4KineticTrack * aPrimary, const G4KineticT 52 G4KineticTrack * aPrimary, const G4KineticTrackVector & aTarget,
57 G4BCAction * aFSGenerator) 53 G4BCAction * aFSGenerator)
58 { 54 {
59 theCollisionTime = time; 55 theCollisionTime = time;
60 thePrimary = aPrimary; 56 thePrimary = aPrimary;
61 theTarget = 0; 57 theTarget = 0;
62 for (size_t i=0; i<aTarget.size(); i++) the 58 for (size_t i=0; i<aTarget.size(); i++) theTs.push_back(aTarget[i]);
63 theFSGenerator = aFSGenerator; 59 theFSGenerator = aFSGenerator;
64 } 60 }
65 // -new interface post pion: 61 // -new interface post pion:
66 62
67 63
68 G4CollisionInitialState::G4CollisionInitialSta << 64 G4CollisionInitialState::G4CollisionInitialState(G4CollisionInitialState & right)
69 { 65 {
>> 66 if (this != &right)
>> 67 {
70 theCollisionTime = right.theCollisionTime 68 theCollisionTime = right.theCollisionTime;
71 thePrimary = right.thePrimary; 69 thePrimary = right.thePrimary;
72 theTarget = right.theTarget; 70 theTarget = right.theTarget;
73 for (size_t i=0; i<right.theTs.size(); i+ 71 for (size_t i=0; i<right.theTs.size(); i++) theTs.push_back(right.theTs[i]);
74 theFSGenerator = right.theFSGenerator; 72 theFSGenerator = right.theFSGenerator;
>> 73 }
75 } 74 }
76 75
77 G4CollisionInitialState & G4CollisionInitialSt << 76 const G4CollisionInitialState & G4CollisionInitialState::
>> 77 operator=(const G4CollisionInitialState& right)
78 { 78 {
79 if (this != &right) 79 if (this != &right)
80 { 80 {
81 theCollisionTime = right.theCollisionTim 81 theCollisionTime = right.theCollisionTime;
82 thePrimary = right.thePrimary; 82 thePrimary = right.thePrimary;
83 theTarget = right.theTarget; 83 theTarget = right.theTarget;
84 for (size_t i=0; i<right.theTs.size(); i 84 for (size_t i=0; i<right.theTs.size(); i++)
85 theTs.push_back(right.theTs[i]); 85 theTs.push_back(right.theTs[i]);
86 theFSGenerator = right.theFSGenerator; 86 theFSGenerator = right.theFSGenerator;
87 } 87 }
88 88
89 return *this; 89 return *this;
90 } 90 }
91 91
92 //#include <typeinfo> 92 //#include <typeinfo>
93 93
94 G4KineticTrackVector * G4CollisionInitialSta 94 G4KineticTrackVector * G4CollisionInitialState::
95 GetFinalState() 95 GetFinalState()
96 { 96 {
97 // G4cerr << "what is the FS generator? " 97 // G4cerr << "what is the FS generator? "
98 // << typeid(*theFSGenerator).name() 98 // << typeid(*theFSGenerator).name()
99 // <<G4endl; 99 // <<G4endl;
100 return theFSGenerator->GetFinalState(thePr 100 return theFSGenerator->GetFinalState(thePrimary, theTs);
101 } 101 }
102 102
103 //#include <typeinfo> <<
104 103
105 void G4CollisionInitialState::Print() const <<
106 { <<
107 G4int tgtPdg=theTarget ? <<
108 theTarget->GetDefinition()->GetPDGEncodin <<
109 G4cout << " collision " << this << " time: <<
110 << theCollisionTime/second << " proj: " <<
111 << thePrimary << "/pdg=" << thePrimary->G <<
112 << " tgt: " << theTarget << "/pdg=" << tg <<
113 << " Collision type: "<< typeid(*theFSGen <<
114 104
115 } <<
116 105
117 /* <<
118 std::ostream& G4CollisionInitialState::operato <<
119 { <<
120 G4int tgtPdg=collision.GetTarget() ? <<
121 collision.GetTarget()->GetDefinition()->Ge <<
122 out << " collision " << collision << " time <<
123 << collision.GetCollisionTime()/second << <<
124 << collision.GetPrimary() << "/pdg=" << co <<
125 << " tgt: " << collision.GetTarget() << "/ <<
126 << " Collision type: "<< typeid(*collision <<
127 106
128 return out; <<
129 } <<
130 */ <<
131 107