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 // G4ScoringBox << 26 // 27 // ------------------------------------------- << 27 // $Id: G4ScoringBox.cc 89027 2015-03-18 08:37:30Z gcosmo $ >> 28 // 28 29 29 #include "G4ScoringBox.hh" 30 #include "G4ScoringBox.hh" 30 31 >> 32 #include "G4SystemOfUnits.hh" 31 #include "G4Box.hh" 33 #include "G4Box.hh" 32 #include "G4LogicalVolume.hh" 34 #include "G4LogicalVolume.hh" 33 #include "G4VPhysicalVolume.hh" 35 #include "G4VPhysicalVolume.hh" 34 #include "G4PVPlacement.hh" 36 #include "G4PVPlacement.hh" 35 #include "G4PVReplica.hh" 37 #include "G4PVReplica.hh" 36 #include "G4PVDivision.hh" 38 #include "G4PVDivision.hh" 37 #include "G4VisAttributes.hh" 39 #include "G4VisAttributes.hh" 38 #include "G4VVisManager.hh" 40 #include "G4VVisManager.hh" 39 #include "G4VScoreColorMap.hh" 41 #include "G4VScoreColorMap.hh" 40 42 41 #include "G4MultiFunctionalDetector.hh" 43 #include "G4MultiFunctionalDetector.hh" >> 44 #include "G4SDParticleFilter.hh" 42 #include "G4VPrimitiveScorer.hh" 45 #include "G4VPrimitiveScorer.hh" 43 #include "G4Polyhedron.hh" 46 #include "G4Polyhedron.hh" 44 47 45 #include "G4ScoringManager.hh" 48 #include "G4ScoringManager.hh" 46 #include "G4StatDouble.hh" << 47 << 48 #include "G4SystemOfUnits.hh" << 49 49 50 #include <map> 50 #include <map> 51 #include <fstream> 51 #include <fstream> 52 52 53 G4ScoringBox::G4ScoringBox(const G4String& wNa << 53 G4ScoringBox::G4ScoringBox(G4String wName) 54 : G4VScoringMesh(wName) << 54 :G4VScoringMesh(wName), fSegmentDirection(-1) 55 , fSegmentDirection(-1) << 56 { 55 { 57 fShape = MeshShape::box; << 56 fShape = boxMesh; 58 fDivisionAxisNames[0] = "X"; 57 fDivisionAxisNames[0] = "X"; 59 fDivisionAxisNames[1] = "Y"; 58 fDivisionAxisNames[1] = "Y"; 60 fDivisionAxisNames[2] = "Z"; 59 fDivisionAxisNames[2] = "Z"; 61 } 60 } 62 61 63 void G4ScoringBox::SetupGeometry(G4VPhysicalVo << 62 G4ScoringBox::~G4ScoringBox() 64 { 63 { 65 if(verboseLevel > 9) << 64 } 66 G4cout << "G4ScoringBox::SetupGeometry() . << 67 65 >> 66 void G4ScoringBox::SetupGeometry(G4VPhysicalVolume * fWorldPhys) { >> 67 >> 68 if(verboseLevel > 9) G4cout << "G4ScoringBox::SetupGeometry() ..." << G4endl; >> 69 68 // World 70 // World 69 G4VPhysicalVolume* scoringWorld = fWorldPhys << 71 G4VPhysicalVolume * scoringWorld = fWorldPhys; 70 G4LogicalVolume* worldLogical = scoringWor << 72 G4LogicalVolume * worldLogical = scoringWorld->GetLogicalVolume(); 71 << 73 72 // Scoring Mesh 74 // Scoring Mesh 73 if(verboseLevel > 9) << 75 if(verboseLevel > 9) G4cout << fWorldName << G4endl; 74 G4cout << fWorldName << G4endl; << 75 G4String boxName = fWorldName; 76 G4String boxName = fWorldName; 76 << 77 77 if(verboseLevel > 9) 78 if(verboseLevel > 9) 78 G4cout << fSize[0] << ", " << fSize[1] << 79 G4cout << fSize[0] << ", " << fSize[1] << ", " << fSize[2] << G4endl; 79 G4VSolid* boxSolid = new G4Box(boxName + "0" << 80 G4VSolid * boxSolid = new G4Box(boxName+"0", fSize[0], fSize[1], fSize[2]); 80 auto boxLogical = << 81 G4LogicalVolume * boxLogical = new G4LogicalVolume(boxSolid, 0, boxName+"_0"); 81 new G4LogicalVolume(boxSolid, nullptr, box << 82 new G4PVPlacement(fRotationMatrix, fCenterPosition, 82 new G4PVPlacement(fRotationMatrix, fCenterPo << 83 boxLogical, boxName+"0", worldLogical, false, 0); 83 worldLogical, false, 0); << 84 84 << 85 //G4double fsegment[3][3]; 85 G4String layerName[2] = { boxName + "_1", bo << 86 //G4int segOrder[3]; 86 G4VSolid* layerSolid[2]; << 87 //GetSegmentOrder(fSegmentDirection, fNSegment, segOrder, fsegment); 87 G4LogicalVolume* layerLogical[2]; << 88 //EAxis axis[3] = {kXAxis, kYAxis, kZAxis}; 88 << 89 >> 90 G4String layerName[2] = {boxName + "_1", boxName + "_2"}; >> 91 G4VSolid * layerSolid[2]; >> 92 G4LogicalVolume * layerLogical[2]; >> 93 89 //-- fisrt nested layer (replicated to x dir 94 //-- fisrt nested layer (replicated to x direction) 90 if(verboseLevel > 9) << 95 if(verboseLevel > 9) G4cout << "layer 1 :" << G4endl; 91 G4cout << "layer 1 :" << G4endl; << 96 layerSolid[0] = new G4Box(layerName[0], 92 layerSolid[0] = << 97 fSize[0]/fNSegment[0], 93 new G4Box(layerName[0], fSize[0] / fNSegme << 98 fSize[1], 94 layerLogical[0] = new G4LogicalVolume(layerS << 99 fSize[2]); 95 if(fNSegment[0] > 1) << 100 layerLogical[0] = new G4LogicalVolume(layerSolid[0], 0, layerName[0]); 96 { << 101 if(fNSegment[0] > 1) { 97 if(verboseLevel > 9) 102 if(verboseLevel > 9) 98 G4cout << "G4ScoringBox::Construct() : R << 103 G4cout << "G4ScoringBox::Construct() : Replicate to x direction" << G4endl; 99 << G4endl; << 104 if(G4ScoringManager::GetReplicaLevel()>0) 100 if(G4ScoringManager::GetReplicaLevel() > 0 << 101 { 105 { 102 new G4PVReplica(layerName[0], layerLogic 106 new G4PVReplica(layerName[0], layerLogical[0], boxLogical, kXAxis, 103 fNSegment[0], fSize[0] / << 107 fNSegment[0], fSize[0]/fNSegment[0]*2.); 104 } 108 } 105 else 109 else 106 { 110 { 107 new G4PVDivision(layerName[0], layerLogi 111 new G4PVDivision(layerName[0], layerLogical[0], boxLogical, kXAxis, 108 fNSegment[0], 0.); 112 fNSegment[0], 0.); 109 } 113 } 110 } << 114 } else if(fNSegment[0] == 1) { 111 else if(fNSegment[0] == 1) << 112 { << 113 if(verboseLevel > 9) 115 if(verboseLevel > 9) 114 G4cout << "G4ScoringBox::Construct() : P 116 G4cout << "G4ScoringBox::Construct() : Placement" << G4endl; 115 new G4PVPlacement(nullptr, G4ThreeVector(0 << 117 new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), layerLogical[0], layerName[0], 116 layerName[0], boxLogical << 118 boxLogical, false, 0); 117 } << 119 } else 118 else << 119 G4cerr << "ERROR : G4ScoringBox::SetupGeom 120 G4cerr << "ERROR : G4ScoringBox::SetupGeometry() : invalid parameter (" 120 << fNSegment[0] << ") " << 121 << fNSegment[0] << ") " 121 << "in placement of the first neste << 122 << "in placement of the first nested layer." << G4endl; 122 << 123 123 if(verboseLevel > 9) << 124 if(verboseLevel > 9) { 124 { << 125 G4cout << fSize[0]/fNSegment[0] << ", " 125 G4cout << fSize[0] / fNSegment[0] << ", " << 126 << fSize[1] << ", " 126 << G4endl; << 127 << fSize[2] << G4endl; 127 G4cout << layerName[0] << ": kXAxis, " << << 128 G4cout << layerName[0] << ": kXAxis, " 128 << 2. * fSize[0] / fNSegment[0] << << 129 << fNSegment[0] << ", " >> 130 << 2.*fSize[0]/fNSegment[0] << G4endl; 129 } 131 } 130 << 132 131 // second nested layer (replicated to y dire 133 // second nested layer (replicated to y direction) 132 if(verboseLevel > 9) << 134 if(verboseLevel > 9) G4cout << "layer 2 :" << G4endl; 133 G4cout << "layer 2 :" << G4endl; << 135 layerSolid[1] = new G4Box(layerName[1], 134 layerSolid[1] = new G4Box(layerName[1], fS << 136 fSize[0]/fNSegment[0], 135 fSize[1] / fNSegme << 137 fSize[1]/fNSegment[1], 136 layerLogical[1] = new G4LogicalVolume(layerS << 138 fSize[2]); 137 if(fNSegment[1] > 1) << 139 layerLogical[1] = new G4LogicalVolume(layerSolid[1], 0, layerName[1]); 138 { << 140 if(fNSegment[1] > 1) { 139 if(verboseLevel > 9) 141 if(verboseLevel > 9) 140 G4cout << "G4ScoringBox::Construct() : R << 142 G4cout << "G4ScoringBox::Construct() : Replicate to y direction" << G4endl; 141 << G4endl; << 143 if(G4ScoringManager::GetReplicaLevel()>1) 142 if(G4ScoringManager::GetReplicaLevel() > 1 << 143 { 144 { 144 new G4PVReplica(layerName[1], layerLogic 145 new G4PVReplica(layerName[1], layerLogical[1], layerLogical[0], kYAxis, 145 fNSegment[1], fSize[1] / << 146 fNSegment[1], fSize[1]/fNSegment[1]*2.); 146 } 147 } 147 else 148 else 148 { 149 { 149 new G4PVDivision(layerName[1], layerLogi 150 new G4PVDivision(layerName[1], layerLogical[1], layerLogical[0], kYAxis, 150 fNSegment[1], 0.); 151 fNSegment[1], 0.); 151 } 152 } 152 } << 153 } else if(fNSegment[1] == 1) { 153 else if(fNSegment[1] == 1) << 154 { << 155 if(verboseLevel > 9) 154 if(verboseLevel > 9) 156 G4cout << "G4ScoringBox::Construct() : P 155 G4cout << "G4ScoringBox::Construct() : Placement" << G4endl; 157 new G4PVPlacement(nullptr, G4ThreeVector(0 << 156 new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), layerLogical[1], layerName[1], 158 layerName[1], layerLogic << 157 layerLogical[0], false, 0); 159 } << 158 } else 160 else << 161 G4cerr << "ERROR : G4ScoringBox::SetupGeom 159 G4cerr << "ERROR : G4ScoringBox::SetupGeometry() : invalid parameter (" 162 << fNSegment[1] << ") " << 160 << fNSegment[1] << ") " 163 << "in placement of the second nest << 161 << "in placement of the second nested layer." << G4endl; 164 << 162 165 if(verboseLevel > 9) << 163 if(verboseLevel > 9) { 166 { << 164 G4cout << fSize[0]/fNSegment[0] << ", " 167 G4cout << fSize[0] / fNSegment[0] << ", " << 165 << fSize[1]/fNSegment[1] << ", " 168 << fSize[2] << G4endl; << 166 << fSize[2] << G4endl; 169 G4cout << layerName[1] << ": kYAxis, " << << 167 G4cout << layerName[1] << ": kYAxis, " 170 << 2. * fSize[1] / fNSegment[1] << << 168 << fNSegment[1] << ", " >> 169 << 2.*fSize[1]/fNSegment[1] << G4endl; 171 } 170 } 172 << 171 173 // mesh elements (replicated to z direction) 172 // mesh elements (replicated to z direction) 174 if(verboseLevel > 9) << 173 if(verboseLevel > 9) G4cout << "mesh elements :" << G4endl; 175 G4cout << "mesh elements :" << G4endl; << 174 G4String elementName = boxName +"_3"; 176 G4String elementName = boxName + "_3"; << 175 G4VSolid * elementSolid = new G4Box(elementName, 177 G4VSolid* elementSolid = << 176 fSize[0]/fNSegment[0], 178 new G4Box(elementName, fSize[0] / fNSegmen << 177 fSize[1]/fNSegment[1], 179 fSize[2] / fNSegment[2]); << 178 fSize[2]/fNSegment[2]); 180 fMeshElementLogical = new G4LogicalVolume(el << 179 fMeshElementLogical = new G4LogicalVolume(elementSolid, 0, elementName); 181 if(fNSegment[2] > 1) << 180 if(fNSegment[2] > 1) { 182 { << 183 if(verboseLevel > 9) 181 if(verboseLevel > 9) 184 G4cout << "G4ScoringBox::Construct() : R << 182 G4cout << "G4ScoringBox::Construct() : Replicate to z direction" << G4endl; 185 << G4endl; << 183 186 << 184 if(G4ScoringManager::GetReplicaLevel()>2) 187 if(G4ScoringManager::GetReplicaLevel() > 2 << 188 { 185 { 189 new G4PVReplica(elementName, fMeshElemen 186 new G4PVReplica(elementName, fMeshElementLogical, layerLogical[1], kZAxis, 190 fNSegment[2], 2. * fSize << 187 fNSegment[2], 2.*fSize[2]/fNSegment[2]); 191 } 188 } 192 else 189 else 193 { 190 { 194 new G4PVDivision(elementName, fMeshEleme << 191 new G4PVDivision(elementName, fMeshElementLogical, layerLogical[1], kZAxis, 195 kZAxis, fNSegment[2], 0 << 192 fNSegment[2], 0.); 196 } 193 } 197 } << 194 } else if(fNSegment[2] == 1) { 198 else if(fNSegment[2] == 1) << 199 { << 200 if(verboseLevel > 9) 195 if(verboseLevel > 9) 201 G4cout << "G4ScoringBox::Construct() : P 196 G4cout << "G4ScoringBox::Construct() : Placement" << G4endl; 202 new G4PVPlacement(nullptr, G4ThreeVector(0 << 197 new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), fMeshElementLogical, 203 elementName, layerLogica 198 elementName, layerLogical[1], false, 0); 204 } << 199 } else 205 else << 206 G4cerr << "ERROR : G4ScoringBox::SetupGeom 200 G4cerr << "ERROR : G4ScoringBox::SetupGeometry() : " 207 << "invalid parameter (" << fNSegme << 201 << "invalid parameter (" << fNSegment[2] << ") " 208 << "in mesh element placement." << << 202 << "in mesh element placement." << G4endl; 209 << 203 210 if(verboseLevel > 9) << 204 if(verboseLevel > 9) { 211 { << 205 G4cout << fSize[0]/fNSegment[0] << ", " 212 G4cout << fSize[0] / fNSegment[0] << ", " << 206 << fSize[1]/fNSegment[1] << ", " 213 << fSize[2] / fNSegment[2] << G4end << 207 << fSize[2]/fNSegment[2] << G4endl; 214 G4cout << elementName << ": kZAxis, " << f << 208 G4cout << elementName << ": kZAxis, " 215 << 2. * fSize[2] / fNSegment[2] << << 209 << fNSegment[2] << ", " >> 210 << 2.*fSize[2]/fNSegment[2] << G4endl; 216 } 211 } 217 << 212 >> 213 218 // set the sensitive detector 214 // set the sensitive detector 219 fMeshElementLogical->SetSensitiveDetector(fM 215 fMeshElementLogical->SetSensitiveDetector(fMFD); 220 << 216 >> 217 221 // vis. attributes 218 // vis. attributes 222 auto visatt = new G4VisAttributes(G4Colour( << 219 G4VisAttributes * visatt = new G4VisAttributes(G4Colour(.5,.5,.5)); 223 visatt->SetVisibility(false); 220 visatt->SetVisibility(false); 224 layerLogical[0]->SetVisAttributes(visatt); 221 layerLogical[0]->SetVisAttributes(visatt); 225 layerLogical[1]->SetVisAttributes(visatt); 222 layerLogical[1]->SetVisAttributes(visatt); 226 visatt->SetVisibility(true); 223 visatt->SetVisibility(true); 227 fMeshElementLogical->SetVisAttributes(visatt 224 fMeshElementLogical->SetVisAttributes(visatt); 228 } 225 } 229 226 230 void G4ScoringBox::List() const << 231 { << 232 G4cout << "G4ScoringBox : " << fWorldName << << 233 G4cout << " Size (x, y, z): (" << fSize[0] / << 234 << ", " << fSize[2] / cm << ") [cm]" << 235 227 >> 228 void G4ScoringBox::List() const { >> 229 G4cout << "G4ScoringBox : " << fWorldName << " --- Shape: Box mesh" << G4endl; >> 230 G4cout << " Size (x, y, z): (" >> 231 << fSize[0]/cm << ", " >> 232 << fSize[1]/cm << ", " >> 233 << fSize[2]/cm << ") [cm]" >> 234 << G4endl; >> 235 236 G4VScoringMesh::List(); 236 G4VScoringMesh::List(); 237 } 237 } 238 238 239 void G4ScoringBox::Draw(RunScore* map, G4VScor << 239 void G4ScoringBox::Draw(std::map<G4int, G4double*> * map, 240 { << 240 G4VScoreColorMap* colorMap, G4int axflg) { 241 G4VVisManager* pVisManager = G4VVisManager:: << 241 242 if(pVisManager != nullptr) << 242 G4VVisManager * pVisManager = G4VVisManager::GetConcreteInstance(); 243 { << 243 if(pVisManager) { 244 // cell vectors << 245 std::vector<std::vector<std::vector<G4doub << 246 std::vector<G4double> ez; << 247 for(G4int z = 0; z < fNSegment[2]; z++) << 248 ez.push_back(0.); << 249 std::vector<std::vector<G4double>> eyz; << 250 for(G4int y = 0; y < fNSegment[1]; y++) << 251 eyz.push_back(ez); << 252 for(G4int x = 0; x < fNSegment[0]; x++) << 253 cell.push_back(eyz); << 254 << 255 std::vector<std::vector<G4double>> xycell; << 256 std::vector<G4double> ey; << 257 for(G4int y = 0; y < fNSegment[1]; y++) << 258 ey.push_back(0.); << 259 for(G4int x = 0; x < fNSegment[0]; x++) << 260 xycell.push_back(ey); << 261 << 262 std::vector<std::vector<G4double>> yzcell; << 263 for(G4int y = 0; y < fNSegment[1]; y++) << 264 yzcell.push_back(ez); << 265 << 266 std::vector<std::vector<G4double>> xzcell; << 267 for(G4int x = 0; x < fNSegment[0]; x++) << 268 xzcell.push_back(ez); << 269 244 >> 245 // cell vectors >> 246 std::vector<std::vector<std::vector<double> > > cell; // cell[X][Y][Z] >> 247 std::vector<double> ez; >> 248 for(int z = 0; z < fNSegment[2]; z++) ez.push_back(0.); >> 249 std::vector<std::vector<double> > eyz; >> 250 for(int y = 0; y < fNSegment[1]; y++) eyz.push_back(ez); >> 251 for(int x = 0; x < fNSegment[0]; x++) cell.push_back(eyz); >> 252 >> 253 std::vector<std::vector<double> > xycell; // xycell[X][Y] >> 254 std::vector<double> ey; >> 255 for(int y = 0; y < fNSegment[1]; y++) ey.push_back(0.); >> 256 for(int x = 0; x < fNSegment[0]; x++) xycell.push_back(ey); >> 257 >> 258 std::vector<std::vector<double> > yzcell; // yzcell[Y][Z] >> 259 for(int y = 0; y < fNSegment[1]; y++) yzcell.push_back(ez); >> 260 >> 261 std::vector<std::vector<double> > xzcell; // xzcell[X][Z] >> 262 for(int x = 0; x < fNSegment[0]; x++) xzcell.push_back(ez); >> 263 270 // projections 264 // projections 271 G4int q[3]; 265 G4int q[3]; 272 auto itr = map->GetMap()->begin(); << 266 std::map<G4int, G4double*>::iterator itr = map->begin(); 273 for(; itr != map->GetMap()->end(); itr++) << 267 for(; itr != map->end(); itr++) { 274 { << 275 GetXYZ(itr->first, q); 268 GetXYZ(itr->first, q); 276 << 269 277 xycell[q[0]][q[1]] += (itr->second->sum_ << 270 xycell[q[0]][q[1]] += *(itr->second)/fDrawUnitValue; 278 yzcell[q[1]][q[2]] += (itr->second->sum_ << 271 yzcell[q[1]][q[2]] += *(itr->second)/fDrawUnitValue; 279 xzcell[q[0]][q[2]] += (itr->second->sum_ << 272 xzcell[q[0]][q[2]] += *(itr->second)/fDrawUnitValue; 280 } 273 } 281 << 274 282 // search max. & min. values in each slice 275 // search max. & min. values in each slice 283 G4double xymin = DBL_MAX, yzmin = DBL_MAX, 276 G4double xymin = DBL_MAX, yzmin = DBL_MAX, xzmin = DBL_MAX; 284 G4double xymax = 0., yzmax = 0., xzmax = 0 277 G4double xymax = 0., yzmax = 0., xzmax = 0.; 285 for(G4int x = 0; x < fNSegment[0]; x++) << 278 for(int x = 0; x < fNSegment[0]; x++) { 286 { << 279 for(int y = 0; y < fNSegment[1]; y++) { 287 for(G4int y = 0; y < fNSegment[1]; y++) << 280 if(xymin > xycell[x][y]) xymin = xycell[x][y]; 288 { << 281 if(xymax < xycell[x][y]) xymax = xycell[x][y]; 289 if(xymin > xycell[x][y]) << 282 } 290 xymin = xycell[x][y]; << 283 for(int z = 0; z < fNSegment[2]; z++) { 291 if(xymax < xycell[x][y]) << 284 if(xzmin > xzcell[x][z]) xzmin = xzcell[x][z]; 292 xymax = xycell[x][y]; << 285 if(xzmax < xzcell[x][z]) xzmax = xzcell[x][z]; 293 } << 294 for(G4int z = 0; z < fNSegment[2]; z++) << 295 { << 296 if(xzmin > xzcell[x][z]) << 297 xzmin = xzcell[x][z]; << 298 if(xzmax < xzcell[x][z]) << 299 xzmax = xzcell[x][z]; << 300 } 286 } 301 } 287 } 302 for(G4int y = 0; y < fNSegment[1]; y++) << 288 for(int y = 0; y < fNSegment[1]; y++) { 303 { << 289 for(int z = 0; z < fNSegment[2]; z++) { 304 for(G4int z = 0; z < fNSegment[2]; z++) << 290 if(yzmin > yzcell[y][z]) yzmin = yzcell[y][z]; 305 { << 291 if(yzmax < yzcell[y][z]) yzmax = yzcell[y][z]; 306 if(yzmin > yzcell[y][z]) << 307 yzmin = yzcell[y][z]; << 308 if(yzmax < yzcell[y][z]) << 309 yzmax = yzcell[y][z]; << 310 } 292 } 311 } 293 } 312 << 294 >> 295 313 G4VisAttributes att; 296 G4VisAttributes att; 314 att.SetForceSolid(true); 297 att.SetForceSolid(true); 315 att.SetForceAuxEdgeVisible(true); 298 att.SetForceAuxEdgeVisible(true); 316 G4double thick = 0.01; 299 G4double thick = 0.01; 317 << 300 318 G4Scale3D scale; 301 G4Scale3D scale; 319 if(axflg / 100 == 1) << 302 if(axflg/100==1) { 320 { << 321 pVisManager->BeginDraw(); 303 pVisManager->BeginDraw(); 322 304 323 // xy plane 305 // xy plane 324 if(colorMap->IfFloatMinMax()) << 306 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(xymin ,xymax); } 325 { << 307 G4ThreeVector zhalf(0., 0., fSize[2]/fNSegment[2]-thick); 326 colorMap->SetMinMax(xymin, xymax); << 308 for(int x = 0; x < fNSegment[0]; x++) { 327 } << 309 for(int y = 0; y < fNSegment[1]; y++) { 328 G4ThreeVector zhalf(0., 0., fSize[2] / f << 310 329 for(G4int x = 0; x < fNSegment[0]; x++) << 330 { << 331 for(G4int y = 0; y < fNSegment[1]; y++ << 332 { << 333 G4ThreeVector pos(GetReplicaPosition 311 G4ThreeVector pos(GetReplicaPosition(x, y, 0) - zhalf); 334 G4ThreeVector pos2(GetReplicaPositio << 312 G4ThreeVector pos2(GetReplicaPosition(x, y, fNSegment[2]-1) + zhalf); 335 zhalf); << 336 G4Transform3D trans, trans2; 313 G4Transform3D trans, trans2; 337 if(fRotationMatrix != nullptr) << 314 if(fRotationMatrix) { 338 { << 315 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos); 339 trans = G4Rotate3D(*fRotationMatri << 316 trans = G4Translate3D(fCenterPosition)*trans; 340 trans = G4Translate3D(fCenterPosit << 317 trans2 = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos2); 341 trans2 = << 318 trans2 = G4Translate3D(fCenterPosition)*trans2; 342 G4Rotate3D(*fRotationMatrix).inv << 319 } else { 343 trans2 = G4Translate3D(fCenterPosi << 320 trans = G4Translate3D(pos)*G4Translate3D(fCenterPosition); 344 } << 321 trans2 = G4Translate3D(pos2)*G4Translate3D(fCenterPosition); 345 else << 346 { << 347 trans = G4Translate3D(pos) * G4Tr << 348 trans2 = G4Translate3D(pos2) * G4T << 349 } 322 } 350 G4double c[4]; 323 G4double c[4]; 351 colorMap->GetMapColor(xycell[x][y], 324 colorMap->GetMapColor(xycell[x][y], c); 352 att.SetColour(c[0], c[1], c[2]); // << 325 att.SetColour(c[0], c[1], c[2]);//, c[3]); 353 << 326 354 G4Box xyplate("xy", fSize[0] / fNSeg << 327 G4Box xyplate("xy", fSize[0]/fNSegment[0], fSize[1]/fNSegment[1], 355 thick); 328 thick); 356 G4Polyhedron* poly = xyplate.GetPoly << 329 G4Polyhedron * poly = xyplate.GetPolyhedron(); 357 poly->Transform(trans); 330 poly->Transform(trans); 358 poly->SetVisAttributes(&att); 331 poly->SetVisAttributes(&att); 359 pVisManager->Draw(*poly); 332 pVisManager->Draw(*poly); 360 << 333 361 G4Box xyplate2 = xyplate; << 334 G4Box xyplate2 = xyplate; 362 G4Polyhedron* poly2 = xyplate2.GetPo << 335 G4Polyhedron * poly2 = xyplate2.GetPolyhedron(); 363 poly2->Transform(trans2); 336 poly2->Transform(trans2); 364 poly2->SetVisAttributes(&att); 337 poly2->SetVisAttributes(&att); 365 pVisManager->Draw(*poly2); 338 pVisManager->Draw(*poly2); >> 339 >> 340 /* >> 341 G4double nodes[][3] = >> 342 {{-fSize[0]/fNSegment[0], -fSize[1]/fNSegment[1], 0.}, >> 343 { fSize[0]/fNSegment[0], -fSize[1]/fNSegment[1], 0.}, >> 344 { fSize[0]/fNSegment[0], fSize[1]/fNSegment[1], 0.}, >> 345 {-fSize[0]/fNSegment[0], fSize[1]/fNSegment[1], 0.}}; >> 346 G4int facets[][4] = {{4, 3, 2, 1}}; >> 347 G4int facets2[][4] = {{1, 2, 3, 4}}; >> 348 >> 349 G4Polyhedron poly, poly2; >> 350 poly.createPolyhedron(4, 1, nodes, facets); >> 351 poly.Transform(trans); >> 352 poly.SetVisAttributes(att); >> 353 pVisManager->Draw(poly); >> 354 >> 355 poly2.createPolyhedron(4, 1, nodes, facets2); >> 356 poly2.Transform(trans2); >> 357 poly2.SetVisAttributes(att); >> 358 pVisManager->Draw(poly2); >> 359 */ 366 } 360 } 367 } 361 } 368 pVisManager->EndDraw(); 362 pVisManager->EndDraw(); 369 } 363 } 370 axflg = axflg % 100; << 364 axflg = axflg%100; 371 if(axflg / 10 == 1) << 365 if(axflg/10==1) { 372 { << 373 pVisManager->BeginDraw(); 366 pVisManager->BeginDraw(); 374 367 375 // yz plane 368 // yz plane 376 if(colorMap->IfFloatMinMax()) << 369 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(yzmin, yzmax); } 377 { << 370 G4ThreeVector xhalf(fSize[0]/fNSegment[0]-thick, 0., 0.); 378 colorMap->SetMinMax(yzmin, yzmax); << 371 for(int y = 0; y < fNSegment[1]; y++) { 379 } << 372 for(int z = 0; z < fNSegment[2]; z++) { 380 G4ThreeVector xhalf(fSize[0] / fNSegment << 373 381 for(G4int y = 0; y < fNSegment[1]; y++) << 382 { << 383 for(G4int z = 0; z < fNSegment[2]; z++ << 384 { << 385 G4ThreeVector pos(GetReplicaPosition 374 G4ThreeVector pos(GetReplicaPosition(0, y, z) - xhalf); 386 G4ThreeVector pos2(GetReplicaPositio << 375 G4ThreeVector pos2(GetReplicaPosition(fNSegment[0]-1, y, z) + xhalf); 387 xhalf); << 388 G4Transform3D trans, trans2; 376 G4Transform3D trans, trans2; 389 if(fRotationMatrix != nullptr) << 377 if(fRotationMatrix) { 390 { << 378 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos); 391 trans = G4Rotate3D(*fRotationMatri << 379 trans = G4Translate3D(fCenterPosition)*trans; 392 trans = G4Translate3D(fCenterPosit << 380 trans2 = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos2); 393 trans2 = << 381 trans2 = G4Translate3D(fCenterPosition)*trans2; 394 G4Rotate3D(*fRotationMatrix).inv << 382 } else { 395 trans2 = G4Translate3D(fCenterPosi << 383 trans = G4Translate3D(pos)*G4Translate3D(fCenterPosition); 396 } << 384 trans2 = G4Translate3D(pos2)*G4Translate3D(fCenterPosition); 397 else << 398 { << 399 trans = G4Translate3D(pos) * G4Tr << 400 trans2 = G4Translate3D(pos2) * G4T << 401 } 385 } 402 G4double c[4]; 386 G4double c[4]; 403 colorMap->GetMapColor(yzcell[y][z], 387 colorMap->GetMapColor(yzcell[y][z], c); 404 att.SetColour(c[0], c[1], c[2]); // << 388 att.SetColour(c[0], c[1], c[2]);//, c[3]); 405 << 389 406 G4Box yzplate("yz", thick, // fSize << 390 G4Box yzplate("yz", thick,//fSize[0]/fNSegment[0]*0.001, 407 fSize[1] / fNSegment[1 << 391 fSize[1]/fNSegment[1], 408 G4Polyhedron* poly = yzplate.GetPoly << 392 fSize[2]/fNSegment[2]); >> 393 G4Polyhedron * poly = yzplate.GetPolyhedron(); 409 poly->Transform(trans); 394 poly->Transform(trans); 410 poly->SetVisAttributes(&att); 395 poly->SetVisAttributes(&att); 411 pVisManager->Draw(*poly); 396 pVisManager->Draw(*poly); 412 << 397 413 G4Box yzplate2 = yzplate; << 398 G4Box yzplate2 = yzplate; 414 G4Polyhedron* poly2 = yzplate2.GetPo << 399 G4Polyhedron * poly2 = yzplate2.GetPolyhedron(); 415 poly2->Transform(trans2); 400 poly2->Transform(trans2); 416 poly2->SetVisAttributes(&att); 401 poly2->SetVisAttributes(&att); 417 pVisManager->Draw(*poly2); 402 pVisManager->Draw(*poly2); >> 403 >> 404 /* >> 405 G4double nodes[][3] = >> 406 {{0., -fSize[1]/fNSegment[1], -fSize[2]/fNSegment[2]}, >> 407 {0., fSize[1]/fNSegment[1], -fSize[2]/fNSegment[2]}, >> 408 {0., fSize[1]/fNSegment[1], fSize[2]/fNSegment[2]}, >> 409 {0., -fSize[1]/fNSegment[1], fSize[2]/fNSegment[2]}}; >> 410 G4int facets[][4] = {{4, 3, 2, 1}}; >> 411 G4int facets2[][4] = {{1, 2, 3, 4}}; >> 412 >> 413 G4Polyhedron poly, poly2; >> 414 poly.createPolyhedron(4, 1, nodes, facets); >> 415 poly.Transform(trans); >> 416 poly.SetVisAttributes(att); >> 417 pVisManager->Draw(poly); >> 418 >> 419 poly2.createPolyhedron(4, 1, nodes, facets2); >> 420 poly2.Transform(trans2); >> 421 poly2.SetVisAttributes(att); >> 422 pVisManager->Draw(poly2); >> 423 */ 418 } 424 } 419 } 425 } 420 pVisManager->EndDraw(); 426 pVisManager->EndDraw(); 421 } 427 } 422 axflg = axflg % 10; << 428 axflg = axflg%10; 423 if(axflg == 1) << 429 if(axflg==1) { 424 { << 425 pVisManager->BeginDraw(); 430 pVisManager->BeginDraw(); 426 431 427 // xz plane 432 // xz plane 428 if(colorMap->IfFloatMinMax()) << 433 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(xzmin,xzmax); } 429 { << 434 G4ThreeVector yhalf(0., fSize[1]/fNSegment[1]-thick, 0.); 430 colorMap->SetMinMax(xzmin, xzmax); << 435 for(int x = 0; x < fNSegment[0]; x++) { 431 } << 436 for(int z = 0; z < fNSegment[2]; z++) { 432 G4ThreeVector yhalf(0., fSize[1] / fNSeg << 437 433 for(G4int x = 0; x < fNSegment[0]; x++) << 434 { << 435 for(G4int z = 0; z < fNSegment[2]; z++ << 436 { << 437 G4ThreeVector pos(GetReplicaPosition 438 G4ThreeVector pos(GetReplicaPosition(x, 0, z) - yhalf); 438 G4ThreeVector pos2(GetReplicaPositio << 439 G4ThreeVector pos2(GetReplicaPosition(x, fNSegment[1]-1, z) + yhalf); 439 yhalf); << 440 G4Transform3D trans, trans2; 440 G4Transform3D trans, trans2; 441 if(fRotationMatrix != nullptr) << 441 if(fRotationMatrix) { 442 { << 442 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos); 443 trans = G4Rotate3D(*fRotationMatri << 443 trans = G4Translate3D(fCenterPosition)*trans; 444 trans = G4Translate3D(fCenterPosit << 444 trans2 = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos2); 445 trans2 = << 445 trans2 = G4Translate3D(fCenterPosition)*trans2; 446 G4Rotate3D(*fRotationMatrix).inv << 446 } else { 447 trans2 = G4Translate3D(fCenterPosi << 447 trans = G4Translate3D(pos)*G4Translate3D(fCenterPosition); 448 } << 448 trans2 = G4Translate3D(pos2)*G4Translate3D(fCenterPosition); 449 else << 450 { << 451 trans = G4Translate3D(pos) * G4Tr << 452 trans2 = G4Translate3D(pos2) * G4T << 453 } 449 } 454 G4double c[4]; 450 G4double c[4]; 455 colorMap->GetMapColor(xzcell[x][z], 451 colorMap->GetMapColor(xzcell[x][z], c); 456 att.SetColour(c[0], c[1], c[2]); // << 452 att.SetColour(c[0], c[1], c[2]);//, c[3]); 457 453 458 G4Box xzplate("xz", fSize[0] / fNSeg << 454 G4Box xzplate("xz", fSize[0]/fNSegment[0], thick,//fSize[1]/fNSegment[1]*0.001, 459 thick, // fSize[1]/fN << 455 fSize[2]/fNSegment[2]); 460 fSize[2] / fNSegment[2 << 456 G4Polyhedron * poly = xzplate.GetPolyhedron(); 461 G4Polyhedron* poly = xzplate.GetPoly << 462 poly->Transform(trans); 457 poly->Transform(trans); 463 poly->SetVisAttributes(&att); 458 poly->SetVisAttributes(&att); 464 pVisManager->Draw(*poly); 459 pVisManager->Draw(*poly); 465 << 460 466 G4Box xzplate2 = xzplate; << 461 G4Box xzplate2 = xzplate; 467 G4Polyhedron* poly2 = xzplate2.GetPo << 462 G4Polyhedron * poly2 = xzplate2.GetPolyhedron(); 468 poly2->Transform(trans2); 463 poly2->Transform(trans2); 469 poly2->SetVisAttributes(&att); 464 poly2->SetVisAttributes(&att); 470 pVisManager->Draw(*poly2); 465 pVisManager->Draw(*poly2); >> 466 >> 467 >> 468 /* >> 469 G4double nodes[][3] = >> 470 {{-fSize[1]/fNSegment[1], 0., -fSize[2]/fNSegment[2]}, >> 471 { fSize[1]/fNSegment[1], 0., -fSize[2]/fNSegment[2]}, >> 472 { fSize[1]/fNSegment[1], 0., fSize[2]/fNSegment[2]}, >> 473 {-fSize[1]/fNSegment[1], 0., fSize[2]/fNSegment[2]}}; >> 474 G4int facets[][4] = {{1, 2, 3, 4}}; >> 475 G4int facets2[][4] = {{4, 3, 2, 1}}; >> 476 >> 477 G4Polyhedron poly, poly2; >> 478 poly.createPolyhedron(4, 1, nodes, facets); >> 479 poly.Transform(trans); >> 480 poly.SetVisAttributes(att); >> 481 pVisManager->Draw(poly); >> 482 >> 483 poly2.createPolyhedron(4, 1, nodes, facets2); >> 484 poly2.Transform(trans2); >> 485 poly2.SetVisAttributes(att); >> 486 pVisManager->Draw(poly2); >> 487 */ 471 } 488 } 472 } 489 } 473 pVisManager->EndDraw(); 490 pVisManager->EndDraw(); 474 } 491 } 475 } 492 } 476 colorMap->SetPSUnit(fDrawUnit); 493 colorMap->SetPSUnit(fDrawUnit); 477 colorMap->SetPSName(fDrawPSName); 494 colorMap->SetPSName(fDrawPSName); 478 colorMap->DrawColorChart(); 495 colorMap->DrawColorChart(); 479 } 496 } 480 497 481 G4ThreeVector G4ScoringBox::GetReplicaPosition << 498 G4ThreeVector G4ScoringBox::GetReplicaPosition(G4int x, G4int y, G4int z) { 482 { << 499 483 G4ThreeVector width(fSize[0] / fNSegment[0], << 500 G4ThreeVector width(fSize[0]/fNSegment[0], fSize[1]/fNSegment[1], 484 fSize[2] / fNSegment[2]) << 501 fSize[2]/fNSegment[2]); 485 G4ThreeVector pos(-fSize[0] + 2 * (x + 0.5) << 502 G4ThreeVector pos(-fSize[0] + 2*(x+0.5)*width.x(), 486 -fSize[1] + 2 * (y + 0.5) << 503 -fSize[1] + 2*(y+0.5)*width.y(), 487 -fSize[2] + 2 * (z + 0.5) << 504 -fSize[2] + 2*(z+0.5)*width.z()); 488 << 505 489 return pos; 506 return pos; 490 } 507 } 491 508 492 void G4ScoringBox::GetXYZ(G4int index, G4int q << 509 void G4ScoringBox::GetXYZ(G4int index, G4int q[3]) const { 493 { << 510 494 q[0] = index / (fNSegment[2] * fNSegment[1]) << 511 q[0] = index/(fNSegment[2]*fNSegment[1]); 495 q[1] = (index - q[0] * fNSegment[2] * fNSegm << 512 q[1] = (index - q[0]*fNSegment[2]*fNSegment[1])/fNSegment[2]; 496 q[2] = index - q[1] * fNSegment[2] - q[0] * << 513 q[2] = index - q[1]*fNSegment[2] - q[0]*fNSegment[2]*fNSegment[1]; >> 514 497 } 515 } 498 516 499 G4int G4ScoringBox::GetIndex(G4int x, G4int y, << 517 G4int G4ScoringBox::GetIndex(G4int x, G4int y, G4int z) const { 500 { << 518 return x + y*fNSegment[0] + z*fNSegment[0]*fNSegment[1]; 501 return x + y * fNSegment[0] + z * fNSegment[ << 502 } 519 } 503 520 504 void G4ScoringBox::DrawColumn(RunScore* map, G << 521 void G4ScoringBox::DrawColumn(std::map<G4int, G4double*> * map, >> 522 G4VScoreColorMap* colorMap, 505 G4int idxProj, G 523 G4int idxProj, G4int idxColumn) 506 { 524 { 507 G4int iColumn[3] = { 2, 0, 1 }; << 525 G4int iColumn[3] = {2, 0, 1}; 508 if(idxColumn < 0 || idxColumn >= fNSegment[i << 526 if(idxColumn<0 || idxColumn>=fNSegment[iColumn[idxProj]]) 509 { 527 { 510 G4cerr << "ERROR : Column number " << idxC 528 G4cerr << "ERROR : Column number " << idxColumn 511 << " is out of scoring mesh [0," << << 529 << " is out of scoring mesh [0," << fNSegment[iColumn[idxProj]]-1 512 << "]. Method ignored." << G4endl; << 530 << "]. Method ignored." << G4endl; 513 return; 531 return; 514 } 532 } 515 G4VVisManager* pVisManager = G4VVisManager:: << 533 G4VVisManager * pVisManager = G4VVisManager::GetConcreteInstance(); 516 if(pVisManager != nullptr) << 534 if(pVisManager) { 517 { << 518 pVisManager->BeginDraw(); 535 pVisManager->BeginDraw(); 519 << 536 520 // cell vectors 537 // cell vectors 521 std::vector<std::vector<std::vector<G4doub << 538 std::vector<std::vector<std::vector<double> > > cell; // cell[X][Y][Z] 522 std::vector<G4double> ez; << 539 std::vector<double> ez; 523 for(G4int z = 0; z < fNSegment[2]; z++) << 540 for(int z = 0; z < fNSegment[2]; z++) ez.push_back(0.); 524 ez.push_back(0.); << 541 std::vector<std::vector<double> > eyz; 525 std::vector<std::vector<G4double>> eyz; << 542 for(int y = 0; y < fNSegment[1]; y++) eyz.push_back(ez); 526 for(G4int y = 0; y < fNSegment[1]; y++) << 543 for(int x = 0; x < fNSegment[0]; x++) cell.push_back(eyz); 527 eyz.push_back(ez); << 544 528 for(G4int x = 0; x < fNSegment[0]; x++) << 545 std::vector<std::vector<double> > xycell; // xycell[X][Y] 529 cell.push_back(eyz); << 546 std::vector<double> ey; 530 << 547 for(int y = 0; y < fNSegment[1]; y++) ey.push_back(0.); 531 std::vector<std::vector<G4double>> xycell; << 548 for(int x = 0; x < fNSegment[0]; x++) xycell.push_back(ey); 532 std::vector<G4double> ey; << 549 533 for(G4int y = 0; y < fNSegment[1]; y++) << 550 std::vector<std::vector<double> > yzcell; // yzcell[Y][Z] 534 ey.push_back(0.); << 551 for(int y = 0; y < fNSegment[1]; y++) yzcell.push_back(ez); 535 for(G4int x = 0; x < fNSegment[0]; x++) << 552 536 xycell.push_back(ey); << 553 std::vector<std::vector<double> > xzcell; // xzcell[X][Z] 537 << 554 for(int x = 0; x < fNSegment[0]; x++) xzcell.push_back(ez); 538 std::vector<std::vector<G4double>> yzcell; << 555 539 for(G4int y = 0; y < fNSegment[1]; y++) << 540 yzcell.push_back(ez); << 541 << 542 std::vector<std::vector<G4double>> xzcell; << 543 for(G4int x = 0; x < fNSegment[0]; x++) << 544 xzcell.push_back(ez); << 545 << 546 // projections 556 // projections 547 G4int q[3]; 557 G4int q[3]; 548 auto itr = map->GetMap()->begin(); << 558 std::map<G4int, G4double*>::iterator itr = map->begin(); 549 for(; itr != map->GetMap()->end(); itr++) << 559 for(; itr != map->end(); itr++) { 550 { << 551 GetXYZ(itr->first, q); 560 GetXYZ(itr->first, q); 552 << 561 553 if(idxProj == 0 && q[2] == idxColumn) << 562 if(idxProj == 0 && q[2] == idxColumn) { // xy plane 554 { // xy plane << 563 xycell[q[0]][q[1]] += *(itr->second)/fDrawUnitValue; 555 xycell[q[0]][q[1]] += (itr->second->su << 564 } 556 } << 565 if(idxProj == 1 && q[0] == idxColumn) { // yz plane 557 if(idxProj == 1 && q[0] == idxColumn) << 566 yzcell[q[1]][q[2]] += *(itr->second)/fDrawUnitValue; 558 { // yz plane << 567 } 559 yzcell[q[1]][q[2]] += (itr->second->su << 568 if(idxProj == 2 && q[1] == idxColumn) { // zx plane 560 } << 569 xzcell[q[0]][q[2]] += *(itr->second)/fDrawUnitValue; 561 if(idxProj == 2 && q[1] == idxColumn) << 562 { // zx plane << 563 xzcell[q[0]][q[2]] += (itr->second->su << 564 } 570 } 565 } 571 } 566 << 572 567 // search max. & min. values in each slice 573 // search max. & min. values in each slice 568 G4double xymin = DBL_MAX, yzmin = DBL_MAX, 574 G4double xymin = DBL_MAX, yzmin = DBL_MAX, xzmin = DBL_MAX; 569 G4double xymax = 0., yzmax = 0., xzmax = 0 575 G4double xymax = 0., yzmax = 0., xzmax = 0.; 570 for(G4int x = 0; x < fNSegment[0]; x++) << 576 for(int x = 0; x < fNSegment[0]; x++) { 571 { << 577 for(int y = 0; y < fNSegment[1]; y++) { 572 for(G4int y = 0; y < fNSegment[1]; y++) << 578 if(xymin > xycell[x][y]) xymin = xycell[x][y]; 573 { << 579 if(xymax < xycell[x][y]) xymax = xycell[x][y]; 574 if(xymin > xycell[x][y]) << 580 } 575 xymin = xycell[x][y]; << 581 for(int z = 0; z < fNSegment[2]; z++) { 576 if(xymax < xycell[x][y]) << 582 if(xzmin > xzcell[x][z]) xzmin = xzcell[x][z]; 577 xymax = xycell[x][y]; << 583 if(xzmax < xzcell[x][z]) xzmax = xzcell[x][z]; 578 } << 579 for(G4int z = 0; z < fNSegment[2]; z++) << 580 { << 581 if(xzmin > xzcell[x][z]) << 582 xzmin = xzcell[x][z]; << 583 if(xzmax < xzcell[x][z]) << 584 xzmax = xzcell[x][z]; << 585 } 584 } 586 } 585 } 587 for(G4int y = 0; y < fNSegment[1]; y++) << 586 for(int y = 0; y < fNSegment[1]; y++) { 588 { << 587 for(int z = 0; z < fNSegment[2]; z++) { 589 for(G4int z = 0; z < fNSegment[2]; z++) << 588 if(yzmin > yzcell[y][z]) yzmin = yzcell[y][z]; 590 { << 589 if(yzmax < yzcell[y][z]) yzmax = yzcell[y][z]; 591 if(yzmin > yzcell[y][z]) << 592 yzmin = yzcell[y][z]; << 593 if(yzmax < yzcell[y][z]) << 594 yzmax = yzcell[y][z]; << 595 } 590 } 596 } 591 } 597 << 592 >> 593 598 G4VisAttributes att; 594 G4VisAttributes att; 599 att.SetForceSolid(true); 595 att.SetForceSolid(true); 600 att.SetForceAuxEdgeVisible(true); 596 att.SetForceAuxEdgeVisible(true); 601 597 602 G4Scale3D scale; 598 G4Scale3D scale; 603 // xy plane 599 // xy plane 604 if(idxProj == 0) << 600 if(idxProj == 0) { 605 { << 601 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(xymin,xymax); } 606 if(colorMap->IfFloatMinMax()) << 602 for(int x = 0; x < fNSegment[0]; x++) { 607 { << 603 for(int y = 0; y < fNSegment[1]; y++) { 608 colorMap->SetMinMax(xymin, xymax); << 604 G4Box xyplate("xy", fSize[0]/fNSegment[0], fSize[1]/fNSegment[1], 609 } << 605 fSize[2]/fNSegment[2]); 610 for(G4int x = 0; x < fNSegment[0]; x++) << 611 { << 612 for(G4int y = 0; y < fNSegment[1]; y++ << 613 { << 614 G4Box xyplate("xy", fSize[0] / fNSeg << 615 fSize[2] / fNSegment[2 << 616 606 617 G4ThreeVector pos(GetReplicaPosition 607 G4ThreeVector pos(GetReplicaPosition(x, y, idxColumn)); 618 G4Transform3D trans; 608 G4Transform3D trans; 619 if(fRotationMatrix != nullptr) << 609 if(fRotationMatrix) { 620 { << 610 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos); 621 trans = G4Rotate3D(*fRotationMatri << 611 trans = G4Translate3D(fCenterPosition)*trans; 622 trans = G4Translate3D(fCenterPosit << 612 } else { 623 } << 613 trans = G4Translate3D(pos)*G4Translate3D(fCenterPosition); 624 else << 625 { << 626 trans = G4Translate3D(pos) * G4Tra << 627 } 614 } 628 G4double c[4]; 615 G4double c[4]; 629 colorMap->GetMapColor(xycell[x][y], 616 colorMap->GetMapColor(xycell[x][y], c); 630 att.SetColour(c[0], c[1], c[2]); 617 att.SetColour(c[0], c[1], c[2]); 631 << 618 632 G4Polyhedron* poly = xyplate.GetPoly << 619 G4Polyhedron * poly = xyplate.GetPolyhedron(); 633 poly->Transform(trans); 620 poly->Transform(trans); 634 poly->SetVisAttributes(att); 621 poly->SetVisAttributes(att); 635 pVisManager->Draw(*poly); 622 pVisManager->Draw(*poly); 636 } 623 } 637 } 624 } 638 } << 639 else << 640 // yz plane << 641 if(idxProj == 1) << 642 { << 643 if(colorMap->IfFloatMinMax()) << 644 { << 645 colorMap->SetMinMax(yzmin, yzmax); << 646 } << 647 for(G4int y = 0; y < fNSegment[1]; y++) << 648 { << 649 for(G4int z = 0; z < fNSegment[2]; z++ << 650 { << 651 G4Box yzplate("yz", fSize[0] / fNSeg << 652 fSize[2] / fNSegment[2 << 653 625 654 G4ThreeVector pos(GetReplicaPosition << 626 } else 655 G4Transform3D trans; << 627 // yz plane 656 if(fRotationMatrix != nullptr) << 628 if(idxProj == 1) { 657 { << 629 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(yzmin,yzmax); } 658 trans = G4Rotate3D(*fRotationMatri << 630 for(int y = 0; y < fNSegment[1]; y++) { 659 trans = G4Translate3D(fCenterPosit << 631 for(int z = 0; z < fNSegment[2]; z++) { 660 } << 632 G4Box yzplate("yz", fSize[0]/fNSegment[0], fSize[1]/fNSegment[1], 661 else << 633 fSize[2]/fNSegment[2]); 662 { << 634 663 trans = G4Translate3D(pos) * G4Tra << 635 G4ThreeVector pos(GetReplicaPosition(idxColumn, y, z)); >> 636 G4Transform3D trans; >> 637 if(fRotationMatrix) { >> 638 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos); >> 639 trans = G4Translate3D(fCenterPosition)*trans; >> 640 } else { >> 641 trans = G4Translate3D(pos)*G4Translate3D(fCenterPosition); >> 642 } >> 643 G4double c[4]; >> 644 colorMap->GetMapColor(yzcell[y][z], c); >> 645 att.SetColour(c[0], c[1], c[2]);//, c[3]); >> 646 >> 647 G4Polyhedron * poly = yzplate.GetPolyhedron(); >> 648 poly->Transform(trans); >> 649 poly->SetVisAttributes(att); >> 650 pVisManager->Draw(*poly); 664 } 651 } 665 G4double c[4]; << 666 colorMap->GetMapColor(yzcell[y][z], << 667 att.SetColour(c[0], c[1], c[2]); // << 668 << 669 G4Polyhedron* poly = yzplate.GetPoly << 670 poly->Transform(trans); << 671 poly->SetVisAttributes(att); << 672 pVisManager->Draw(*poly); << 673 } 652 } 674 } << 653 } else 675 } << 654 // xz plane 676 else << 655 if(idxProj == 2) { 677 // xz plane << 656 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(xzmin,xzmax);} 678 if(idxProj == 2) << 657 for(int x = 0; x < fNSegment[0]; x++) { 679 { << 658 for(int z = 0; z < fNSegment[2]; z++) { 680 if(colorMap->IfFloatMinMax()) << 659 G4Box xzplate("xz", fSize[0]/fNSegment[0], fSize[1]/fNSegment[1], 681 { << 660 fSize[2]/fNSegment[2]); 682 colorMap->SetMinMax(xzmin, xzmax); << 661 683 } << 662 G4ThreeVector pos(GetReplicaPosition(x, idxColumn, z)); 684 for(G4int x = 0; x < fNSegment[0]; x++) << 663 G4Transform3D trans; 685 { << 664 if(fRotationMatrix) { 686 for(G4int z = 0; z < fNSegment[2]; z++ << 665 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos); 687 { << 666 trans = G4Translate3D(fCenterPosition)*trans; 688 G4Box xzplate("xz", fSize[0] / fNSeg << 667 } else { 689 fSize[2] / fNSegment[2 << 668 trans = G4Translate3D(pos)*G4Translate3D(fCenterPosition); 690 << 669 } 691 G4ThreeVector pos(GetReplicaPosition << 670 G4double c[4]; 692 G4Transform3D trans; << 671 colorMap->GetMapColor(xzcell[x][z], c); 693 if(fRotationMatrix != nullptr) << 672 att.SetColour(c[0], c[1], c[2]);//, c[3]); 694 { << 673 695 trans = G4Rotate3D(*fRotationMatri << 674 G4Polyhedron * poly = xzplate.GetPolyhedron(); 696 trans = G4Translate3D(fCenterPosit << 675 poly->Transform(trans); >> 676 poly->SetVisAttributes(att); >> 677 pVisManager->Draw(*poly); >> 678 } 697 } 679 } 698 else << 699 { << 700 trans = G4Translate3D(pos) * G4Tra << 701 } << 702 G4double c[4]; << 703 colorMap->GetMapColor(xzcell[x][z], << 704 att.SetColour(c[0], c[1], c[2]); // << 705 << 706 G4Polyhedron* poly = xzplate.GetPoly << 707 poly->Transform(trans); << 708 poly->SetVisAttributes(att); << 709 pVisManager->Draw(*poly); << 710 } 680 } 711 } << 712 } << 713 pVisManager->EndDraw(); 681 pVisManager->EndDraw(); 714 } << 715 682 >> 683 } >> 684 716 colorMap->SetPSUnit(fDrawUnit); 685 colorMap->SetPSUnit(fDrawUnit); 717 colorMap->SetPSName(fDrawPSName); 686 colorMap->SetPSName(fDrawPSName); 718 colorMap->DrawColorChart(); 687 colorMap->DrawColorChart(); 719 } 688 } >> 689 >> 690 720 691