Changeset 1340 for trunk/source/digits_hits/utils/src

Timestamp:

Nov 5, 2010, 3:45:55 PM (14 years ago)

Author:

garnier

Message:

update ti head

Location:

trunk/source/digits_hits/utils/src

Files:

• CVS/Entries (modified) (1 diff)
• G4DefaultLinearColorMap.cc (modified) (1 diff)
• G4ScoreLogColorMap.cc (modified) (8 diffs)
• G4ScoreQuantityMessenger.cc (modified) (6 diffs)
• G4ScoreQuantityMessengerQCmd.cc (modified) (23 diffs)
• G4ScoringBox.cc (modified) (11 diffs)
• G4ScoringCylinder.cc (modified) (21 diffs)
• G4ScoringManager.cc (modified) (2 diffs)
• G4ScoringMessenger.cc (modified) (6 diffs)
• G4VScoreColorMap.cc (modified) (3 diffs)
• G4VScoreWriter.cc (modified) (5 diffs)
• G4VScoringMesh.cc (modified) (4 diffs)

trunk/source/digits_hits/utils/src/CVS/Entries

@@ -1 @@
-/G4DefaultLinearColorMap.cc/1.3/Wed Sep 29 21:48:27 2010//Tgeant4-09-04-beta-01
-/G4ScoreLogColorMap.cc/1.3/Wed Sep 29 21:48:27 2010//Tgeant4-09-04-beta-01
-/G4ScoreQuantityMessenger.cc/1.8/Wed Sep 29 21:48:27 2010//Tgeant4-09-04-beta-01
-/G4ScoreQuantityMessengerQCmd.cc/1.6/Wed Sep 29 21:48:27 2010//Tgeant4-09-04-beta-01
-/G4ScoringBox.cc/1.54/Wed Sep 29 21:48:28 2010//Tgeant4-09-04-beta-01
-/G4ScoringBoxParameterisation.cc/1.4/Wed Sep 29 21:48:28 2010//Tgeant4-09-04-beta-01
-/G4ScoringCylinder.cc/1.6/Wed Sep 29 21:48:28 2010//Tgeant4-09-04-beta-01
-/G4ScoringManager.cc/1.31/Wed Sep 29 21:48:28 2010//Tgeant4-09-04-beta-01
-/G4ScoringMessenger.cc/1.39/Wed Sep 29 21:48:28 2010//Tgeant4-09-04-beta-01
-/G4VScoreColorMap.cc/1.4/Wed Sep 29 21:48:28 2010//Tgeant4-09-04-beta-01
-/G4VScoreWriter.cc/1.5/Wed Sep 29 21:48:29 2010//Tgeant4-09-04-beta-01
-/G4VScoringMesh.cc/1.37/Wed Sep 29 21:48:29 2010//Tgeant4-09-04-beta-01
+/G4DefaultLinearColorMap.cc/1.3/Thu Nov  4 15:58:45 2010//
+/G4ScoreLogColorMap.cc/1.10/Fri Nov  5 09:56:24 2010//
+/G4ScoreQuantityMessenger.cc/1.10/Fri Nov  5 09:56:24 2010//
+/G4ScoreQuantityMessengerQCmd.cc/1.8/Fri Nov  5 09:56:24 2010//
+/G4ScoringBox.cc/1.61/Fri Nov  5 09:56:25 2010//
+/G4ScoringCylinder.cc/1.16/Fri Nov  5 09:56:25 2010//
+/G4ScoringManager.cc/1.33/Fri Nov  5 09:56:25 2010//
+/G4ScoringMessenger.cc/1.42/Fri Nov  5 09:56:25 2010//
+/G4VScoreColorMap.cc/1.8/Fri Nov  5 09:56:25 2010//
+/G4VScoreWriter.cc/1.10/Fri Nov  5 09:56:25 2010//
+/G4VScoringMesh.cc/1.42/Fri Nov  5 09:56:25 2010//
 D

trunk/source/digits_hits/utils/src/G4DefaultLinearColorMap.cc

@@ -26 +26 @@
 //
 // $Id: G4DefaultLinearColorMap.cc,v 1.3 2008/08/29 02:50:05 akimura Exp $
-// GEANT4 tag $Name: geant4-09-04-beta-01 $
+// GEANT4 tag $Name:  $
 //
 

trunk/source/digits_hits/utils/src/G4ScoreLogColorMap.cc

@@ -25 +25 @@
 //
 //
-// $Id: G4ScoreLogColorMap.cc,v 1.3 2009/05/04 15:57:33 akimura Exp $
-// GEANT4 tag $Name: geant4-09-04-beta-01 $
+// $Id: G4ScoreLogColorMap.cc,v 1.10 2010/11/03 19:31:36 asaim Exp $
+// GEANT4 tag $Name:  $
 //
 
@@ -50 +50 @@
 {;}
 
+#include "G4UIcommand.hh"
 void G4ScoreLogColorMap::GetMapColor(G4double val, G4double color[4])
 {
   G4bool lmin = true, lmax = true, lval = true;
-  if(fMinVal <= 0.) lmin = false;
-  if(fMaxVal <= 0.) lmax = false;
-  if(val <= 0.) lval = false;
+  if(fMinVal < 0.) {
+    lmin = false;
+    G4String message = "    The min. value (fMinVal) is negative. : ";
+    message += G4UIcommand::ConvertToString(fMinVal);
+    G4Exception("G4ScoreLogColorMap::GetMapColor()",
+                "DigiHitsUtilsScoreLogColorMap000", JustWarning,
+                message);
+  }
+  if(fMaxVal < 0.) {
+    lmax = false;
+    G4String message = "    The max. value (fMaxVal) is negative. : ";
+    message += G4UIcommand::ConvertToString(fMaxVal);
+    G4Exception("G4ScoreLogColorMap::GetMapColor()",
+                "DigiHitsUtilsScoreLogColorMap001", JustWarning,
+                message);
+  }
+  if(!lmin || !lmax) {
+    color[0] = 0.;
+    color[1] = 0.;
+    color[2] = 0.;
+    color[3] = 0.;
+    return;
+  }
+
+  if(val < 0.) {
+    lval = false;
+    G4String message = "     'val' (first argument) is negative : ";
+    message += G4UIcommand::ConvertToString(fMaxVal);
+    G4Exception("G4ScoreLogColorMap::GetMapColor()",
+                "DigiHitsUtilsScoreLogColorMap002", JustWarning,
+                message);
+  }
+  if(!lval) {
+    color[0] = 0.;
+    color[1] = 0.;
+    color[2] = 0.;
+    color[3] = -1.;
+    return;
+  }
+
   G4double logmin = 0., logmax = 0., logval = 0.;
   if(lmin) logmin = std::log10(fMinVal);
@@ -101 +139 @@
 void G4ScoreLogColorMap::DrawColorChartBar(G4int _nPoint) {
 
+  G4cout << "++++++ " << fMinVal << " - " << fMaxVal << G4endl;
   G4bool lmin = true, lmax = true;
   if(fMinVal <= 0.) lmin = false;
@@ -118 +157 @@
     G4double val = std::pow(10., (ra*max+rb*min)/(ra+rb));
     this->GetMapColor(val, c);
+    if(c[0] == 0 && c[1] == 0 && c[2] == 0 && c[3] == 0) return;
+    if(c[0] == 0 && c[1] == 0 && c[2] == 0 && c[3] == -1.) continue;
     G4Colour col(c[0], c[1], c[2]);
     G4VisAttributes att(col);
@@ -132 +173 @@
   G4double min = 0.;
   if(lmin) min = std::log10(fMinVal);
-  if(min > 0.) min = std::floor(min);
-  else min = std::ceil(min);
+  //if(min > 0.) min = std::floor(min);
+  //else min = std::ceil(min);
 
   G4double max = 0.;
   if(lmax) max = std::log10(fMaxVal);
-  if(max > 0.) max = std::floor(max);
-  else max = std::ceil(max);
+  //if(max > 0.) max = std::ceil(max);
+  //else max = std::floor(max);
 
   G4double c[4];
@@ -145 +186 @@
     G4double a = n/(_nPoint-1.), b = 1.-a;
     G4double v = (a*max + b*min)/(a+b);
+
+    this->GetMapColor(std::pow(10., v), c);
+    if(c[0] == 0 && c[1] == 0 && c[2] == 0 && c[3] == 0) return;
+    if(c[0] == 0 && c[1] == 0 && c[2] == 0 && c[3] == -1.) continue;
+
     // background color
     for(int l = 0; l < 21; l++) {
@@ -165 +211 @@
     G4double size = 12.;
     text.SetScreenSize(size);
-    this->GetMapColor(std::pow(10., v), c);
+    //this->GetMapColor(std::pow(10., v), c);
     G4Colour color(c[0], c[1], c[2]);
     G4VisAttributes att(color);
@@ -172 +218 @@
     fVisManager->Draw2D(text);
   }
+
+
+  // draw ps name
+  // background
+  G4int lpsname = 20;// fPSName.size();
+  if(lpsname > 0) {
+    for(int l = 0; l < 22; l++) {
+      G4Polyline line;
+      line.push_back(G4Point3D(-0.9, -0.965+0.002*l, 0.));
+      line.push_back(G4Point3D(-0.9+0.025*lpsname, -0.965+0.002*l, 0.));
+      G4VisAttributes attblack(black);
+      //G4VisAttributes attblack(G4Colour(.0, .5, .0));
+      line.SetVisAttributes(&attblack);
+      fVisManager->Draw2D(line);
+    }
+    // ps name
+    G4Text txtpsname(fPSName, G4Point3D(-0.9, -0.96, 0.));
+    G4double size = 12.;
+    txtpsname.SetScreenSize(size);
+    G4Colour color(1., 1., 1.);
+    G4VisAttributes att(color);
+    txtpsname.SetVisAttributes(&att);
+    fVisManager->Draw2D(txtpsname);
+  }
+
+
+
+  // draw unit
+  // background
+  G4int len = fPSUnit.size();
+  if(len > 0) {
+    for(int l = 0; l < 21; l++) {
+      G4Polyline line;
+      line.push_back(G4Point3D(-0.7, -0.9+0.002*l, 0.));
+      line.push_back(G4Point3D(-0.7+0.3, -0.9+0.002*l, 0.));
+      G4VisAttributes attblack(black);
+      //G4VisAttributes attblack(G4Colour(.5, .0, .0));
+      line.SetVisAttributes(&attblack);
+      fVisManager->Draw2D(line);
+    }
+    // unit
+    G4String psunit = "[" + fPSUnit + "]";
+    G4Text txtunit(psunit, G4Point3D(-0.69, -0.9, 0.));
+    G4double size = 12.;
+    txtunit.SetScreenSize(size);
+    G4Colour color(1., 1., 1.);
+    G4VisAttributes att(color);
+    txtunit.SetVisAttributes(&att);
+    fVisManager->Draw2D(txtunit);
+  }
+
 }

trunk/source/digits_hits/utils/src/G4ScoreQuantityMessenger.cc

@@ -25 +25 @@
 //
 //
-// $Id: G4ScoreQuantityMessenger.cc,v 1.8 2007/11/07 04:12:07 akimura Exp $
-// GEANT4 tag $Name: geant4-09-04-beta-01 $
+// $Id: G4ScoreQuantityMessenger.cc,v 1.10 2010/11/03 08:28:42 taso Exp $
+// GEANT4 tag $Name:  $
 //
+// ---------------------------------------------------------------------
+// Modifications
+// 08-Oct-2010 T.Aso remove unit of G4PSPassageCellCurrent.
 // ---------------------------------------------------------------------
 
@@ -55 +58 @@
 #include "G4PSTrackCounter3D.hh"
 #include "G4PSTermination3D.hh"
+#include "G4PSMinKinEAtGeneration3D.hh"
 
 #include "G4SDChargedFilter.hh"
@@ -160 +164 @@
     delete         quantityDir;
     delete         qTouchCmd;
+    delete         qGetUnitCmd;
+    delete         qSetUnitCmd;
+
     //
     delete    qCellChgCmd;
@@ -182 +189 @@
     delete          qTrackCountCmd;
     delete          qTerminationCmd;
+    delete          qMinKinEAtGeneCmd;
     //
     delete   filterDir;
@@ -209 +217 @@
       if(command==qTouchCmd) {
               mesh->SetCurrentPrimitiveScorer(newVal);
+      } else if(command == qGetUnitCmd ){
+          G4cout << "Unit:  "<< mesh->GetCurrentPSUnit() <<G4endl;
+      } else if(command == qSetUnitCmd ){
+          mesh->SetCurrentPSUnit(newVal);
       } else if(command== qCellChgCmd) {
-            if(!mesh->FindPrimitiveScorer(newVal)) {
-              mesh->SetPrimitiveScorer(new G4PSCellCharge3D(newVal));
-            } else {
-              G4cout << "WARNING[" << qTouchCmd->GetCommandPath()
-                     << "] : Quantity name, \"" << newVal << "\", is already existing." << G4endl;
-              mesh->SetNullToCurrentPrimitiveScorer();
-            }
+          if ( CheckMeshPS(mesh,token[0]) ){
+              G4PSCellCharge3D* ps = new G4PSCellCharge3D(token[0]);
+              ps->SetUnit(token[1]);
+              mesh->SetPrimitiveScorer(ps);
+          }
       } else if(command== qCellFluxCmd) {
-            if(!mesh->FindPrimitiveScorer(newVal)) { 
-              mesh->SetPrimitiveScorer(new G4PSCellFlux3D(newVal));
-            } else {
-              G4cout << "WARNING[" << qCellFluxCmd->GetCommandPath()
-                     << "] : Quantity name, \"" << newVal << "\", is already existing." << G4endl;
-              mesh->SetNullToCurrentPrimitiveScorer();
-            }
+          if ( CheckMeshPS(mesh,token[0]) ){
+              G4PSCellFlux3D* ps = new G4PSCellFlux3D(token[0]);
+              ps->SetUnit(token[1]);
+              mesh->SetPrimitiveScorer(ps);
+          }
       } else if(command== qPassCellFluxCmd) {
-            if(!mesh->FindPrimitiveScorer(newVal))  {
-              mesh->SetPrimitiveScorer(new G4PSPassageCellFlux3D(newVal));
-            } else {
-              G4cout << "WARNING[" << qPassCellFluxCmd->GetCommandPath()
-                     << "] : Quantity name, \"" << newVal << "\", is already existing." << G4endl;
-              mesh->SetNullToCurrentPrimitiveScorer();
-            }
+          if ( CheckMeshPS(mesh,token[0]) ){
+              G4PSPassageCellFlux3D* ps = new G4PSPassageCellFlux3D(token[0]);
+              ps->SetUnit(token[1]);
+              mesh->SetPrimitiveScorer(ps);
+          }
       } else if(command==qeDepCmd) {
-            if(!mesh->FindPrimitiveScorer(newVal))  {
-              mesh->SetPrimitiveScorer(new G4PSEnergyDeposit3D(newVal));
-            } else {
-              G4cout << "WARNING[" << qeDepCmd->GetCommandPath()
-                     << "] : Quantity name, \"" << newVal << "\", is already existing." << G4endl;
-              mesh->SetNullToCurrentPrimitiveScorer();
-            }
+          if ( CheckMeshPS(mesh,token[0]) ){
+              G4PSEnergyDeposit3D* ps =new G4PSEnergyDeposit3D(token[0]);
+              ps->SetUnit(token[1]);
+              mesh->SetPrimitiveScorer(ps);
+          }
       } else if(command== qdoseDepCmd) {
-            if(!mesh->FindPrimitiveScorer(newVal))  {
-              mesh->SetPrimitiveScorer(new G4PSDoseDeposit3D(newVal));
-            } else {
-              G4cout << "WARNING[" << qdoseDepCmd->GetCommandPath()
-                     << "] : Quantity name, \"" << newVal << "\", is already existing." << G4endl;
-              mesh->SetNullToCurrentPrimitiveScorer();
-            }
+          if ( CheckMeshPS(mesh,token[0]) ){
+              G4PSDoseDeposit3D* ps = new G4PSDoseDeposit3D(token[0]);
+              ps->SetUnit(token[1]);
+              mesh->SetPrimitiveScorer(ps);
+          }
       } else if(command== qnOfStepCmd) {
-            if(!mesh->FindPrimitiveScorer(newVal))  {
-              mesh->SetPrimitiveScorer(new G4PSNofStep3D(newVal));
-            } else {
-              G4cout << "WARNING[" << qnOfStepCmd->GetCommandPath()
-                     << "] : Quantity name, \"" << newVal << "\", is already existing." << G4endl;
-              mesh->SetNullToCurrentPrimitiveScorer();
-            }
+          if ( CheckMeshPS(mesh,token[0]) ){
+              G4PSNofStep3D* ps = new G4PSNofStep3D(token[0]);
+              mesh->SetPrimitiveScorer(ps);
+          }
       } else if(command== qnOfSecondaryCmd) {
-            if(!mesh->FindPrimitiveScorer(newVal))  {
-              mesh->SetPrimitiveScorer(new G4PSNofSecondary3D(newVal));
-            } else {
-              G4cout << "WARNING[" << qnOfSecondaryCmd->GetCommandPath()
-                     << "] : Quantity name, \"" << newVal << "\", is already existing." << G4endl;
-              mesh->SetNullToCurrentPrimitiveScorer();
-            }
+          if ( CheckMeshPS(mesh,token[0]) ){
+              G4PSNofSecondary3D* ps =new G4PSNofSecondary3D(token[0]);
+              mesh->SetPrimitiveScorer(ps);
+          }
       } else if(command== qTrackLengthCmd) {
-            if(!mesh->FindPrimitiveScorer(newVal)) {
+          if ( CheckMeshPS(mesh,token[0]) ){
               G4PSTrackLength3D* ps = new G4PSTrackLength3D(token[0]);
               ps->Weighted(StoB(token[1]));
               ps->MultiplyKineticEnergy(StoB(token[2]));
               ps->DivideByVelocity(StoB(token[3]));
-              mesh->SetPrimitiveScorer(ps);
-            } else {
-              G4cout << "WARNING[" << qTrackLengthCmd->GetCommandPath()
-                     << "] : Quantity name, \"" << newVal << "\", is already existing." << G4endl;
-              mesh->SetNullToCurrentPrimitiveScorer();
-            }
+              ps->SetUnit(token[4]);
+              mesh->SetPrimitiveScorer(ps);
+          }
       } else if(command== qPassCellCurrCmd){
-            if(!mesh->FindPrimitiveScorer(newVal)) {
+          if( CheckMeshPS(mesh,token[0]) ) {
               G4PSPassageCellCurrent* ps = new G4PSPassageCellCurrent3D(token[0]);
               ps->Weighted(StoB(token[1]));
-              mesh->SetPrimitiveScorer(ps);
-            } else {
-              G4cout << "WARNING[" << qPassCellCurrCmd->GetCommandPath()
-                     << "] : Quantity name, \"" << newVal << "\", is already existing." << G4endl;
-              mesh->SetNullToCurrentPrimitiveScorer();
-            }
+              //ps->SetUnit(token[2]);
+              mesh->SetPrimitiveScorer(ps);
+          }
       } else if(command== qPassTrackLengthCmd){
-            if(!mesh->FindPrimitiveScorer(newVal)) {
+          if( CheckMeshPS(mesh,token[0]) ) {
               G4PSPassageTrackLength* ps = new G4PSPassageTrackLength3D(token[0]);
               ps->Weighted(StoB(token[1]));
               mesh->SetPrimitiveScorer(ps);
-            } else {
-              G4cout << "WARNING[" << qPassTrackLengthCmd->GetCommandPath()
-                     << "] : Quantity name, \"" << newVal << "\", is already existing." << G4endl;
-              mesh->SetNullToCurrentPrimitiveScorer();
-            }
+          }
       } else if(command== qFlatSurfCurrCmd){
-            if(!mesh->FindPrimitiveScorer(newVal)) {
+          if( CheckMeshPS(mesh,token[0])) {
               G4PSFlatSurfaceCurrent3D* ps = 
                 new G4PSFlatSurfaceCurrent3D(token[0],StoI(token[1]));
               ps->Weighted(StoB(token[2]));
               ps->DivideByArea(StoB(token[3]));
-              mesh->SetPrimitiveScorer(ps);
-            } else {
-              G4cout << "WARNING[" << qFlatSurfCurrCmd->GetCommandPath()
-                     << "] : Quantity name, \"" << newVal << "\", is already existing." << G4endl;
-              mesh->SetNullToCurrentPrimitiveScorer();
-            }
+              ps->SetUnit(token[4]);
+              mesh->SetPrimitiveScorer(ps);
+          }
       } else if(command== qFlatSurfFluxCmd){
-            if(!mesh->FindPrimitiveScorer(newVal)) {
-              mesh->SetPrimitiveScorer(
-                                       new G4PSFlatSurfaceFlux3D(token[0],StoI(token[1])));
-            } else {
-              G4cout << "WARNING[" << qFlatSurfFluxCmd->GetCommandPath()
-                     << "] : Quantity name, \"" << newVal << "\", is already existing." << G4endl;
-              mesh->SetNullToCurrentPrimitiveScorer();
-            }
-//        } else if(command== qSphereSurfCurrCmd){
-//          if(!mesh->FindPrimitiveScorer(newVal)) {
+          if( CheckMeshPS(mesh, token[0] )) {
+              G4PSFlatSurfaceFlux3D* ps = new G4PSFlatSurfaceFlux3D(token[0],StoI(token[1]));
+              ps->SetUnit(token[2]);
+              mesh->SetPrimitiveScorer(ps);
+          }
+//    } else if(command== qSphereSurfCurrCmd){
+//        if( CheckMeshPS(mesh, token[0] )) {
 //            G4PSSphereSurfaceCurrent3D* ps = 
 //              new G4PSSphereSurfaceCurrent3D(token[0],StoI(token[1]));
 //            ps->Weighted(StoB(token[2]));
 //            ps->DivideByArea(StoB(token[3]));
+//            ps->SetUnit(token[4]);
 //            mesh->SetPrimitiveScorer(ps);
-//          } else {
-//            G4cout << "WARNING[" << qSphereSurfCurrCmd->GetCommandPath()
-//                   << "] : Quantity name, \"" << newVal << "\", is already existing." << G4endl;
-//            mesh->SetNullToCurrentPrimitiveScorer();
-//          }
-//        } else if(command== qSphereSurfFluxCmd){
-//          if(!mesh->FindPrimitiveScorer(newVal)) {
-//            mesh->SetPrimitiveScorer(
-//                                     new G4PSSphereSurfaceFlux3D(token[0], StoI(token[1])));
-//          } else {
-//            G4cout << "WARNING[" << qSphereSurfFluxCmd->GetCommandPath()
-//                   << "] : Quantity name, \"" << newVal << "\", is already existing." << G4endl;
-//            mesh->SetNullToCurrentPrimitiveScorer();
-//          }
-//        } else if(command== qCylSurfCurrCmd){
-//          if(!mesh->FindPrimitiveScorer(newVal)) {
+//        }
+//   } else if(command== qSphereSurfFluxCmd){
+//        if( CheckMeshPS(mesh,token[0])) {
+//            G4PSSphereSurfaceFlux3D* ps = new G4PSSphereSurfaceFlux3D(token[0], StoI(token[1]));
+//            ps->SetUnit(token[2]);       
+//            mesh->SetPrimitiveScorer(ps);
+//        }
+//   } else if(command== qCylSurfCurrCmd){
+//        if( CheckMeshPS(mesh, token[0] ) ) {
 //            G4PSCylinderSurfaceCurrent3D* ps = 
 //              new G4PSCylinderSurfaceCurrent3D(token[0],StoI(token[1]));
 //            ps->Weighted(StoB(token[2]));
 //            ps->DivideByArea(StoB(token[3]));
+//            ps->SetUnit(token[4]);
 //            mesh->SetPrimitiveScorer(ps);
-//          } else {
-//            G4cout << "WARNING[" << qCylSurfCurrCmd->GetCommandPath()
-//                   << "] : Quantity name, \"" << newVal << "\", is already existing." << G4endl;
-//            mesh->SetNullToCurrentPrimitiveScorer();
-//          }
-//        } else if(command== qCylSurfFluxCmd){
-//          if(!mesh->FindPrimitiveScorer(newVal)) {
-//            mesh->SetPrimitiveScorer(
-//                                     new G4PSCylinderSurfaceFlux3D(token[0], StoI(token[1])));
-//          } else {
-//            G4cout << "WARNING[" << qCylSurfFluxCmd->GetCommandPath()
-//                   << "] : Quantity name, \"" << newVal << "\", is already existing." << G4endl;
-//            mesh->SetNullToCurrentPrimitiveScorer();
-//          }
+//        }
+//   } else if(command== qCylSurfFluxCmd){
+//        if( CheckMeshPS(mesh, token[0] ) {
+//            G4PSCylinerSurfaceFlux3D* ps =new G4PSCylinderSurfaceFlux3D(token[0], StoI(token[1]));
+//            ps->SetUnit(token[2]);
+//            mesh->SetPrimitiveScorer(ps);
+//        }
       } else if(command== qNofCollisionCmd){
-            if(!mesh->FindPrimitiveScorer(newVal)) {
+          if( CheckMeshPS(mesh,token[0])) {
               G4PSNofCollision3D* ps =new G4PSNofCollision3D(token[0]); 
               ps->Weighted(StoB(token[1]));
               mesh->SetPrimitiveScorer(ps);
-            } else {
-              G4cout << "WARNING[" << qNofCollisionCmd->GetCommandPath()
-                     << "] : Quantity name, \"" << newVal << "\", is already existing." << G4endl;
-              mesh->SetNullToCurrentPrimitiveScorer();
-            }
+          }
       } else if(command== qPopulationCmd){
-            if(!mesh->FindPrimitiveScorer(newVal)) {
+          if( CheckMeshPS(mesh,token[0]) ) {
               G4PSPopulation3D* ps =new G4PSPopulation3D(token[0]); 
               ps->Weighted(StoB(token[1]));
               mesh->SetPrimitiveScorer(ps);
-            } else {
-              G4cout << "WARNING[" << qPopulationCmd->GetCommandPath()
-                     << "] : Quantity name, \"" << newVal << "\", is already existing." << G4endl;
-              mesh->SetNullToCurrentPrimitiveScorer();
-            }
+          }
       } else if(command== qTrackCountCmd){
-            if(!mesh->FindPrimitiveScorer(newVal)) {
+          if( CheckMeshPS(mesh,token[0])) {
               G4PSTrackCounter3D* ps =new G4PSTrackCounter3D(token[0],StoI(token[1])); 
               mesh->SetPrimitiveScorer(ps);
-            } else {
-              G4cout << "WARNING[" << qTrackCountCmd->GetCommandPath()
-                     << "] : Quantity name, \"" << newVal << "\", is already existing." << G4endl;
-              mesh->SetNullToCurrentPrimitiveScorer();
-            }
+          }
       } else if(command== qTerminationCmd){
-            if(!mesh->FindPrimitiveScorer(newVal)) {
+          if( CheckMeshPS(mesh,token[0])) {
               G4PSTermination3D* ps =new G4PSTermination3D(token[0]); 
               ps->Weighted(StoB(token[1]));
               mesh->SetPrimitiveScorer(ps);
-            } else {
-              G4cout << "WARNING[" << qTerminationCmd->GetCommandPath()
-                     << "] : Quantity name, \"" << newVal << "\", is already existing." << G4endl;
-              mesh->SetNullToCurrentPrimitiveScorer();
-            }
+          }
+
+      } else if(command== qMinKinEAtGeneCmd){
+          if( CheckMeshPS(mesh,token[0]) ){
+              G4PSMinKinEAtGeneration3D* ps =new G4PSMinKinEAtGeneration3D(token[0]); 
+              ps->SetUnit(token[1]);
+              mesh->SetPrimitiveScorer(ps);
+          }
 
             //
@@ -488 +447 @@
     mesh->SetFilter(filter);
 }
- 
+
+G4bool G4ScoreQuantityMessenger::CheckMeshPS(G4VScoringMesh* mesh, G4String& psname){
+    if(!mesh->FindPrimitiveScorer(psname)) {
+        return true;
+    } else {
+        G4cout << "WARNING[" << qTouchCmd->GetCommandPath()
+               << "] : Quantity name, \"" << psname << "\", is already existing." << G4endl;
+        mesh->SetNullToCurrentPrimitiveScorer();
+        return false;
+    }
+}

trunk/source/digits_hits/utils/src/G4ScoreQuantityMessengerQCmd.cc

@@ -25 +25 @@
 //
 //
-// $Id: G4ScoreQuantityMessengerQCmd.cc,v 1.6 2007/11/07 04:12:07 akimura Exp $
-// GEANT4 tag $Name: geant4-09-04-beta-01 $
-//
+// $Id: G4ScoreQuantityMessengerQCmd.cc,v 1.8 2010/11/03 08:29:02 taso Exp $
+// GEANT4 tag $Name:  $
+//
+// ---------------------------------------------------------------------
+// Modifications
+// 08-Oct-2010 T.Aso remove unit of G4PSPassageCellCurrent.
 // ---------------------------------------------------------------------
 
@@ -86 +89 @@
   qTouchCmd->SetParameterName("qname",false);
   //
-  qeDepCmd = new G4UIcmdWithAString("/score/quantity/energyDeposit",this);
+  qGetUnitCmd = new G4UIcmdWithoutParameter("/score/quantity/get/unit",this);
+  qGetUnitCmd->SetGuidance("Print output unit of the current quantity.");
+  //
+  qSetUnitCmd = new G4UIcmdWithAString("/score/quantity/set/unit",this);
+  qSetUnitCmd->SetGuidance("Set output unit of the current quantity.");
+  qSetUnitCmd->SetParameterName("unit",false);
+
+  // Primitive Scorers
+  qeDepCmd = new G4UIcommand("/score/quantity/energyDeposit",this);
   qeDepCmd->SetGuidance("Energy deposit scorer.");
-  qeDepCmd->SetParameterName("qname",false);
-  //
-  qCellChgCmd  = new G4UIcmdWithAString("/score/quantity/cellCharge",this);
+  qeDepCmd->
+  SetGuidance("[usage] /score/quantiy/energyDeposit qname unit");
+  qeDepCmd->SetGuidance("  qname  :(String) scorer name");
+  qeDepCmd->SetGuidance("  unit   :(String) unit");
+  param = new G4UIparameter("qname",'s',false);
+  qeDepCmd->SetParameter(param);
+  param = new G4UIparameter("unit",'s',true);
+  param->SetDefaultValue("MeV");
+  qeDepCmd->SetParameter(param);
+  //
+  qCellChgCmd  = new G4UIcommand("/score/quantity/cellCharge",this);
   qCellChgCmd->SetGuidance("Cell charge scorer.");
-  qCellChgCmd->SetParameterName("qname",false);
-  //
-  qCellFluxCmd = new G4UIcmdWithAString("/score/quantity/cellFlux",this);
+  qCellChgCmd->
+  SetGuidance("[usage] /score/quantiy/cellCharge qname unit");
+  qCellChgCmd->SetGuidance("  qname  :(String) scorer name");
+  qCellChgCmd->SetGuidance("  unit   :(String) unit");
+  param = new G4UIparameter("qname",'s',false);
+  qCellChgCmd->SetParameter(param);
+  param = new G4UIparameter("unit",'s',true);
+  param->SetDefaultValue("e+");
+  qCellChgCmd->SetParameter(param);
+  //
+  qCellFluxCmd = new G4UIcommand("/score/quantity/cellFlux",this);
   qCellFluxCmd->SetGuidance("Cell flux scorer.");
-  qCellFluxCmd->SetParameterName("qname",false);
-  //
-  qPassCellFluxCmd = new G4UIcmdWithAString("/score/quantity/passageCellFlux",this);
+  qCellFluxCmd->
+  SetGuidance("[usage] /score/quantiy/cellFlux qname unit");
+  qCellFluxCmd->SetGuidance("  qname  :(String) scorer name");
+  qCellFluxCmd->SetGuidance("  unit   :(String) unit");
+  param = new G4UIparameter("qname",'s',false);
+  qCellFluxCmd->SetParameter(param);
+  param = new G4UIparameter("unit",'s',true);
+  param->SetDefaultValue("percm2");
+  qCellFluxCmd->SetParameter(param);
+  //
+  qPassCellFluxCmd = new G4UIcommand("/score/quantity/passageCellFlux",this);
   qPassCellFluxCmd->SetGuidance("Passage cell flux scorer");
-  qPassCellFluxCmd->SetParameterName("qname",false);
-  //
-  qdoseDepCmd = new G4UIcmdWithAString("/score/quantity/doseDeposit",this);
+  qPassCellFluxCmd->
+  SetGuidance("[usage] /score/quantiy/passageCellFlux qname unit");
+  qPassCellFluxCmd->SetGuidance("  qname  :(String) scorer name");
+  qPassCellFluxCmd->SetGuidance("  unit   :(String) unit");
+  param = new G4UIparameter("qname",'s',false);
+  qPassCellFluxCmd->SetParameter(param);
+  param = new G4UIparameter("unit",'s',true);
+  param->SetDefaultValue("percm2");
+  qPassCellFluxCmd->SetParameter(param);
+  //
+  qdoseDepCmd = new G4UIcommand("/score/quantity/doseDeposit",this);
   qdoseDepCmd->SetGuidance("Dose deposit scorer.");
-  qdoseDepCmd->SetParameterName("qname",false);
-  //
-  qnOfStepCmd = new G4UIcmdWithAString("/score/quantity/nOfStep",this);
+  qdoseDepCmd->
+  SetGuidance("[usage] /score/quantiy/doseDeposit qname unit");
+  qdoseDepCmd->SetGuidance("  qname  :(String) scorer name");
+  qdoseDepCmd->SetGuidance("  unit   :(String) unit");
+  param = new G4UIparameter("qname",'s',false);
+  qdoseDepCmd->SetParameter(param);
+  param = new G4UIparameter("unit",'s',true);
+  param->SetDefaultValue("Gy");
+  qdoseDepCmd->SetParameter(param);
+  //
+  qnOfStepCmd = new G4UIcommand("/score/quantity/nOfStep",this);
   qnOfStepCmd->SetGuidance("Number of step scorer.");
-  qnOfStepCmd->SetParameterName("qname",false);
-  //
-  qnOfSecondaryCmd = new G4UIcmdWithAString("/score/quantity/nOfSecondary",this);
+  qnOfStepCmd->
+  SetGuidance("[usage] /score/quantiy/nOfStep qname");
+  qnOfStepCmd->SetGuidance("  qname  :(String) scorer name");
+  param = new G4UIparameter("qname",'s',false);
+  qnOfStepCmd->SetParameter(param);
+  //
+  qnOfSecondaryCmd = new G4UIcommand("/score/quantity/nOfSecondary",this);
   qnOfSecondaryCmd->SetGuidance("Number of secondary scorer.");
-  qnOfSecondaryCmd->SetParameterName("qname",false);
+  qnOfSecondaryCmd->
+  SetGuidance("[usage] /score/quantiy/nOfSecondary qname");
+  qnOfSecondaryCmd->SetGuidance("  qname  :(String) scorer name");
+  param = new G4UIparameter("qname",'s',false);
+  qnOfSecondaryCmd->SetParameter(param);
   //
   qTrackLengthCmd = new G4UIcommand("/score/quantity/trackLength",this);
   qTrackLengthCmd->SetGuidance("Track length scorer.");
   qTrackLengthCmd->
-      SetGuidance("[usage] /score/quantiy/trackLength qname wflag kflag vflag ");
+  SetGuidance("[usage] /score/quantiy/trackLength qname wflag kflag vflag unit");
   qTrackLengthCmd->SetGuidance("  qname  :(String) scorer name");
   qTrackLengthCmd->SetGuidance("  wflag  :(Bool) weighted");
   qTrackLengthCmd->SetGuidance("  kflag  :(Bool) multiply kinetic energy");
   qTrackLengthCmd->SetGuidance("  vflag  :(Bool) divide by velocity");
+  qTrackLengthCmd->SetGuidance("  unit   :(String) unit");
   param = new G4UIparameter("qname",'s',false);
   qTrackLengthCmd->SetParameter(param);
@@ -132 +192 @@
   param = new G4UIparameter("vflag",'b',true);
   param->SetDefaultValue("false");
+  qTrackLengthCmd->SetParameter(param);
+  param = new G4UIparameter("unit",'s',true);
+  param->SetDefaultValue("mm");
   qTrackLengthCmd->SetParameter(param);
   //
@@ -137 +200 @@
   qPassCellCurrCmd->SetGuidance("Passage cell current scorer.");
   qPassCellCurrCmd->
-      SetGuidance("[usage] /score/quantiy/passageCellCurrent qname wflag");
+    SetGuidance("[usage] /score/quantiy/passageCellCurrent qname wflag");
+    //SetGuidance("[usage] /score/quantiy/passageCellCurrent qname wflag unit");
   qPassCellCurrCmd->SetGuidance("  qname  :(String) scorer name");
   qPassCellCurrCmd->SetGuidance("  wflag  :(Bool) weighted");
+  //qPassCellCurrCmd->SetGuidance("  unit  :(Bool) unit");
   param = new G4UIparameter("qname",'s',false);
   qPassCellCurrCmd->SetParameter(param);
@@ -145 +210 @@
   param->SetDefaultValue("true");
   qPassCellCurrCmd->SetParameter(param);
+  //param = new G4UIparameter("unit",'s',true);
+  //param->SetDefaultValue("parcm2");
+  //qPassCellCurrCmd->SetParameter(param);
   //
   qPassTrackLengthCmd = new G4UIcommand("/score/quantity/passageTrackLength",this);
   qPassTrackLengthCmd->SetGuidance("Passage track length scorer.");
   qPassTrackLengthCmd->
-      SetGuidance("[usage] /score/quantiy/passageTrackLength qname wflag");
+  SetGuidance("[usage] /score/quantiy/passageTrackLength qname wflag unit");
   qPassTrackLengthCmd->SetGuidance("  qname  :(String) scorer name");
   qPassTrackLengthCmd->SetGuidance("  wflag  :(Bool) weighted");
+  qPassTrackLengthCmd->SetGuidance("  unit   :(Bool) unit");
   param = new G4UIparameter("qname",'s',false);
   qPassTrackLengthCmd->SetParameter(param);
   param = new G4UIparameter("wflag",'b',true);
   param->SetDefaultValue("true");
+  qPassTrackLengthCmd->SetParameter(param);
+  param = new G4UIparameter("unit",'s',true);
+  param->SetDefaultValue("mm");
   qPassTrackLengthCmd->SetParameter(param);
   //
@@ -161 +233 @@
   qFlatSurfCurrCmd->SetGuidance("Flat surface current Scorer.");
   qFlatSurfCurrCmd->
-      SetGuidance("[usage] /score/quantiy/flatSurfaceCurrent qname dflag wflag aflag");
+  SetGuidance("[usage] /score/quantiy/flatSurfaceCurrent qname dflag wflag aflag unit");
   qFlatSurfCurrCmd->SetGuidance("  qname  :(String) scorer name");
   qFlatSurfCurrCmd->SetGuidance("  dflag  :(Int) direction flag");
@@ -169 +241 @@
   qFlatSurfCurrCmd->SetGuidance("  wflag  :(Bool) weighted");
   qFlatSurfCurrCmd->SetGuidance("  aflag  :(Bool) divide by area");
+  qFlatSurfCurrCmd->SetGuidance("  unit   :(Bool) unit");
   param = new G4UIparameter("qname",'s',false);
   qFlatSurfCurrCmd->SetParameter(param);
@@ -180 +253 @@
   param->SetDefaultValue("true");
   qFlatSurfCurrCmd->SetParameter(param);
+  param = new G4UIparameter("unit",'s',true);
+  param->SetDefaultValue("percm2");
+  qFlatSurfCurrCmd->SetParameter(param);
   //
   qFlatSurfFluxCmd = new G4UIcommand("/score/quantity/flatSurfaceFlux",this);
   qFlatSurfFluxCmd->SetGuidance("Flat surface flux scorer.");
   qFlatSurfFluxCmd->
-      SetGuidance("[usage] /score/quantiy/flatSurfaceFlux qname dflag");
+  SetGuidance("[usage] /score/quantiy/flatSurfaceFlux qname dflag unit");
   qFlatSurfFluxCmd->SetGuidance("  qname  :(String) scorer name");
   qFlatSurfFluxCmd->SetGuidance("  dflag  :(Int) direction flag");
@@ -190 +266 @@
   qFlatSurfFluxCmd->SetGuidance("         : 1 = In only");
   qFlatSurfFluxCmd->SetGuidance("         : 2 = Out only");
+  qFlatSurfFluxCmd->SetGuidance("  unit   :(String) unit");
   param = new G4UIparameter("qname",'s',false);
   qFlatSurfFluxCmd->SetParameter(param);
@@ -195 +272 @@
   param->SetDefaultValue("0");
   qFlatSurfFluxCmd->SetParameter(param);
+  param = new G4UIparameter("unit",'s',true);
+  param->SetDefaultValue("percm2");
+  qFlatSurfFluxCmd->SetParameter(param);
   //
 //  qSphereSurfCurrCmd = new G4UIcommand("/score/quantity/sphereSurfaceCurrent",this);
 //  qSphereSurfCurrCmd->SetGuidance("Sphere surface current Scorer.");
 //  qSphereSurfCurrCmd->
-//      SetGuidance("[usage] /score/quantiy/sphereSurfaceCurrent qname dflag wflag aflag");
+//      SetGuidance("[usage] /score/quantiy/sphereSurfaceCurrent qname dflag wflag aflag unit");
 //  qSphereSurfCurrCmd->SetGuidance("  qname  :(String) scorer name");
 //  qSphereSurfCurrCmd->SetGuidance("  dflag  :(Int) direction flag");
@@ -207 +287 @@
 //  qSphereSurfCurrCmd->SetGuidance("  wflag  :(Bool) Weighted");
 //  qSphereSurfCurrCmd->SetGuidance("  aflag  :(Bool) DivideByArea");
+//  qSphereSurfCurrCmd->SetGuidance("  unit   :(String) unit");
 //  param = new G4UIparameter("qname",'s',false);
 //  qSphereSurfCurrCmd->SetParameter(param);
@@ -218 +299 @@
 //  param->SetDefaultValue("true");
 //  qSphereSurfCurrCmd->SetParameter(param);
+//  param = new G4UIparameter("unit",'s',true);
+//  param->SetDefaultValue("percm2");
+//  qSphereSurfCurrCmd->SetParameter(param);
 
   //
@@ -223 +307 @@
 //  qSphereSurfFluxCmd->SetGuidance("Sphere surface Flux Scorer.");
 //  qSphereSurfFluxCmd->
-//      SetGuidance("[usage] /score/quantiy/sphereSurfaceFlux qname dflag");
+//  SetGuidance("[usage] /score/quantiy/sphereSurfaceFlux qname dflag unit");
 //  qSphereSurfFluxCmd->SetGuidance("  qname  :(String) scorer name");
 //  qSphereSurfFluxCmd->SetGuidance("  dflag  :(Int) direction flag");
@@ -229 +313 @@
 //  qSphereSurfFluxCmd->SetGuidance("         : 1 = In only");
 //  qSphereSurfFluxCmd->SetGuidance("         : 2 = Out only");
+//  qSphereSurfFluxCmd->SetGuidance("  unit   :(String) unit");
 //  param = new G4UIparameter("qname",'s',false);
 //  qSphereSurfFluxCmd->SetParameter(param);
@@ -234 +319 @@
 //  param->SetDefaultValue("0");
 //  qSphereSurfFluxCmd->SetParameter(param);
+//  param = new G4UIparameter("unit",'s',true);
+//  param->SetDefaultValue("percm2");
+//  qSphereSurfFluxCmd->SetParameter(param);
 
   //
@@ -239 +327 @@
 //  qCylSurfCurrCmd->SetGuidance("Cylinder surface current Scorer.");
 //  qCylSurfCurrCmd->
-//      SetGuidance("[usage] /score/quantiy/cylinderSurfaceCurrent qname dflag wflag aflag");
+//  SetGuidance("[usage] /score/quantiy/cylinderSurfaceCurrent qname dflag wflag aflag unit");
 //  qCylSurfCurrCmd->SetGuidance("  qname  :(String) scorer name");
 //  qCylSurfCurrCmd->SetGuidance("  dflag  :(Int) direction flag");
@@ -247 +335 @@
 //  qCylSurfCurrCmd->SetGuidance("  wflag  :(Bool) Weighted");
 //  qCylSurfCurrCmd->SetGuidance("  aflag  :(Bool) DivideByArea");
+//  qCylSurfCurrCmd->SetGuidance("  unit   :(String) unit");
 //  param = new G4UIparameter("qname",'s',false);
 //  qCylSurfCurrCmd->SetParameter(param);
@@ -258 +347 @@
 //  param->SetDefaultValue("true");
 //  qCylSurfCurrCmd->SetParameter(param);
+//  param = new G4UIparameter("unit",'s',true);
+//  param->SetDefaultValue("percm2");
+//  qCylSurfCurrCmd->SetParameter(param);
   //
 //  qCylSurfFluxCmd = new G4UIcommand("/score/quantity/cylinderSurfaceFlux",this);
 //  qCylSurfFluxCmd->SetGuidance("Cylinder surface Flux Scorer.");
 //  qCylSurfFluxCmd->
-//      SetGuidance("[usage] /score/quantiy/cylinderSurfaceFlux qname dflag");
+//  SetGuidance("[usage] /score/quantiy/cylinderSurfaceFlux qname dflag unit");
 //  qCylSurfFluxCmd->SetGuidance("  qname  :(String) scorer name");
 //  qCylSurfFluxCmd->SetGuidance("  dflag  :(Int) direction flag");
@@ -268 +360 @@
 //  qCylSurfFluxCmd->SetGuidance("         : 1 = In only");
 //  qCylSurfFluxCmd->SetGuidance("         : 2 = Out only");
+//  qCylSurfFluxCmd->SetGuidance("  unit   :(String) unit");
 //  param = new G4UIparameter("qname",'s',false);
 //  qCylSurfFluxCmd->SetParameter(param);
@@ -273 +366 @@
 //  param->SetDefaultValue("0");
 //  qCylSurfFluxCmd->SetParameter(param);
+//  param = new G4UIparameter("unit",'s',true);
+//  param->SetDefaultValue("percm2");
+//  qCylSurfFluxCmd->SetParameter(param);
+//
   //
   qNofCollisionCmd = new G4UIcommand("/score/quantity/nOfCollision",this);
   qNofCollisionCmd->SetGuidance("Number of collision scorer.");
   qNofCollisionCmd->
-      SetGuidance("[usage] /score/quantiy/nOfCollision qname wflag");
+  SetGuidance("[usage] /score/quantiy/nOfCollision qname wflag");
   qNofCollisionCmd->SetGuidance("  qname  :(String) scorer name");
-  qNofCollisionCmd->SetGuidance("  wflag  :(Bool) weighted");
   param = new G4UIparameter("qname",'s',false);
   qNofCollisionCmd->SetParameter(param);
@@ -289 +385 @@
   qPopulationCmd->SetGuidance("Population scorer.");
   qPopulationCmd->
-      SetGuidance("[usage] /score/quantiy/population qname wflag");
+   SetGuidance("[usage] /score/quantiy/population qname wflag");
   qPopulationCmd->SetGuidance("  qname  :(String) scorer name");
   qPopulationCmd->SetGuidance("  wflag  :(Bool) weighted");
@@ -302 +398 @@
   qTrackCountCmd->SetGuidance("Number of track scorer.");
   qTrackCountCmd->
-      SetGuidance("[usage] /score/quantiy/nOfTrack qname dflag wflag");
+  SetGuidance("[usage] /score/quantiy/nOfTrack qname dflag wflag");
   qTrackCountCmd->SetGuidance("  qname  :(String) scorer name");
   qTrackCountCmd->SetGuidance("  dflag  :(Int) direction");
@@ -330 +426 @@
   param->SetDefaultValue("false");
   qTerminationCmd->SetParameter(param);
+
+  //
+  qMinKinEAtGeneCmd = new G4UIcommand("/score/quantity/minKinEAtGeneration",this);
+  qMinKinEAtGeneCmd->SetGuidance("Min Kinetic Energy at Generation");
+  qMinKinEAtGeneCmd->
+  SetGuidance("[usage] /score/quantiy/minKinEAtGeneration qname");
+  qMinKinEAtGeneCmd->SetGuidance("  qname  :(String) scorer name");
+  param = new G4UIparameter("qname",'s',false);
+  qMinKinEAtGeneCmd->SetParameter(param);
 }
 

trunk/source/digits_hits/utils/src/G4ScoringBox.cc

@@ -25 +25 @@
 //
 //
-// $Id: G4ScoringBox.cc,v 1.54 2008/08/29 02:50:05 akimura Exp $
-// GEANT4 tag $Name: geant4-09-04-beta-01 $
+// $Id: G4ScoringBox.cc,v 1.61 2010/07/27 01:44:54 akimura Exp $
+// GEANT4 tag $Name:  $
 //
 
@@ -37 +37 @@
 #include "G4PVReplica.hh"
 #include "G4PVDivision.hh"
-#include "G4PVParameterised.hh"
 #include "G4VisAttributes.hh"
-#include "G4ScoringBoxParameterisation.hh"
 #include "G4VVisManager.hh"
 #include "G4VScoreColorMap.hh"
@@ -57 +55 @@
 {
   fShape = boxMesh;
+  fDivisionAxisNames[0] = "X";
+  fDivisionAxisNames[1] = "Y";
+  fDivisionAxisNames[2] = "Z";
 }
 
@@ -186 +187 @@
                                       fSize[2]/fNSegment[2]);
   fMeshElementLogical = new G4LogicalVolume(elementSolid, 0, elementName);
-  if(fNSegment[2] > 1) 
-    if(fSegmentPositions.size() > 0) {
-      if(verboseLevel > 9) G4cout << "G4ScoringBox::Construct() : Parameterise to z direction" << G4endl;
-      G4double motherDims[3] ={fSize[0]/fNSegment[0],
-                               fSize[1]/fNSegment[1],
-                               fSize[2]/fNSegment[2]};
-      G4int nelement = fNSegment[2];
-      fSegmentPositions.push_back(fSize[2]*2.);
-      //G4ScoringBoxParameterisation * param =
-      G4VPVParameterisation * param =
-        new G4ScoringBoxParameterisation(kZAxis, motherDims, fSegmentPositions);
-      new G4PVParameterised(elementName,
-                            fMeshElementLogical,
-                            layerLogical[1],
-                            kZAxis,
-                            nelement,
-                            param);
-
-      if(verboseLevel > 9) {
-        G4cout << motherDims[0] << ", " << motherDims[1] << ", " << motherDims[2] << G4endl;
-        for(int i = 0; i < (int)fSegmentPositions.size(); i++)
-          G4cout << fSegmentPositions[i] << ", ";
-        G4cout << G4endl;
-      }
-
-    } else {
-      if(verboseLevel > 9) G4cout << "G4ScoringBox::Construct() : Replicate to z direction" << G4endl;
-
-      if(G4ScoringManager::GetReplicaLevel()>2)
-      { 
-        new G4PVReplica(elementName, fMeshElementLogical, layerLogical[1], kZAxis,
+  if(fNSegment[2] > 1) {
+    if(verboseLevel > 9) G4cout << "G4ScoringBox::Construct() : Replicate to z direction" << G4endl;
+
+    if(G4ScoringManager::GetReplicaLevel()>2) 
+    { 
+      new G4PVReplica(elementName, fMeshElementLogical, layerLogical[1], kZAxis,
                       fNSegment[2], 2.*fSize[2]/fNSegment[2]);
-      }
-      else
-      {
-        new G4PVDivision(elementName, fMeshElementLogical, layerLogical[1], kZAxis,
-                      fNSegment[2], 0.);
-      }
-    }
-  else if(fNSegment[2] == 1) {
+    }
+    else
+    {
+      new G4PVDivision(elementName, fMeshElementLogical, layerLogical[1], kZAxis,
+                       fNSegment[2], 0.);
+    }
+  } else if(fNSegment[2] == 1) {
     if(verboseLevel > 9) G4cout << "G4ScoringBox::Construct() : Placement" << G4endl;
     new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), fMeshElementLogical, elementName, layerLogical[1], false, 0);
@@ -292 +267 @@
     for(int x = 0; x < fNSegment[0]; x++) xzcell.push_back(ez);
 
+    // search max. & min. values in each slice
     G4double xymin = DBL_MAX, yzmin = DBL_MAX, xzmin = DBL_MAX;
     G4double xymax = 0., yzmax = 0., xzmax = 0.;
@@ -299 +275 @@
       GetXYZ(itr->first, q);
 
-      xycell[q[0]][q[1]] += *(itr->second);
+      xycell[q[0]][q[1]] += *(itr->second)/fDrawUnitValue;
       if(xymin > xycell[q[0]][q[1]]) xymin = xycell[q[0]][q[1]];
       if(xymax < xycell[q[0]][q[1]]) xymax = xycell[q[0]][q[1]];
 
-      yzcell[q[1]][q[2]] += *(itr->second);
+      yzcell[q[1]][q[2]] += *(itr->second)/fDrawUnitValue;
       if(yzmin > yzcell[q[1]][q[2]]) yzmin = yzcell[q[1]][q[2]];
       if(yzmax < yzcell[q[1]][q[2]]) yzmax = yzcell[q[1]][q[2]];
 
-      xzcell[q[0]][q[2]] += *(itr->second);
+      xzcell[q[0]][q[2]] += *(itr->second)/fDrawUnitValue;
       if(xzmin > xzcell[q[0]][q[2]]) xzmin = xzcell[q[0]][q[2]];
       if(xzmax < xzcell[q[0]][q[2]]) xzmax = xzcell[q[0]][q[2]];
@@ -404 +380 @@
     }
   }
+  colorMap->SetPSUnit(fDrawUnit);
+  colorMap->SetPSName(fDrawPSName);
   colorMap->DrawColorChart();
 }
@@ -429 +407 @@
 }
 
-void G4ScoringBox::DrawColumn(std::map<G4int, G4double*> * map, G4VScoreColorMap* colorMap, 
-                          G4int idxProj, G4int idxColumn) 
+void G4ScoringBox::DrawColumn(std::map<G4int, G4double*> * map, G4VScoreColorMap* colorMap,
+                              G4int idxProj, G4int idxColumn) 
 {
   if(idxColumn<0 || idxColumn>=fNSegment[idxProj])
@@ -460 +438 @@
     for(int x = 0; x < fNSegment[0]; x++) xzcell.push_back(ez);
 
+    // search max. & min. values in each slice
     G4double xymax = 0., yzmax = 0., xzmax = 0.;
     G4int q[3];
@@ -467 +446 @@
 
       if(idxProj == 0 && q[2] == idxColumn) { // xy plane
-        xycell[q[0]][q[1]] += *(itr->second);
+        xycell[q[0]][q[1]] += *(itr->second)/fDrawUnitValue;
         if(xymax < xycell[q[0]][q[1]]) xymax = xycell[q[0]][q[1]];
       }
       if(idxProj == 1 && q[0] == idxColumn) { // yz plane
-        yzcell[q[1]][q[2]] += *(itr->second);
+        yzcell[q[1]][q[2]] += *(itr->second)/fDrawUnitValue;
         if(yzmax < yzcell[q[1]][q[2]]) yzmax = yzcell[q[1]][q[2]];
       }
       if(idxProj == 2 && q[1] == idxColumn) { // zx plane
-        xzcell[q[0]][q[2]] += *(itr->second);
+        xzcell[q[0]][q[2]] += *(itr->second)/fDrawUnitValue;
         if(xzmax < xzcell[q[0]][q[2]]) xzmax = xzcell[q[0]][q[2]];
       }
@@ -552 +531 @@
   }
 
+  colorMap->SetPSUnit(fDrawUnit);
+  colorMap->SetPSName(fDrawPSName);
   colorMap->DrawColorChart();
 }

trunk/source/digits_hits/utils/src/G4ScoringCylinder.cc

@@ -25 +25 @@
 //
 //
-// $Id: G4ScoringCylinder.cc,v 1.6 2008/08/29 02:50:05 akimura Exp $
-// GEANT4 tag $Name: geant4-09-04-beta-01 $
+// $Id: G4ScoringCylinder.cc,v 1.16 2010/08/30 08:15:20 akimura Exp $
+// GEANT4 tag $Name:  $
 //
 
@@ -38 +38 @@
 #include "G4PVReplica.hh"
 #include "G4PVDivision.hh"
-#include "G4PVParameterised.hh"
 #include "G4VisAttributes.hh"
-//#include "G4ScoringCylinderParameterisation.hh"
 #include "G4VVisManager.hh"
 #include "G4VScoreColorMap.hh"
@@ -55 +53 @@
 
 G4ScoringCylinder::G4ScoringCylinder(G4String wName)
-  :G4VScoringMesh(wName), fSegmentDirection(-1), 
-   fMeshElementLogical(0)
+  :G4VScoringMesh(wName), fMeshElementLogical(0)
 {
   fShape = cylinderMesh;
+
+  fDivisionAxisNames[0] = "Z";
+  fDivisionAxisNames[1] = "PHI";
+  fDivisionAxisNames[2] = "R";
 }
 
 G4ScoringCylinder::~G4ScoringCylinder()
-{
-}
+{;}
 
 void G4ScoringCylinder::Construct(G4VPhysicalVolume* fWorldPhys)
@@ -91 +91 @@
   // Scoring Mesh
   if(verboseLevel > 9) G4cout << fWorldName << G4endl;
-  G4String tubsName = fWorldName;
-
-  if(verboseLevel > 9) G4cout << fSize[0] << ", " << fSize[1] << G4endl;
+  G4String tubsName = fWorldName+"_mesh";
+
+  if(verboseLevel > 9) G4cout << "R max., Dz =: " << fSize[0] << ", " << fSize[1] << G4endl;
   G4VSolid * tubsSolid = new G4Tubs(tubsName+"0", // name
                                     0.,           // R min
                                     fSize[0],     // R max
-                                    fSize[1],     // dZ
+                                    fSize[1],     // Dz
                                     0.,           // starting phi
-                                    twopi*rad);   // segment phi
+                                    twopi*rad);   // segment phi
   G4LogicalVolume *  tubsLogical = new G4LogicalVolume(tubsSolid, 0, tubsName);
   new G4PVPlacement(fRotationMatrix, fCenterPosition,
                     tubsLogical, tubsName+"0", worldLogical, false, 0);
 
+  if(verboseLevel > 9) G4cout << " # of segments : r, phi, z =: "
+         << fNSegment[IR] << ", " << fNSegment[IPHI] << ", " << fNSegment[IZ] << G4endl;
 
   G4String layerName[2] = {tubsName + "1",  tubsName + "2"};
@@ -109 +111 @@
   G4LogicalVolume * layerLogical[2];
 
-  //-- fisrt nested layer (replicated along r direction)
+  //-- fisrt nested layer (replicated along z direction)
   if(verboseLevel > 9) G4cout << "layer 1 :" << G4endl;
-  layerSolid[0] = new G4Tubs(layerName[0],
-                             0.,
-                             fSize[0]/fNSegment[0],
-                             fSize[1],
-                             0., twopi*rad);
+  layerSolid[0] = new G4Tubs(layerName[0],           // name
+                             0.,                     // inner radius
+                             fSize[0],               // outer radius
+                             fSize[1]/fNSegment[IZ], // half len. in z
+                             0.,                     // starting phi angle
+                             twopi*rad);             // delta angle of the segment
   layerLogical[0] = new G4LogicalVolume(layerSolid[0], 0, layerName[0]);
-  if(fNSegment[0] > 1) {
-    if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replicate along r direction" << G4endl;
-    G4double r = fSize[0]/fNSegment[0];
-    //if(G4ScoringManager::GetReplicaLevel()>0) {
-    if(false) { // always use G4PVDivision
+  if(fNSegment[IZ] > 1) {
+    if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replicate along z direction" << G4endl;
+    if(G4ScoringManager::GetReplicaLevel()>0) {
       if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replica" << G4endl;
-      new G4PVReplica(layerName[0], layerLogical[0], tubsLogical, kRho,
-                      fNSegment[0], r, 0.);
+      new G4PVReplica(layerName[0], layerLogical[0], tubsLogical, kZAxis, fNSegment[IZ], 2.*fSize[1]/fNSegment[IZ]);
     } else {
       if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Division" << G4endl;
-      new G4PVDivision(layerName[0], layerLogical[0], tubsLogical, kRho,
-                       fNSegment[0], 0.);
-    }
-  } else if(fNSegment[0] == 1) {
+      new G4PVDivision(layerName[0], layerLogical[0], tubsLogical, kZAxis, fNSegment[IZ], 0.);
+    }
+  } else if(fNSegment[IZ] == 1) {
     if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Placement" << G4endl;
     new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), layerLogical[0], layerName[0], tubsLogical, false, 0);
   } else {
     G4cerr << "G4ScoringCylinder::SetupGeometry() : invalid parameter ("
-           << fNSegment[0] << ") "
+           << fNSegment[IZ] << ") "
            << "in placement of the first nested layer." << G4endl;
   }
 
-  if(verboseLevel > 9) {
-    G4cout << fSize[0] << ", "
-           << fSize[1] 
-           << G4endl;
-    G4cout << layerName[0] << ": kRho, "
-           << fNSegment[0] << ", "
-           << fSize[0]/fNSegment[0] << G4endl;
-  }
-
-  // second nested layer (replicated along z direction)
+  // second nested layer (replicated along phi direction)
   if(verboseLevel > 9) G4cout << "layer 2 :" << G4endl;
   layerSolid[1] = new G4Tubs(layerName[1],
                              0.,
-                             fSize[0],///fNSegment[0],
-                             fSize[1]/fNSegment[1],
-                             0., twopi*rad);
+                             fSize[0],
+                             fSize[1]/fNSegment[IZ],
+                             0.,
+                             twopi*rad/fNSegment[IPHI]);
   layerLogical[1] = new G4LogicalVolume(layerSolid[1], 0, layerName[1]);
-  if(fNSegment[1] > 1)  {
-    if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replicate along z direction" << G4endl;
-    G4double width = fSize[1]/fNSegment[1]*2.;
-    //if(G4ScoringManager::GetReplicaLevel()>1) {
-    if(false) { // always use G4PVDivision
+  if(fNSegment[IPHI] > 1)  {
+    if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replicate along phi direction" << G4endl;
+    if(G4ScoringManager::GetReplicaLevel()>1) {
       if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replica" << G4endl;
-      new G4PVReplica(layerName[1], layerLogical[1], layerLogical[0], kZAxis,
-                      fNSegment[1], width);
+      new G4PVReplica(layerName[1], layerLogical[1], layerLogical[0], kPhi,
+                      fNSegment[IPHI], twopi*rad/fNSegment[IPHI]);
     } else {
       if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Division" << G4endl;
-      new G4PVDivision(layerName[1], layerLogical[1], layerLogical[0], kZAxis,
-                       fNSegment[1], 0.);
-    }
-  } else if(fNSegment[1] == 1) {
+      new G4PVDivision(layerName[1], layerLogical[1], layerLogical[0], kPhi, fNSegment[IPHI], 0.);
+    }
+  } else if(fNSegment[IPHI] == 1) {
     if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Placement" << G4endl;
     new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), layerLogical[1], layerName[1], layerLogical[0], false, 0);
   } else
     G4cerr << "ERROR : G4ScoringCylinder::SetupGeometry() : invalid parameter ("
-           << fNSegment[1] << ") "
+           << fNSegment[IPHI] << ") "
            << "in placement of the second nested layer." << G4endl;
-
-  if(verboseLevel > 9) {
-    G4cout << fSize[0]/fNSegment[0] << ", "
-           << fSize[1]/fNSegment[1] << G4endl;
-    G4cout << layerName[1] << ": kZAxis, "
-           << fNSegment[1] << ", "
-           << fSize[1]/fNSegment[1] << G4endl;
-  }
-
 
   // mesh elements
@@ -191 +170 @@
   G4VSolid * elementSolid = new G4Tubs(elementName,
                                        0.,
-                                       fSize[0],//fNSegment[0],
-                                       fSize[1]/fNSegment[1],
-                                       0., twopi*rad/fNSegment[2]);
+                                       fSize[0]/fNSegment[IR],
+                                       fSize[1]/fNSegment[IZ],
+                                       0.,
+                                       twopi*rad/fNSegment[IPHI]);
   fMeshElementLogical = new G4LogicalVolume(elementSolid, 0, elementName);
-  if(fNSegment[2] > 1) {
-
-    /*
-    if(fSegmentPositions.size() > 0) {
-      G4double motherDims[3] ={fSize[0]/fsegParam[2][0],
-                               fSize[1]/fsegParam[2][1],
-                               fSize[2]/fsegParam[2][2]};
-      G4int nelement = fSegmentPositions.size() + 1;
-      //G4ScoringCylinderParameterisation * param =
-      G4VPVParameterisation * param =
-        new G4ScoringCylinderParameterisation(axis[2], motherDims, fSegmentPositions);
-      new G4PVParameterised(elementName,
-                            fMeshElementLogical,
-                            layerLogical[1],
-                            axis[2],
-                            nelement,
-                            param);
-    } else {
-    */
-    if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replicate along phi direction" << G4endl;
-
-    G4double angle = twopi*rad/fNSegment[2];
-    //if(G4ScoringManager::GetReplicaLevel()>2) {
-    if(false) { // always use G4PVDivision
+  if(fNSegment[IR] > 1) {
+
+    if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replicate along r direction" << G4endl;
+
+    if(G4ScoringManager::GetReplicaLevel()>2) {
       if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replica" << G4endl;
-      new G4PVReplica(elementName, fMeshElementLogical, layerLogical[1], kPhi,
-                        fNSegment[2], angle, 0.);
+      new G4PVReplica(elementName, fMeshElementLogical, layerLogical[1], kRho,
+                        fNSegment[IR], fSize[0]/fNSegment[IR]);
     } else {
       if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Division" << G4endl;
-      new G4PVDivision(elementName, fMeshElementLogical, layerLogical[1], kPhi,
-                       fNSegment[2], 0.);
-    }
-    //}
-  } else if(fNSegment[2] == 1) {
+      new G4PVDivision(elementName, fMeshElementLogical, layerLogical[1], kRho, fNSegment[IR], 0.);
+    }
+  } else if(fNSegment[IR] == 1) {
     if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Placement" << G4endl;
     new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), fMeshElementLogical, elementName, layerLogical[1], false, 0);
   } else {
     G4cerr << "G4ScoringCylinder::SetupGeometry() : "
-           << "invalid parameter (" << fNSegment[2] << ") "
+           << "invalid parameter (" << fNSegment[IR] << ") "
            << "in mesh element placement." << G4endl;
-  }
-
-  if(verboseLevel > 9) {
-    G4cout << fSize[0]/fNSegment[0] << ", "
-           << fSize[1]/fNSegment[1] << G4endl;
-    G4cout << elementName << ": kPhi, "
-           << fNSegment[2] << G4endl;
   }
 
@@ -249 +201 @@
 
   // vis. attributes
-  G4VisAttributes * visatt = new G4VisAttributes(G4Colour(.5,.5,.5,0.1));
+  G4VisAttributes * visatt = new G4VisAttributes(G4Colour(.5,.5,.5));
   visatt->SetVisibility(true);
-  //layerLogical[0]->SetVisAttributes(visatt);
-  //layerLogical[1]->SetVisAttributes(visatt);
+  layerLogical[0]->SetVisAttributes(visatt);
+  layerLogical[1]->SetVisAttributes(visatt);
   visatt = new G4VisAttributes(G4Colour(.5,.5,.5,0.01));
   //visatt->SetForceSolid(true);
@@ -272 +224 @@
 void G4ScoringCylinder::Draw(std::map<G4int, G4double*> * map, G4VScoreColorMap* colorMap, G4int axflg) {
 
-
   G4VVisManager * pVisManager = G4VVisManager::GetConcreteInstance();
   if(pVisManager) {
     
     // cell vectors
-    std::vector<std::vector<std::vector<double> > > cell; // cell[R][Z][PHI]
     std::vector<double> ephi;
-    for(int phi = 0; phi < fNSegment[2]; phi++) ephi.push_back(0.);
-    std::vector<std::vector<double> > ezphi;
-    for(int z = 0; z < fNSegment[1]; z++) ezphi.push_back(ephi);
-    for(int r = 0; r < fNSegment[0]; r++) cell.push_back(ezphi);
-
-    std::vector<std::vector<double> > rzcell; // rzcell[R][Z]
-    std::vector<double> ez;
-    for(int z = 0; z < fNSegment[1]; z++) ez.push_back(0.);
-    for(int r = 0; r < fNSegment[0]; r++) rzcell.push_back(ez);
-
+    for(int phi = 0; phi < fNSegment[IPHI]; phi++) ephi.push_back(0.);
+    //-
     std::vector<std::vector<double> > zphicell; // zphicell[Z][PHI]
-    for(int z = 0; z < fNSegment[1]; z++) zphicell.push_back(ephi);
-
+    for(int z = 0; z < fNSegment[IZ]; z++) zphicell.push_back(ephi);
+    //-
     std::vector<std::vector<double> > rphicell; // rphicell[R][PHI]
-    for(int r = 0; r < fNSegment[0]; r++) rphicell.push_back(ephi);
+    for(int r = 0; r < fNSegment[IR]; r++) rphicell.push_back(ephi);
 
     // search max. values
-    G4double rzmin = DBL_MAX, zphimin = DBL_MAX, rphimin = DBL_MAX;
-    G4double rzmax = 0., zphimax = 0., rphimax = 0.;
+    G4double zphimin = DBL_MAX, rphimin = DBL_MAX;
+    G4double zphimax = 0., rphimax = 0.;
     G4int q[3];
     std::map<G4int, G4double*>::iterator itr = map->begin();
     for(; itr != map->end(); itr++) {
+      if(itr->first < 0) {
+        G4cout << itr->first << G4endl;
+        continue;
+      }
       GetRZPhi(itr->first, q);
 
-      rzcell[q[0]][q[1]] += *(itr->second);
-      if(rzmin > rzcell[q[0]][q[1]]) rzmin = rzcell[q[0]][q[1]];
-      if(rzmax < rzcell[q[0]][q[1]]) rzmax = rzcell[q[0]][q[1]];
-
-      zphicell[q[1]][q[2]] += *(itr->second);
-      if(zphimin > zphicell[q[1]][q[2]]) zphimin = zphicell[q[1]][q[2]];
-      if(zphimax < zphicell[q[1]][q[2]]) zphimax = zphicell[q[1]][q[2]];
-
-      rphicell[q[0]][q[2]] += *(itr->second);
-      if(rphimin > rphicell[q[0]][q[2]]) rphimin = rphicell[q[0]][q[2]];
-      if(rphimax < rphicell[q[0]][q[2]]) rphimax = rphicell[q[0]][q[2]];
+      // projections
+      zphicell[q[IZ]][q[IPHI]] += *(itr->second)/fDrawUnitValue;
+      if(zphimin > zphicell[q[IZ]][q[IPHI]]) zphimin = zphicell[q[IZ]][q[IPHI]];
+      if(zphimax < zphicell[q[IZ]][q[IPHI]]) zphimax = zphicell[q[IZ]][q[IPHI]];
+      //-
+      rphicell[q[IR]][q[IPHI]] += *(itr->second)/fDrawUnitValue;
+      if(rphimin > rphicell[q[IR]][q[IPHI]]) rphimin = rphicell[q[IR]][q[IPHI]];
+      if(rphimax < rphicell[q[IR]][q[IPHI]]) rphimax = rphicell[q[IR]][q[IPHI]];
     }  
     
@@ -330 +273 @@
       if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(zphimin, zphimax); }
 
-      G4double zhalf = fSize[1]/fNSegment[1];
-      for(int phi = 0; phi < fNSegment[2]; phi++) {
-        for(int z = 0; z < fNSegment[1]; z++) {
-
-          G4double angle = twopi/fNSegment[2]*phi;
-          G4double dphi = twopi/fNSegment[2];
-          G4Tubs cylinder("z-phi", fSize[0]*0.99, fSize[0], zhalf,
-                          angle, dphi*0.99999);
-          /*
-          G4cout << ">>>> "
-                 << fSize[1]/fNSegment[1]/2. << " : "
-                 << angle << " - " << angle + dphi
-                 << G4endl;
-          */
-
-          G4ThreeVector zpos(0., 0., -fSize[1] + fSize[1]/fNSegment[1]*(1 + 2.*z));
+      G4double zhalf = fSize[1]/fNSegment[IZ];
+      for(int phi = 0; phi < fNSegment[IPHI]; phi++) {
+        for(int z = 0; z < fNSegment[IZ]; z++) {
+          //-
+          G4double angle = twopi/fNSegment[IPHI]*phi;
+          G4double dphi = twopi/fNSegment[IPHI];
+          G4Tubs cylinder("z-phi",                    // name
+                          fSize[0]*0.99, fSize[0],  // inner radius, outer radius
+                          zhalf,                      // half length in z
+                          angle, dphi*0.99999);       // starting phi angle, delta angle
+          //-
+          G4ThreeVector zpos(0., 0., -fSize[1] + fSize[1]/fNSegment[IZ]*(1 + 2.*z));
           G4Transform3D trans;
           if(fRotationMatrix) {
@@ -356 +295 @@
           colorMap->GetMapColor(zphicell[z][phi], c);
           att.SetColour(c[0], c[1], c[2]);//, c[3]);
-          /*
-          G4cout << "   " << c[0] << ", "
-                 << c[1] << ", " << c[2] << G4endl;
-          */
+          //-
           pVisManager->Draw(cylinder, att, trans);
         }
@@ -369 +305 @@
       if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(rphimin, rphimax); }
 
-      G4double rsize = fSize[0]/fNSegment[0];
-      for(int phi = 0; phi < fNSegment[2]; phi++) {
-        for(int r = 0; r < fNSegment[0]; r++) {
+      G4double rsize = fSize[0]/fNSegment[IR];
+      for(int phi = 0; phi < fNSegment[IPHI]; phi++) {
+        for(int r = 0; r < fNSegment[IR]; r++) {
 
           G4double rs[2] = {rsize*r, rsize*(r+1)};
-          G4double angle = twopi/fNSegment[2]*phi;
-          G4double dphi = twopi/fNSegment[2];
+          G4double angle = twopi/fNSegment[IPHI]*phi;
+          G4double dphi = twopi/fNSegment[IPHI];
           G4Tubs cylinder("z-phi", rs[0], rs[1], 0.001,
                           angle, dphi*0.99999);
@@ -409 +345 @@
       }
     }
+
+    colorMap->SetPSUnit(fDrawUnit);
+    colorMap->SetPSName(fDrawPSName);
     colorMap->DrawColorChart();
+
   }
 }
@@ -416 +356 @@
                                    G4int idxProj, G4int idxColumn) 
 {
-
-  if(idxColumn<0 || idxColumn>=fNSegment[idxProj])
+  G4int projAxis = 0;
+  switch(idxProj) {
+  case 0: 
+    projAxis = IR;
+    break;
+  case 1:
+    projAxis = IZ;
+    break;
+  case 2:
+    projAxis = IPHI;
+    break;
+  }
+
+  if(idxColumn<0 || idxColumn>=fNSegment[projAxis])
   {
-    G4cerr << "ERROR : Column number " << idxColumn << " is out of scoring mesh [0," << fNSegment[idxProj]-1 <<
+    G4cerr << "Warning : Column number " << idxColumn << " is out of scoring mesh [0," << fNSegment[projAxis]-1 <<
     "]. Method ignored." << G4endl;
     return;
@@ -425 +377 @@
   G4VVisManager * pVisManager = G4VVisManager::GetConcreteInstance();
   if(pVisManager) {
-    
+
     // cell vectors
     std::vector<std::vector<std::vector<double> > > cell; // cell[R][Z][PHI]
     std::vector<double> ephi;
-    for(int phi = 0; phi < fNSegment[2]; phi++) ephi.push_back(0.);
+    for(int phi = 0; phi < fNSegment[IPHI]; phi++) ephi.push_back(0.);
     std::vector<std::vector<double> > ezphi;
-    for(int z = 0; z < fNSegment[1]; z++) ezphi.push_back(ephi);
-    for(int r = 0; r < fNSegment[0]; r++) cell.push_back(ezphi);
+    for(int z = 0; z < fNSegment[IZ]; z++) ezphi.push_back(ephi);
+    for(int r = 0; r < fNSegment[IR]; r++) cell.push_back(ezphi);
 
     std::vector<std::vector<double> > rzcell; // rzcell[R][Z]
     std::vector<double> ez;
-    for(int z = 0; z < fNSegment[1]; z++) ez.push_back(0.);
-    for(int r = 0; r < fNSegment[0]; r++) rzcell.push_back(ez);
+    for(int z = 0; z < fNSegment[IZ]; z++) ez.push_back(0.);
+    for(int r = 0; r < fNSegment[IR]; r++) rzcell.push_back(ez);
 
     std::vector<std::vector<double> > zphicell; // zphicell[Z][PHI]
-    for(int z = 0; z < fNSegment[1]; z++) zphicell.push_back(ephi);
+    for(int z = 0; z < fNSegment[IZ]; z++) zphicell.push_back(ephi);
 
     std::vector<std::vector<double> > rphicell; // rphicell[R][PHI]
-    for(int r = 0; r < fNSegment[0]; r++) rphicell.push_back(ephi);
+    for(int r = 0; r < fNSegment[IR]; r++) rphicell.push_back(ephi);
 
     // search max. values
@@ -450 +402 @@
     std::map<G4int, G4double*>::iterator itr = map->begin();
     for(; itr != map->end(); itr++) {
+      if(itr->first < 0) {
+        G4cout << itr->first << G4endl;
+        continue;
+      }
       GetRZPhi(itr->first, q);
 
-      if(idxProj == 0 && q[0] == idxColumn) { // zphi plane
-        zphicell[q[1]][q[2]] += *(itr->second);
-        if(zphimax < zphicell[q[1]][q[2]]) zphimax = zphicell[q[1]][q[2]];
-      }
-      if(idxProj == 1 && q[1] == idxColumn) { // rphi plane
-        rphicell[q[0]][q[2]] += *(itr->second);
-        if(rphimax < rphicell[q[0]][q[2]]) rphimax = rphicell[q[0]][q[2]];
-      }
-      if(idxProj == 2 && q[2] == idxColumn) { // rz plane
-        rzcell[q[0]][q[1]] += *(itr->second); 
-        if(rzmax < rzcell[q[0]][q[1]]) rzmax = rzcell[q[0]][q[1]];
+      if(projAxis == IR && q[IR] == idxColumn) { // zphi plane
+        zphicell[q[IZ]][q[IPHI]] += *(itr->second)/fDrawUnitValue;
+        if(zphimax < zphicell[q[IZ]][q[IPHI]]) zphimax = zphicell[q[IZ]][q[IPHI]];
+      }
+      if(projAxis == IZ && q[IZ] == idxColumn) { // rphi plane
+        rphicell[q[IR]][q[IPHI]] += *(itr->second)/fDrawUnitValue;
+        if(rphimax < rphicell[q[IR]][q[IPHI]]) rphimax = rphicell[q[IR]][q[IPHI]];
+      }
+      if(projAxis == IPHI && q[IPHI] == idxColumn) { // rz plane
+        rzcell[q[IR]][q[IZ]] += *(itr->second)/fDrawUnitValue; 
+        if(rzmax < rzcell[q[IR]][q[IZ]]) rzmax = rzcell[q[IR]][q[IZ]];
       }
     }  
@@ -472 +428 @@
 
     G4Scale3D scale;
-    // r-phi plane
-    if(idxProj == 0) {
+    // z-phi plane
+    if(projAxis == IR) {
       if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(0.,zphimax); }
 
-      G4double zhalf = fSize[1]/fNSegment[1];
-      G4double rsize[2] = {fSize[0]/fNSegment[0]*idxColumn,
-                           fSize[0]/fNSegment[0]*(idxColumn+1)};
-      for(int phi = 0; phi < fNSegment[2]; phi++) {
-        for(int z = 0; z < fNSegment[1]; z++) {
-
-          G4double angle = twopi/fNSegment[2]*phi*radian;
-          G4double dphi = twopi/fNSegment[2]*radian;
+      G4double zhalf = fSize[1]/fNSegment[IZ];
+      G4double rsize[2] = {fSize[0]/fNSegment[IR]*idxColumn,
+                            fSize[0]/fNSegment[IR]*(idxColumn+1)};
+      for(int phi = 0; phi < fNSegment[IPHI]; phi++) {
+        for(int z = 0; z < fNSegment[IZ]; z++) {
+
+          G4double angle = twopi/fNSegment[IPHI]*phi*radian;
+          G4double dphi = twopi/fNSegment[IPHI]*radian;
           G4Tubs cylinder("z-phi", rsize[0], rsize[1], zhalf,
                           angle, dphi*0.99999);
 
-          G4ThreeVector zpos(0., 0., -fSize[1] + fSize[1]/fNSegment[1]*(1 + 2.*z));
+          G4ThreeVector zpos(0., 0., -fSize[1] + fSize[1]/fNSegment[IZ]*(1 + 2.*z));
           G4Transform3D trans;
           if(fRotationMatrix) {
@@ -503 +459 @@
 
       // r-phi plane
-    } else if(idxProj == 1) {
+    } else if(projAxis == IZ) {
       if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(0.,rphimax); }
 
-      G4double rsize = fSize[0]/fNSegment[0];
-      for(int phi = 0; phi < fNSegment[2]; phi++) {
-        for(int r = 0; r < fNSegment[0]; r++) {
+      G4double rsize = fSize[0]/fNSegment[IR];
+      for(int phi = 0; phi < fNSegment[IPHI]; phi++) {
+        for(int r = 0; r < fNSegment[IR]; r++) {
 
           G4double rs[2] = {rsize*r, rsize*(r+1)};
-          G4double angle = twopi/fNSegment[2]*phi*radian;
-          G4double dz = fSize[1]/fNSegment[1];
-          G4double dphi = twopi/fNSegment[2]*radian;
+          G4double angle = twopi/fNSegment[IPHI]*phi*radian;
+          G4double dz = fSize[1]/fNSegment[IZ];
+          G4double dphi = twopi/fNSegment[IPHI]*radian;
           G4Tubs cylinder("r-phi", rs[0], rs[1], dz,
                           angle, dphi*0.99999);
           G4ThreeVector zpos(0., 0.,
-                             -fSize[1]+fSize[1]/fNSegment[1]*(idxColumn*2+1));
+                             -fSize[1]+fSize[1]/fNSegment[IZ]*(idxColumn*2+1));
           G4Transform3D trans;
           if(fRotationMatrix) {
@@ -533 +489 @@
 
       // r-z plane
-    } else if(idxProj == 2) {
+    } else if(projAxis == IPHI) {
       if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(0.,rzmax); }
 
-      G4double rsize = fSize[0]/fNSegment[0];
-      G4double zhalf = fSize[1]/fNSegment[1];
-      G4double angle = twopi/fNSegment[2]*idxColumn*radian;
-      G4double dphi = twopi/fNSegment[2]*radian;
-      for(int z = 0; z < fNSegment[1]; z++) {
-        for(int r = 0; r < fNSegment[0]; r++) {
+      G4double rsize = fSize[0]/fNSegment[IR];
+      G4double zhalf = fSize[1]/fNSegment[IZ];
+      G4double angle = twopi/fNSegment[IPHI]*idxColumn*radian;
+      G4double dphi = twopi/fNSegment[IPHI]*radian;
+      for(int z = 0; z < fNSegment[IZ]; z++) {
+        for(int r = 0; r < fNSegment[IR]; r++) {
 
           G4double rs[2] = {rsize*r, rsize*(r+1)};
@@ -548 +504 @@
 
           G4ThreeVector zpos(0., 0.,
-                             -fSize[1]+fSize[1]/fNSegment[1]*(2.*z+1));
+                             -fSize[1]+fSize[1]/fNSegment[IZ]*(2.*z+1));
           G4Transform3D trans;
           if(fRotationMatrix) {
@@ -565 +521 @@
   }
 
+  colorMap->SetPSUnit(fDrawUnit);
+  colorMap->SetPSName(fDrawPSName);
   colorMap->DrawColorChart();
 
@@ -570 +528 @@
 
 void G4ScoringCylinder::GetRZPhi(G4int index, G4int q[3]) const {
-
-  q[0] = index/(fNSegment[2]*fNSegment[1]);
-  q[1] = (index - q[0]*fNSegment[2]*fNSegment[1])/fNSegment[2];
-  q[2] = index - q[1]*fNSegment[2] - q[0]*fNSegment[2]*fNSegment[1];
-
-}
+  // index = k + j * k-size + i * jk-plane-size
+
+  // nested : z -> phi -> r
+  G4int i = IZ;
+  G4int j = IPHI;
+  G4int k = IR;
+  G4int jk = fNSegment[j]*fNSegment[k];
+  q[i] = index/jk;
+  q[j] = (index - q[i]*jk)/fNSegment[k];
+  q[k] = index - q[j]*fNSegment[k] - q[i]*jk;
+}

trunk/source/digits_hits/utils/src/G4ScoringManager.cc

@@ -25 +25 @@
 //
 //
-// $Id: G4ScoringManager.cc,v 1.31 2008/03/25 02:18:38 akimura Exp $
-// GEANT4 tag $Name: geant4-09-04-beta-01 $
+// $Id: G4ScoringManager.cc,v 1.33 2010/09/24 05:51:27 asaim Exp $
+// GEANT4 tag $Name:  $
 //
 
@@ -40 +40 @@
 G4ScoringManager* G4ScoringManager::fSManager = 0;
 
-G4int G4ScoringManager::replicaLevel = 2;
+G4int G4ScoringManager::replicaLevel = 3;
 
 G4ScoringManager* G4ScoringManager::GetScoringManager()

trunk/source/digits_hits/utils/src/G4ScoringMessenger.cc

@@ -25 +25 @@
 //
 //
-// $Id: G4ScoringMessenger.cc,v 1.39 2008/11/26 21:27:35 asaim Exp $
-// GEANT4 tag $Name: geant4-09-04-beta-01 $
+// $Id: G4ScoringMessenger.cc,v 1.42 2010/07/26 03:52:33 akimura Exp $
+// GEANT4 tag $Name:  $
 //
 // ---------------------------------------------------------------------
@@ -185 +185 @@
   drawCmd->SetGuidance("Draw projection(s) of scored quantities.");
   drawCmd->SetGuidance("Parameter <proj> specified which projection(s) to be drawn.");
-  drawCmd->SetGuidance("  100 : xy-plane, 010 : yz-place, 001 : zx-plane -- default 111");
+  drawCmd->SetGuidance("  100 : xy-plane, 010 : yz-plane,    001 : zx-plane -- default 111");
+  drawCmd->SetGuidance("  100 : N/A,      010 : z_phi-plane, 001 : r_phi-plane -- default 111");
   param = new G4UIparameter("meshName",'s',false);
   drawCmd->SetParameter(param);
@@ -200 +201 @@
   drawColumnCmd = new G4UIcommand("/score/drawColumn",this);
   drawColumnCmd->SetGuidance("Draw a cell column.");
-  drawColumnCmd->SetGuidance(" plane = 0 : xy, 1: yz, 2: zx");
+  drawColumnCmd->SetGuidance(" plane = 0 : x-y, 1: y-z, 2: z-x  for box mesh");
+  drawColumnCmd->SetGuidance("         0 : z-phi, 1: r-phi, 2: r-z  for cylinder mesh");
   param = new G4UIparameter("meshName",'s',false);
   drawColumnCmd->SetParameter(param);
@@ -235 +237 @@
   colorMapMinMaxCmd->SetParameter(param);
 
+  /*
   chartCmd = new G4UIcommand("/score/drawChart",this);
   chartCmd->SetGuidance("Draw color chart on the screen.");
@@ -252 +255 @@
   param->SetDefaultValue("linear");
   chartCmd->SetParameter(param);
-  
+  */
+
   // Dump a scored quantity 
   dumpQtyToFileCmd = new G4UIcommand("/score/dumpQuantityToFile", this);
@@ -541 +545 @@
     G4int Nk = StoI(token[2]);
     G4int nSegment[3];
-    nSegment[0] = Ni;
-    nSegment[1] = Nj;
-    nSegment[2] = Nk;
+
+    if(dynamic_cast<G4ScoringBox*>(mesh)) {
+      G4cout << ".... G4ScoringMessenger::MeshBinCommand - G4ScoringBox" << G4endl;
+      nSegment[0] = Ni;
+      nSegment[1] = Nj;
+      nSegment[2] = Nk;
+    } else if(dynamic_cast<G4ScoringCylinder*>(mesh)) {
+      G4cout << ".... G4ScoringMessenger::MeshBinCommand - G4ScoringCylinder" << G4endl;
+      nSegment[0] = Nj;
+      nSegment[1] = Nk;
+      nSegment[2] = Ni;
+    } else {
+      G4Exception("G4ScoringMessenger::MeshBinCommand()", "001", FatalException, "invalid mesh type");
+    }
     //
     mesh->SetNumberOfSegments(nSegment);

trunk/source/digits_hits/utils/src/G4VScoreColorMap.cc

@@ -25 +25 @@
 //
 //
-// $Id: G4VScoreColorMap.cc,v 1.4 2009/05/04 15:57:33 akimura Exp $
-// GEANT4 tag $Name: geant4-09-04-beta-01 $
+// $Id: G4VScoreColorMap.cc,v 1.8 2010/07/26 03:52:33 akimura Exp $
+// GEANT4 tag $Name:  $
 //
 
@@ -80 +80 @@
 }
 void G4VScoreColorMap::DrawColorChartText(G4int _nPoint) {
+
   G4double min = this->GetMin();
   G4double max = this->GetMax();
@@ -115 +116 @@
     fVisManager->Draw2D(text);
   }
+
+  // draw ps name
+  // background
+  G4int lpsname = 20;//fPSName.size();
+  if(lpsname > 0) {
+    for(int l = 0; l < 22; l++) {
+      G4Polyline line;
+      line.push_back(G4Point3D(-0.9, -0.965+0.002*l, 0.));
+      line.push_back(G4Point3D(-0.9+0.025*lpsname, -0.965+0.002*l, 0.));
+      G4VisAttributes attblack(black);
+      //G4VisAttributes attblack(G4Colour(.5, .5, 1.));
+      line.SetVisAttributes(&attblack);
+      fVisManager->Draw2D(line);
+    }
+    // ps name
+    G4Text txtpsname(fPSName, G4Point3D(-0.9, -0.96, 0.));
+    G4double size = 12.;
+    txtpsname.SetScreenSize(size);
+    G4Colour color(1., 1., 1.);
+    G4VisAttributes att(color);
+    txtpsname.SetVisAttributes(&att);
+    fVisManager->Draw2D(txtpsname);
+  }
+
+  // draw unit
+  // background
+  G4int len = fPSUnit.size();
+  if(len > 0) {
+    for(int l = 0; l < 21; l++) {
+      G4Polyline line;
+      line.push_back(G4Point3D(-0.7, -0.9+0.002*l, 0.));
+      line.push_back(G4Point3D(-0.7+0.3, -0.9+0.002*l, 0.));
+      G4VisAttributes attblack(black);
+      //G4VisAttributes attblack(G4Colour(.5, .5, .5));
+      line.SetVisAttributes(&attblack);
+      fVisManager->Draw2D(line);
+    }
+    // unit
+    G4String psunit = "[" + fPSUnit + "]";
+    G4Text txtunit(psunit, G4Point3D(-0.69, -0.9, 0.));
+    G4double size = 12.;
+    txtunit.SetScreenSize(size);
+    G4Colour color(1., 1., 1.);
+    G4VisAttributes att(color);
+    txtunit.SetVisAttributes(&att);
+    fVisManager->Draw2D(txtunit);
+  }
+
 }

trunk/source/digits_hits/utils/src/G4VScoreWriter.cc

@@ -25 +25 @@
 //
 //
-// $Id: G4VScoreWriter.cc,v 1.5 2008/03/04 23:19:09 taso Exp $
-// GEANT4 tag $Name: geant4-09-04-beta-01 $
+// $Id: G4VScoreWriter.cc,v 1.10 2010/07/27 01:44:54 akimura Exp $
+// GEANT4 tag $Name:  $
 //
 
@@ -87 +87 @@
     return;
   }
+
+
   std::map<G4int, G4double*> * score = msMapItr->second->GetMap();
-  ofile << "# primitive scorer name: " << msMapItr->first << G4endl;
+  ofile << "# primitive scorer name: " << msMapItr->first << std::endl;
+
+
+  G4double unitValue = fScoringMesh->GetPSUnitValue(psName);
+  G4String unit = fScoringMesh->GetPSUnit(psName);
+  G4String divisionAxisNames[3];
+  fScoringMesh->GetDivisionAxisNames(divisionAxisNames);
+  // index order
+  ofile << "# i" << divisionAxisNames[0]
+        << ", i" << divisionAxisNames[1]
+        << ", i" << divisionAxisNames[2];
+  // unit of scored value
+  ofile << ", value ";
+  if(unit.size() > 0) ofile << "[" << unit << "]";
+  ofile << G4endl;
 
   // "sequence" option: write header info 
@@ -111 +127 @@
           ofile << 0.;
         } else {
-          ofile << *(value->second);
+          ofile << *(value->second)/unitValue;
         }
 
@@ -160 +176 @@
   std::map<G4int, G4double*> * score;
   for(; msMapItr != fSMap.end(); msMapItr++) {
+
+    G4String psname = msMapItr->first;
+
     score = msMapItr->second->GetMap();
-    ofile << "# primitive scorer name: " << msMapItr->first << G4endl;
+    ofile << "# primitive scorer name: " << msMapItr->first << std::endl;
+
+    G4double unitValue = fScoringMesh->GetPSUnitValue(psname);
+    G4String unit = fScoringMesh->GetPSUnit(psname);
+    G4String divisionAxisNames[3];
+    fScoringMesh->GetDivisionAxisNames(divisionAxisNames);
+    // index order
+    ofile << "# i" << divisionAxisNames[0]
+          << ", i" << divisionAxisNames[1]
+          << ", i" << divisionAxisNames[2];
+    // unit of scored value
+    ofile << ", value ";
+    if(unit.size() > 0) ofile << "[" << unit << "]";
+    ofile << G4endl;
+
 
     // "sequence" option: write header info 
@@ -184 +217 @@
             ofile << 0.;
           } else {
-            ofile << *(value->second);
+            ofile << *(value->second)/unitValue;
           }
 

trunk/source/digits_hits/utils/src/G4VScoringMesh.cc

@@ -25 +25 @@
 //
 //
-// $Id: G4VScoringMesh.cc,v 1.37 2009/10/12 04:11:25 akimura Exp $
-// GEANT4 tag $Name: geant4-09-04-beta-01 $
+// $Id: G4VScoringMesh.cc,v 1.42 2010/07/27 01:44:54 akimura Exp $
+// GEANT4 tag $Name:  $
 //
 
@@ -39 +39 @@
   : fWorldName(wName),fConstructed(false),fActive(true),
     fRotationMatrix(NULL), fMFD(new G4MultiFunctionalDetector(wName)),
-    verboseLevel(0),sizeIsSet(false),nMeshIsSet(false)
+    verboseLevel(0),sizeIsSet(false),nMeshIsSet(false),
+    fDrawUnit(""), fDrawUnitValue(1.)
 {
   G4SDManager::GetSDMpointer()->AddNewDetector(fMFD);
@@ -45 +46 @@
   fSize[0] = fSize[1] = fSize[2] = 0.;
   fNSegment[0] = fNSegment[1] = fNSegment[2] = 1;
+  fDivisionAxisNames[0] = fDivisionAxisNames[1] = fDivisionAxisNames[2] = "";
 }
 
@@ -150 +152 @@
   if(itr == fMap.end()) return false;
   return true;
+}
+
+G4String G4VScoringMesh::GetPSUnit(G4String & psname) {
+  std::map<G4String, G4THitsMap<G4double>* >::iterator itr = fMap.find(psname);;
+  if(itr == fMap.end()) {
+    return G4String("");
+  } else {
+    return GetPrimitiveScorer(psname)->GetUnit();
+  }
+}
+
+G4String G4VScoringMesh::GetCurrentPSUnit(){
+    G4String unit = "";
+  if(fCurrentPS == NULL) {
+      G4String msg = "ERROR : G4VScoringMesh::GetCurrentPSUnit() : ";
+      msg += " Current primitive scorer is null.";
+      G4cerr << msg << G4endl;
+  }else{
+     unit =  fCurrentPS->GetUnit();
+  }
+  return unit;
+}
+
+void  G4VScoringMesh::SetCurrentPSUnit(const G4String& unit){
+  if(fCurrentPS == NULL) {
+      G4String msg = "ERROR : G4VScoringMesh::GetCurrentPSUnit() : ";
+      msg += " Current primitive scorer is null.";
+      G4cerr << msg << G4endl;
+  }else{
+      fCurrentPS->SetUnit(unit);
+  }
+}
+
+G4double G4VScoringMesh::GetPSUnitValue(G4String & psname) {
+  std::map<G4String, G4THitsMap<G4double>* >::iterator itr = fMap.find(psname);;
+  if(itr == fMap.end()) {
+    return 1.;
+  } else {
+    return GetPrimitiveScorer(psname)->GetUnitValue();
+  }
+}
+
+void G4VScoringMesh::GetDivisionAxisNames(G4String divisionAxisNames[3]) {
+  for(int i = 0; i < 3; i++) divisionAxisNames[i] = fDivisionAxisNames[i];
 }