| 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 // G4VTrajectory class implementation << 23 //
>> 24 // $Id: G4VTrajectory.cc,v 1.7 2005/05/03 17:48:51 allison Exp $
>> 25 // GEANT4 tag $Name: geant4-07-01 $
>> 26 //
>> 27 //
>> 28 // ---------------------------------------------------------------
>> 29 //
>> 30 // G4VTrajectory.cc
27 // 31 //
28 // Contact: 32 // Contact:
29 // Questions and comments to this code shoul 33 // Questions and comments to this code should be sent to
30 // Katsuya Amako (e-mail: Katsuya.Amako@k 34 // Katsuya Amako (e-mail: Katsuya.Amako@kek.jp)
31 // Makoto Asai (e-mail: asai@slac.stanf << 35 // Makoto Asai (e-mail: asai@kekvax.kek.jp)
32 // Takashi Sasaki (e-mail: Takashi.Sasaki@ 36 // Takashi Sasaki (e-mail: Takashi.Sasaki@kek.jp)
33 // ------------------------------------------- << 37 //
>> 38 // ---------------------------------------------------------------
34 39
35 #include "G4VTrajectory.hh" 40 #include "G4VTrajectory.hh"
36 << 41 #include "G4VTrajectoryPoint.hh"
37 #include "G4AttCheck.hh" <<
38 #include "G4AttDef.hh" <<
39 #include "G4AttDefStore.hh" 42 #include "G4AttDefStore.hh"
>> 43 #include "G4AttDef.hh"
40 #include "G4AttValue.hh" 44 #include "G4AttValue.hh"
41 #include "G4Colour.hh" << 45 #include "G4AttCheck.hh"
42 #include "G4Polyline.hh" <<
43 #include "G4Polymarker.hh" <<
44 #include "G4VTrajectoryPoint.hh" <<
45 #include "G4VVisManager.hh" 46 #include "G4VVisManager.hh"
46 #include "G4VisAttributes.hh" 47 #include "G4VisAttributes.hh"
>> 48 #include "G4Polyline.hh"
>> 49 #include "G4Polymarker.hh"
>> 50 #include "G4Colour.hh"
47 51
48 G4bool G4VTrajectory::operator==(const G4VTraj << 52 G4VTrajectory::G4VTrajectory() {;}
>> 53 G4VTrajectory::~G4VTrajectory() {;}
49 54
50 G4VTrajectory* G4VTrajectory::CloneForMaster() << 55 G4bool G4VTrajectory::operator == (const G4VTrajectory& right) const
51 { 56 {
52 // Base-class method must not be invoked. << 57 return (this==&right);
53 // Each concrete class should implement its <<
54 G4Exception("G4VTrajectory::CloneForMaster( <<
55 "CloneForMaster() of G4VTrajectory base-c <<
56 return nullptr; <<
57 } 58 }
58 59
59 void G4VTrajectory::ShowTrajectory(std::ostrea 60 void G4VTrajectory::ShowTrajectory(std::ostream& os) const
60 { 61 {
61 // Makes use of attribute values implemented 62 // Makes use of attribute values implemented in the concrete class.
62 // Note: the user needs to follow with new-l 63 // Note: the user needs to follow with new-line or end-of-string,
63 // depending on the nature of os << 64 // depending on the nature of os.
64 65
65 std::vector<G4AttValue>* attValues = CreateA 66 std::vector<G4AttValue>* attValues = CreateAttValues();
66 const std::map<G4String, G4AttDef>* attDefs << 67 const std::map<G4String,G4AttDef>* attDefs = GetAttDefs();
67 68
68 // Ensure validity... 69 // Ensure validity...
69 // << 70 if (G4AttCheck(attValues,attDefs).Check("G4VTrajectory::ShowTrajectory")) {
70 if (G4AttCheck(attValues, attDefs).Check("G4 <<
71 return; 71 return;
72 } 72 }
73 73
74 os << "Trajectory:"; 74 os << "Trajectory:";
75 75
76 for (const auto& attValue : *attValues) { << 76 std::vector<G4AttValue>::iterator iAttVal;
77 auto iAttDef = attDefs->find(attValue.GetN << 77 for (iAttVal = attValues->begin();
78 os << "\n " << iAttDef->second.GetDesc() << 78 iAttVal != attValues->end(); ++iAttVal) {
79 << "): " << attValue.GetValue(); << 79 std::map<G4String,G4AttDef>::const_iterator iAttDef =
>> 80 attDefs->find(iAttVal->GetName());
>> 81 os << "\n " << iAttDef->second.GetDesc() << ": "
>> 82 << iAttVal->GetValue();
80 } 83 }
81 84
82 delete attValues; // AttValues must be dele 85 delete attValues; // AttValues must be deleted after use.
83 86
84 // Now do trajectory points... << 87 //Now do trajectory points...
>> 88 for (G4int i = 0; i < GetPointEntries(); i++) {
85 89
86 for (G4int i = 0; i < GetPointEntries(); ++i <<
87 G4VTrajectoryPoint* aTrajectoryPoint = Get 90 G4VTrajectoryPoint* aTrajectoryPoint = GetPoint(i);
88 attValues = aTrajectoryPoint->CreateAttVal << 91 std::vector<G4AttValue>* attValues
89 attDefs = aTrajectoryPoint->GetAttDefs(); << 92 = aTrajectoryPoint->CreateAttValues();
>> 93 const std::map<G4String,G4AttDef>* attDefs
>> 94 = aTrajectoryPoint->GetAttDefs();
90 95
91 // Ensure validity... 96 // Ensure validity...
92 // << 97 if (G4AttCheck(attValues,attDefs).Check("G4VTrajectory::ShowTrajectory")) {
93 if (G4AttCheck(attValues, attDefs).Check(" <<
94 return; 98 return;
95 } 99 }
96 100
97 for (const auto& attValue : *attValues) { << 101 std::vector<G4AttValue>::iterator iAttVal;
98 const auto iAttDef = attDefs->find(attVa << 102 for (iAttVal = attValues->begin();
99 os << "\n " << iAttDef->second.GetDes << 103 iAttVal != attValues->end(); ++iAttVal) {
100 << "): " << attValue.GetValue(); << 104 std::map<G4String,G4AttDef>::const_iterator iAttDef =
>> 105 attDefs->find(iAttVal->GetName());
>> 106 os << "\n " << iAttDef->second.GetDesc() << ": "
>> 107 << iAttVal->GetValue();
101 } 108 }
102 109
103 delete attValues; // AttValues must be de 110 delete attValues; // AttValues must be deleted after use.
104 } 111 }
105 os << std::endl; <<
106 } 112 }
107 113
108 void G4VTrajectory::DrawTrajectory() const << 114 void G4VTrajectory::DrawTrajectory(G4int i_mode) const
109 { 115 {
>> 116 // If i_mode>=0, draws a trajectory as a polyline (blue for
>> 117 // positive, red for negative, green for neutral) and, if i_mode!=0,
>> 118 // adds markers - yellow circles for step points and magenta squares
>> 119 // for auxiliary points, if any - whose screen size in pixels is
>> 120 // given by std::abs(i_mode)/1000. E.g: i_mode = 5000 gives easily
>> 121 // visible markers.
>> 122
110 G4VVisManager* pVVisManager = G4VVisManager: 123 G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
>> 124 if (!pVVisManager) return;
>> 125
>> 126 const G4double markerSize = std::abs(i_mode)/1000;
>> 127 G4bool lineRequired (i_mode >= 0);
>> 128 G4bool markersRequired (markerSize > 0.);
>> 129
>> 130 G4Polyline trajectoryLine;
>> 131 G4Polymarker stepPoints;
>> 132 G4Polymarker auxiliaryPoints;
111 133
112 if (pVVisManager != nullptr) { << 134 for (G4int i = 0; i < GetPointEntries() ; i++) {
113 pVVisManager->DispatchToModel(*this); << 135 G4VTrajectoryPoint* aTrajectoryPoint = GetPoint(i);
>> 136 const std::vector<G4ThreeVector>* auxiliaries
>> 137 = aTrajectoryPoint->GetAuxiliaryPoints();
>> 138 if (auxiliaries) {
>> 139 for (size_t iAux = 0; iAux < auxiliaries->size(); ++iAux) {
>> 140 const G4ThreeVector pos((*auxiliaries)[iAux]);
>> 141 if (lineRequired) {
>> 142 trajectoryLine.push_back(pos);
>> 143 }
>> 144 if (markersRequired) {
>> 145 auxiliaryPoints.push_back(pos);
>> 146 }
>> 147 }
>> 148 }
>> 149 const G4ThreeVector pos(aTrajectoryPoint->GetPosition());
>> 150 if (lineRequired) {
>> 151 trajectoryLine.push_back(pos);
>> 152 }
>> 153 if (markersRequired) {
>> 154 stepPoints.push_back(pos);
>> 155 }
>> 156 }
>> 157
>> 158 if (lineRequired) {
>> 159 G4Colour colour;
>> 160 const G4double charge = GetCharge();
>> 161 if(charge>0.) colour = G4Colour(0.,0.,1.); // Blue = positive.
>> 162 else if(charge<0.) colour = G4Colour(1.,0.,0.); // Red = negative.
>> 163 else colour = G4Colour(0.,1.,0.); // Green = neutral.
>> 164 G4VisAttributes trajectoryLineAttribs(colour);
>> 165 trajectoryLine.SetVisAttributes(&trajectoryLineAttribs);
>> 166 pVVisManager->Draw(trajectoryLine);
>> 167 }
>> 168 if (markersRequired) {
>> 169 auxiliaryPoints.SetMarkerType(G4Polymarker::squares);
>> 170 auxiliaryPoints.SetScreenSize(markerSize);
>> 171 auxiliaryPoints.SetFillStyle(G4VMarker::filled);
>> 172 G4VisAttributes auxiliaryPointsAttribs(G4Colour(0.,1.,1.)); // Magenta
>> 173 auxiliaryPoints.SetVisAttributes(&auxiliaryPointsAttribs);
>> 174 pVVisManager->Draw(auxiliaryPoints);
>> 175
>> 176 stepPoints.SetMarkerType(G4Polymarker::circles);
>> 177 stepPoints.SetScreenSize(markerSize);
>> 178 stepPoints.SetFillStyle(G4VMarker::filled);
>> 179 G4VisAttributes stepPointsAttribs(G4Colour(1.,1.,0.)); // Yellow.
>> 180 stepPoints.SetVisAttributes(&stepPointsAttribs);
>> 181 pVVisManager->Draw(stepPoints);
114 } 182 }
115 } 183 }
116 184