geant4/LEMuSR/src/F04ElementField.cc

@@ -0,0 +1,207 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+//
+//
+
+#include "G4GeometryManager.hh"
+#include "F04ElementField.hh"
+#include "F04GlobalField.hh"
+#include "lem4Parameters.hh"
+#include "lem4ErrorMessage.hh"
+
+G4Navigator* F04ElementField::aNavigator;
+
+F04ElementField::F04ElementField(G4ThreeVector c, G4LogicalVolume* lv)
+{ 
+  elementFieldName="NAME_NOT_DEFINED";
+  center = c;
+
+  minX = minY = minZ = -DBL_MAX;
+  maxX = maxY = maxZ =  DBL_MAX;
+
+  ///G4cout<<"Kamil: F04GlobalField: addElementField() will be called: "<<G4endl;
+  F04GlobalField::getObject()->addElementField(this);
+
+  color = "1,1,1";
+
+  userLimits = new G4UserLimits();
+
+  lvolume = lv;
+  lvolume->SetVisAttributes(getVisAttribute(color));
+
+  maxStep = 1*mm;
+
+  userLimits->SetMaxAllowedStep(maxStep);
+
+  userLimits->SetUserMaxTrackLength(500.*m);
+  userLimits->SetUserMaxTime(10*ms);
+//  userLimits->SetUserMinEkine(0.1*MeV);
+//  userLimits->SetUserMinRange(1*mm);
+
+  lvolume->SetUserLimits(userLimits);
+}
+
+void F04ElementField::construct()
+{
+  G4Navigator* theNavigator = 
+                    G4TransportationManager::GetTransportationManager()->
+                                                 GetNavigatorForTracking();
+
+  if (!aNavigator) {
+     aNavigator = new G4Navigator();
+     if ( theNavigator->GetWorldVolume() )
+               aNavigator->SetWorldVolume(theNavigator->GetWorldVolume());
+   }
+
+  G4GeometryManager* geomManager = G4GeometryManager::GetInstance();
+
+  if (!geomManager->IsGeometryClosed()) {
+     geomManager->OpenGeometry();
+     geomManager->CloseGeometry(true);
+  }
+
+  ///G4cout<<"F04ElementField: center="<<center.x()/mm<<", "<<center.y()/mm<<", "<<center.z()/mm<<G4endl;
+  aNavigator->LocateGlobalPointAndSetup(center,0,false);
+
+  G4TouchableHistoryHandle fTouchable = aNavigator->CreateTouchableHistoryHandle();
+
+  G4int depth = fTouchable->GetHistoryDepth();
+  for (G4int i = 0; i<depth; ++i) {
+    if(fTouchable->GetVolume()->GetLogicalVolume() == lvolume)break;
+    fTouchable->MoveUpHistory();
+  }
+  
+  // Check that the point of origin of the field matches that of the logical volume, to which it is assigned:
+  G4String volumeName=lvolume->GetName();
+  if (fTouchable->GetVolume()->GetLogicalVolume() != lvolume) {
+    char eMessage[200];
+    sprintf(eMessage,"F04ElementField.cc::construct(): Origin of the field outside the respective logical volume!! \"%s\".",
+	    volumeName.c_str());
+    /// NOTE: Cannot apply fields to non simply connected bodies, as e.g. rings, tori, etc. !
+    lem4ErrorMessage::GetInstance()->lem4Error(FATAL,eMessage,false);
+  }
+
+  //            G4cout<<"+!+!+! global2local VOLUME NAME: "<<fTouchable->GetVolume()->GetName()<<G4endl;
+  // Set global2local transform.  The centre of the transformation is set to the centre of the volume, not
+  // to the point "center", as one could naively expect! This is corrected a few lines later.
+  global2local = fTouchable->GetHistory()->GetTopTransform();
+  G4ThreeVector local_center = global2local.TransformPoint(center);
+  
+  G4cout<<"F04ElementField: " << elementFieldName << " in \""<<volumeName<<"\".  "
+        <<"Field origin: Global ("<<center.x()/mm<<", "<<center.y()/mm<<", "<<center.z()/mm<<") mm, "
+	<<"Local ("<<local_center.x()/mm<<", "<<local_center.y()/mm<<", "<<local_center.z()/mm<<") mm."<<G4endl;
+  
+  // Print out the point of the origin of the field in the local coordinate system of the logical volume:
+///  G4ThreeVector local_center = global2local.TransformPoint(center);
+///  G4cout<<"\t==> "<<elementFieldName<<" (Volume = \""<<volumeName<<"\". Origin of the field in the local coord. system: "
+///        <<local_center.x()/mm<<", "<<local_center.y()/mm<<", "<<local_center.z()/mm<<" mm.)"<<G4endl;
+
+  // Now move the centre of the transformation such that it coincides with the point "center":
+  global2local*=G4AffineTransform(-local_center);
+
+  //  After moving the centre of the transformation, the point "local_center" should be set to 0., 0., 0. in
+  //  the following print-out message:
+  //  local_center = global2local.TransformPoint(center);
+  //  G4cout<<"\t==> "<<elementFieldName<<"  (volume=\""<<volumeName<<"\", centre of the field in local coordinate syst 2: "
+  //        <<local_center.x()/mm<<", "<<local_center.y()/mm<<", "<<local_center.z()/mm<<" mm.)"<<G4endl;
+
+  // set global bounding box
+  G4double local[4], global[4];
+
+  G4ThreeVector globalPosition;
+  local[3] = 0.0;
+  for (int i=0; i<2; ++i) {
+      local[0] = (i==0 ? -1.0 : 1.0) * getWidth()/2.;
+      for (int j=0; j<2; ++j) {
+          local[1] = (j==0 ? -1.0 : 1.0) * getHeight()/2.;
+          for (int k=0; k<2; ++k) {
+              local[2] = (k==0 ? -1.0 : 1.0) * getLength()/2.;
+              G4ThreeVector localPosition(local[0],local[1],local[2]);
+              globalPosition = 
+                         global2local.Inverse().TransformPoint(localPosition);
+              global[0] = globalPosition.x();
+              global[1] = globalPosition.y();
+              global[2] = globalPosition.z();
+              setGlobalPoint(global);
+           }
+      }
+  }
+}
+
+
+G4VisAttributes* F04ElementField::getVisAttribute(G4String color)
+{
+   G4VisAttributes* p = NULL;
+   if(color.size() > 0 &&
+     (isdigit(color.c_str()[0]) || color.c_str()[0] == '.')) {
+        G4double red=0.0, green=0.0, blue=0.0;
+        if (sscanf(color.c_str(),"%lf,%lf,%lf",&red,&green,&blue) == 3) {
+           p = new G4VisAttributes(true,G4Color(red,green,blue));
+        } else {
+           G4cout << " Invalid color " << color << G4endl;
+        }
+   }
+
+   if (!p) p = new G4VisAttributes(G4VisAttributes::Invisible);
+   p->SetDaughtersInvisible(false);
+
+   return p;
+}
+
+
+void F04ElementField::SetEventNrDependentField(G4double initialField, G4double finalField, G4int nrOfSteps) {
+  G4double eventNrStep        =  float(lem4Parameters::nrOfEventsToBeGenerated)/(nrOfSteps);
+  G4double fieldStep          =  (finalField-initialField)/(nrOfSteps-1);
+  //  G4cout<<"lem4Parameters::nrOfEventsToBeGenerated="<<lem4Parameters::nrOfEventsToBeGenerated<<G4endl;
+  //  G4cout<<"fieldStep="<<fieldStep<<"     eventNrStep="<<eventNrStep<<G4endl;
+  for (G4int i=1; i<=nrOfSteps; i++) {
+    G4int    eventNumber = int(i*eventNrStep);
+    G4double field       = initialField + i*fieldStep;
+    changeFieldInStepsMap[eventNumber]=field;
+  }
+  
+  G4cout << "Setting field in steps for field "<<elementFieldName<<G4endl;
+  std::map<G4int,G4double>::iterator it;
+  for ( it=changeFieldInStepsMap.begin() ; it != changeFieldInStepsMap.end(); it++ ) {
+    G4cout << "Field will be changed at event "<< (*it).first << " to the value of " << (*it).second/tesla<<" T" << G4endl;
+    //    G4double nominalFieldValue=it->second;
+    //    it->SetNominalFieldValue(nominalFieldValue);
+  }
+}
+
+
+void F04ElementField::SetElementFieldValueIfNeeded(G4int eventNr) {
+  std::map<G4int,G4double>::iterator itr;
+  itr = changeFieldInStepsMap.find(eventNr);
+  if (itr==F04ElementField::changeFieldInStepsMap.end()) {
+    // eventNr was not found in the map ==> field is not going to change at this eventNr
+  } 
+  else {
+    G4double newFieldValue = itr->second;
+    SetNominalFieldValue(newFieldValue);
+    //	G4cout<<"Nominal Field changed for "<<G4endl;
+  }
+}

geant4/LEMuSR/src/F04FieldMessenger.cc

@@ -0,0 +1,147 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+//
+//
+
+#include "F04FieldMessenger.hh"
+
+#include "F04GlobalField.hh"
+#include "G4UIdirectory.hh"
+#include "G4UIcmdWithAString.hh"
+#include "G4UIcmdWithAnInteger.hh"
+#include "G4UIcmdWithADoubleAndUnit.hh"
+#include "G4UIcmdWithoutParameter.hh"
+
+//////////////////////////////////////////////////////////////////////////////
+
+F04FieldMessenger::F04FieldMessenger(F04GlobalField* pEMfield)
+  : fGlobalField(pEMfield)
+{ 
+  detDir = new G4UIdirectory("/field/");
+  detDir->SetGuidance(" Field tracking control ");
+
+  fStepperCMD = new G4UIcmdWithAnInteger("/field/setStepperType",this);
+  fStepperCMD->SetGuidance("Select stepper type for field");
+  fStepperCMD->SetParameterName("choice",true);
+  fStepperCMD->SetDefaultValue(4);
+  fStepperCMD->AvailableForStates(G4State_PreInit,G4State_Idle);
+ 
+  fUpdateCMD = new G4UIcmdWithoutParameter("/field/update",this);
+  fUpdateCMD->SetGuidance("Update Field");
+  fUpdateCMD->SetGuidance("This command MUST be applied before \"beamOn\" ");
+  fUpdateCMD->SetGuidance("if you changed field settings.");
+  fUpdateCMD->AvailableForStates(G4State_PreInit,G4State_Idle);
+
+  fMinStepCMD = new G4UIcmdWithADoubleAndUnit("/field/setMinStep",this);  
+  fMinStepCMD->SetGuidance("Define minimal step");
+  fMinStepCMD->SetParameterName("min step",false,false);
+  fMinStepCMD->SetDefaultUnit("mm");
+  fMinStepCMD->AvailableForStates(G4State_PreInit,G4State_Idle);
+
+  fDeltaChordCMD = new G4UIcmdWithADoubleAndUnit("/field/setDeltaChord",this);
+  fDeltaChordCMD->SetGuidance("Define delta chord");
+  fDeltaChordCMD->SetParameterName("delta chord",false,false);
+  fDeltaChordCMD->SetDefaultUnit("mm");
+  fDeltaChordCMD->AvailableForStates(G4State_PreInit,G4State_Idle);
+
+  fDeltaOneStepCMD = 
+                 new G4UIcmdWithADoubleAndUnit("/field/setDeltaOneStep",this);
+  fDeltaOneStepCMD->SetGuidance("Define delta one step");
+  fDeltaOneStepCMD->SetParameterName("delta one step",false,false);
+  fDeltaOneStepCMD->SetDefaultUnit("mm");
+  fDeltaOneStepCMD->AvailableForStates(G4State_PreInit,G4State_Idle);
+
+  fDeltaIntersectionCMD = 
+            new G4UIcmdWithADoubleAndUnit("/field/setDeltaIntersection",this);
+  fDeltaIntersectionCMD->SetGuidance("Define delta intersection");
+  fDeltaIntersectionCMD->SetParameterName("delta intersection",false,false);
+  fDeltaIntersectionCMD->SetDefaultUnit("mm");
+  fDeltaIntersectionCMD->AvailableForStates(G4State_PreInit,G4State_Idle);
+
+  fEpsMinCMD = new G4UIcmdWithADoubleAndUnit("/field/setEpsMin",this);
+  fEpsMinCMD->SetGuidance("Define eps min");
+  fEpsMinCMD->SetParameterName("eps min",false,false);
+  fEpsMinCMD->SetDefaultUnit("mm");
+  fEpsMinCMD->AvailableForStates(G4State_PreInit,G4State_Idle);
+
+  fEpsMaxCMD = new G4UIcmdWithADoubleAndUnit("/field/setEpsMax",this);
+  fEpsMaxCMD->SetGuidance("Define eps max");
+  fEpsMaxCMD->SetParameterName("eps max",false,false);
+  fEpsMaxCMD->SetDefaultUnit("mm");
+  fEpsMaxCMD->AvailableForStates(G4State_PreInit,G4State_Idle);
+}
+
+F04FieldMessenger::~F04FieldMessenger()
+{
+  delete detDir;
+
+  delete fStepperCMD;
+  delete fMinStepCMD;
+  delete fDeltaChordCMD;
+  delete fDeltaOneStepCMD;
+  delete fDeltaIntersectionCMD;
+  delete fEpsMinCMD;
+  delete fEpsMaxCMD;
+  delete fUpdateCMD;
+}
+
+void F04FieldMessenger::SetNewValue( G4UIcommand* command, G4String newValue)
+{ 
+  if( command == fStepperCMD )
+  { 
+    fGlobalField->SetStepperType(fStepperCMD->GetNewIntValue(newValue));
+  }  
+  if( command == fUpdateCMD )
+  { 
+    fGlobalField->updateField(); 
+  }
+  if( command == fMinStepCMD )
+  { 
+    fGlobalField->SetMinStep(fMinStepCMD->GetNewDoubleValue(newValue));
+  }
+  if( command == fDeltaChordCMD )
+  {
+    fGlobalField->SetDeltaChord(fDeltaChordCMD->GetNewDoubleValue(newValue));
+  }
+  if( command == fDeltaOneStepCMD )
+  {
+    fGlobalField->
+                SetDeltaOneStep(fDeltaOneStepCMD->GetNewDoubleValue(newValue));
+  }
+  if( command == fDeltaIntersectionCMD )
+  {
+    fGlobalField-> 
+      SetDeltaIntersection(fDeltaIntersectionCMD->GetNewDoubleValue(newValue));
+  }
+  if( command == fEpsMinCMD )
+  {
+    fGlobalField->SetEpsMin(fEpsMinCMD->GetNewDoubleValue(newValue));
+  }
+  if( command == fEpsMaxCMD )
+  {
+    fGlobalField->SetEpsMax(fEpsMaxCMD->GetNewDoubleValue(newValue));
+  }
+}

geant4/LEMuSR/src/F04GlobalField.cc

@@ -0,0 +1,313 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+//
+//
+
+#include <time.h>
+
+#include "Randomize.hh"
+#include "G4TransportationManager.hh"
+
+#include "G4ExplicitEuler.hh"
+#include "G4ImplicitEuler.hh"
+#include "G4SimpleRunge.hh"
+#include "G4SimpleHeum.hh"
+#include "G4ClassicalRK4.hh"
+#include "G4CashKarpRKF45.hh"
+
+#include "F04GlobalField.hh"
+#include "lem4RootOutput.hh"
+
+F04GlobalField* F04GlobalField::object = 0;
+
+F04GlobalField::F04GlobalField() : G4ElectroMagneticField(),
+                             minStep(0.01*mm), deltaChord(3.0*mm),
+                             deltaOneStep(0.01*mm), deltaIntersection(0.1*mm),
+                             epsMin(2.5e-7*mm), epsMax(0.05*mm),
+                             fEquation(0), fFieldManager(0), 
+                             fFieldPropagator(0), fStepper(0), fChordFinder(0)
+//F04GlobalField::F04GlobalField() : G4MagneticField(),
+//                             minStep(0.01*mm), deltaChord(3.0*mm),
+//                             deltaOneStep(0.01*mm), deltaIntersection(0.1*mm),
+//                             epsMin(2.5e-7*mm), epsMax(0.05*mm),
+//                             fEquation(0), fFieldManager(0),
+//                             fFieldPropagator(0), fStepper(0), fChordFinder(0)
+{
+  fFieldMessenger = new F04FieldMessenger(this);
+
+  fields = new FieldList();
+
+  fStepperType = 4 ;       // ClassicalRK4 is default stepper
+
+  //  set object
+
+  object = this;
+
+  updateField();
+}
+
+F04GlobalField::~F04GlobalField()
+{
+  clear();
+
+  delete fFieldMessenger;
+
+  if (fEquation)        delete fEquation;
+  if (fFieldManager)    delete fFieldManager;
+  if (fFieldPropagator) delete fFieldPropagator;
+  if (fStepper)         delete fStepper;
+  if (fChordFinder)     delete fChordFinder;
+}
+
+void F04GlobalField::updateField()
+{
+  first = true;
+
+  nfp = 0;
+  fp = 0;
+
+  clear();
+
+  //  Construct equ. of motion of particles through B fields
+//  fEquation = new G4Mag_EqRhs(this);
+  //  Construct equ. of motion of particles through e.m. fields
+//  fEquation = new G4EqMagElectricField(this);
+  //  Construct equ. of motion of particles including spin through B fields
+//  fEquation = new G4Mag_SpinEqRhs(this);
+  //  Construct equ. of motion of particles including spin through e.m. fields
+  fEquation = new G4EqEMFieldWithSpin(this);
+
+  //  Get transportation, field, and propagator managers
+  G4TransportationManager* fTransportManager =
+         G4TransportationManager::GetTransportationManager();
+
+  fFieldManager = GetGlobalFieldManager();
+
+  fFieldPropagator = fTransportManager->GetPropagatorInField();
+
+  //  Need to SetFieldChangesEnergy to account for a time varying electric
+  //  field (r.f. fields)
+  fFieldManager->SetFieldChangesEnergy(true);
+
+  //  Set the field
+  fFieldManager->SetDetectorField(this);
+
+  //  Choose a stepper for integration of the equation of motion
+  SetStepper();
+
+  //  Create a cord finder providing the (global field, min step length,
+  //  a pointer to the stepper)
+  fChordFinder = new G4ChordFinder((G4MagneticField*)this,minStep,fStepper);
+
+  // Set accuracy parameters
+  fChordFinder->SetDeltaChord( deltaChord );
+
+  fFieldManager->SetAccuraciesWithDeltaOneStep(deltaOneStep);
+
+  fFieldManager->SetDeltaIntersection(deltaIntersection);
+
+  fFieldPropagator->SetMinimumEpsilonStep(epsMin);
+  fFieldPropagator->SetMaximumEpsilonStep(epsMax);
+
+  G4cout << "Accuracy Parameters:" <<
+            " MinStep=" << minStep <<
+            ", DeltaChord=" << deltaChord <<
+            ", DeltaOneStep=" << deltaOneStep << G4endl;
+  G4cout << "                    " <<
+            " DeltaIntersection=" << deltaIntersection <<
+            ", EpsMin=" << epsMin <<
+            ", EpsMax=" << epsMax <<  G4endl;
+
+  fFieldManager->SetChordFinder(fChordFinder);
+
+}
+
+F04GlobalField* F04GlobalField::getObject()
+{
+  if (!object) new F04GlobalField();
+  return object;
+}
+
+void F04GlobalField::SetStepper()
+{
+  if(fStepper) delete fStepper;
+  
+  G4cout << G4endl;
+  switch ( fStepperType )
+  {
+    case 0:
+//      fStepper = new G4ExplicitEuler( fEquation, 8 ); // no spin tracking
+      fStepper = new G4ExplicitEuler( fEquation, 12 ); // with spin tracking
+      G4cout << "G4ExplicitEuler is called" << G4endl;
+      break;
+    case 1:
+//      fStepper = new G4ImplicitEuler( fEquation, 8 ); // no spin tracking
+      fStepper = new G4ImplicitEuler( fEquation, 12 ); // with spin tracking
+      G4cout << "G4ImplicitEuler is called" << G4endl;
+      break;
+    case 2:
+//      fStepper = new G4SimpleRunge( fEquation, 8 ); // no spin tracking
+      fStepper = new G4SimpleRunge( fEquation, 12 ); // with spin tracking
+      G4cout << "G4SimpleRunge is called" << G4endl;
+      break;
+    case 3:
+//      fStepper = new G4SimpleHeum( fEquation, 8 ); // no spin tracking
+      fStepper = new G4SimpleHeum( fEquation, 12 ); // with spin tracking
+      G4cout << "G4SimpleHeum is called" << G4endl;
+      break;
+    case 4:
+//      fStepper = new G4ClassicalRK4( fEquation, 8 ); // no spin tracking
+      fStepper = new G4ClassicalRK4( fEquation, 12 ); // with spin tracking
+      G4cout << "G4ClassicalRK4 (default) is called" << G4endl;
+      break;
+    case 5:
+//      fStepper = new G4CashKarpRKF45( fEquation, 8 ); // no spin tracking
+      fStepper = new G4CashKarpRKF45( fEquation, 12 ); // with spin tracking
+      G4cout << "G4CashKarpRKF45 is called" << G4endl;
+      break;
+    default: fStepper = 0;
+  }
+}
+
+G4FieldManager* F04GlobalField::GetGlobalFieldManager()
+{
+  return G4TransportationManager::GetTransportationManager()
+                                ->GetFieldManager();
+}
+
+void F04GlobalField::GetFieldValue(const G4double* point, G4double* field) const
+{
+  // NOTE: this routine dominates the CPU time for tracking.
+  // Using the simple array fp[] instead of fields[] 
+  // directly sped it up
+
+  field[0] = field[1] = field[2] = field[3] = field[4] = field[5] = 0.0;
+
+  // protect against Geant4 bug that calls us with point[] NaN.
+  if(point[0] != point[0]) return;
+
+  // (can't use nfp or fp, as they may change)
+  if (first) ((F04GlobalField*)this)->setupArray();   // (cast away const)
+
+  for (int i=0; i<nfp; ++i) {
+      const F04ElementField* p = fp[i];
+      if (p->isInBoundingBox(point)) {
+         p->addFieldValue(point,field);
+      }
+  }
+
+}
+
+  // cks  NOT SURE WHETHER THE FOLLOWING IS STILL NEEDED, HOWEVER ADDED HERE JUST
+  //      FOR THE CASE:
+  // Set some small field if field is almost zero (to avoid internal problems of Geant).
+  ///if (sqrt(field[0]*field[0]+field[1]*field[1]+field[2]*field[2])<0.00001*tesla) {
+  ///  field[2] = 0.00001*tesla;
+  ///}
+  // csk
+
+
+void F04GlobalField::clear()
+{
+  if (fields) {
+     if (fields->size()>0) {
+        FieldList::iterator i;
+        for (i=fields->begin(); i!=fields->end(); ++i) delete *i;
+        fields->clear();
+     }
+  }
+
+  if (fp) delete[] fp;
+
+  first = true;
+
+  nfp = 0;
+  fp = NULL;
+}
+
+void F04GlobalField::setupArray()
+{
+  first = false;
+  nfp = fields->size();
+  fp = new const F04ElementField* [nfp+1]; // add 1 so it's never 0
+  for (int i=0; i<nfp; ++i) {
+    fp[i] = (*fields)[i];
+    // cks
+    // Find the event numbers, for which the field changes, for each Element Field.
+    // Then mark these event numbers in the Global Field, such that it can be efficiently
+    // find out during the run-time, at which event number the field may change.
+    std::map<G4int,G4double> localChangeFieldInStepsMap = fp[i] ->GetEventNrDependentField();
+    std::map<G4int,G4double>::iterator it;
+    for ( it=localChangeFieldInStepsMap.begin() ; it != localChangeFieldInStepsMap.end(); it++ ) {
+      G4int eventNr = it->first;
+      G4cout<<"globalChangeFieldInStepsMap  set for event number "<<eventNr<<G4endl;
+      globalChangeFieldInStepsMap[eventNr]=true;
+    }
+  }
+  lem4RootOutput::GetRootInstance()->SetNrFieldNomVal(nfp);
+}
+
+
+
+void F04GlobalField::CheckWhetherAnyNominalFieldValueNeedsToBeChanged(G4int eventNumber) {
+  if (globalChangeFieldInStepsMap[eventNumber]) {
+    //    G4cout<<"We should check each Element Field Object whether its field needs to be changed:"<<G4endl;
+    G4int jjj=0;
+    FieldList::iterator i;
+    for (i=fields->begin(); i!=fields->end(); ++i) {
+
+      // Set the nominal field value for the given field, if that has been requested for the given field
+      (*i)->SetElementFieldValueIfNeeded(eventNumber);
+
+      // Get the nominal field value for the given field and store it in the Root output 
+      G4double nomFieldValue = (*i)->GetNominalFieldValue();
+      lem4RootOutput::GetRootInstance()->SetFieldNomVal(jjj,nomFieldValue);
+      jjj++;
+    }
+  }
+}
+
+
+//  Print field value at all points requested by the user:
+void F04GlobalField::PrintFieldAtRequestedPoints() const {
+  G4ThreeVector p; 
+  G4double point[4];
+  G4double EMfield[6]; //={0,0,0,0,0,0};
+  for (unsigned int i=0; i < pointsAtWhichUserWantsToPrintFieldValue.size(); i++) {
+    p        = pointsAtWhichUserWantsToPrintFieldValue[i];
+    point[0] = p.x();
+    point[1] = p.y();
+    point[2] = p.z();
+    point[3] = 0.;
+    object->GetFieldValue(point,EMfield);
+    // [MV/m] = [10^3 kV / 10^3 mm] = [kV/mm]. But MV and mm are the BASE units in Geant4 => Fact. = 0.001
+    ///printf ("   EM field value at (%.f, %.f, %.f) mm is:  B = (%.f, %.f, %.f) T,  E = (%.10f, %.10f, %.10f) kV/mm\n", 
+    printf ("   EM field value at (%.f, %.f, %.f) mm is:  B = (%0.3g, %0.3g, %0.3g) T,  E = (%0.3g, %0.3g, %0.3g) kV/mm\n", 
+        point[0]/mm, point[1]/mm, point[2]/mm,
+        EMfield[0]/tesla,         EMfield[1]/tesla,         EMfield[2]/tesla,
+        EMfield[3]/(kilovolt/mm), EMfield[4]/(kilovolt/mm), EMfield[5]/(kilovolt/mm));
+  }
+}

geant4/LEMuSR/src/G4DecayWithSpin.cc

@@ -0,0 +1,175 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+// ------------------------------------------------------------
+//      GEANT 4 class header file
+//
+//      History:
+//      17 August 2004  P. Gumplinger, T. MacPhail
+// ------------------------------------------------------------
+//
+#include "G4DecayWithSpin.hh"
+
+#include "G4Step.hh"
+#include "G4Track.hh"
+#include "G4DecayTable.hh"
+#include "G4MuonDecayChannelWithSpin.hh"
+
+#include "G4Vector3D.hh"
+
+#include "G4TransportationManager.hh"
+#include "G4PropagatorInField.hh"
+#include "G4FieldManager.hh"
+#include "G4Field.hh"
+
+#include "G4Transform3D.hh"
+
+G4DecayWithSpin::G4DecayWithSpin(const G4String& processName):G4Decay(processName){}
+
+G4DecayWithSpin::~G4DecayWithSpin(){}
+
+G4VParticleChange* G4DecayWithSpin::DecayIt(const G4Track& aTrack, const G4Step& aStep)
+{
+// get particle
+  const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
+  G4ParticleDefinition* aParticleDef = aParticle->GetDefinition();
+
+// get parent_polarization
+  G4ThreeVector parent_polarization = aParticle->GetPolarization();
+
+  if(parent_polarization == G4ThreeVector(0,0,0))
+  {
+    // Generate random polarization direction
+
+    G4double cost = 1. - 2.*G4UniformRand();
+    G4double sint = std::sqrt((1.-cost)*(1.+cost));
+
+    G4double phi = twopi*G4UniformRand();
+    G4double sinp = std::sin(phi);
+    G4double cosp = std::cos(phi);
+
+    G4double px = sint*cosp;
+    G4double py = sint*sinp;
+    G4double pz = cost;
+
+    parent_polarization.setX(px);
+    parent_polarization.setY(py);
+    parent_polarization.setZ(pz);
+
+  }else{
+
+    G4FieldManager* fieldMgr = aStep.GetTrack()->GetVolume()->
+                                     GetLogicalVolume()->GetFieldManager();
+
+    if (!fieldMgr) {
+       G4TransportationManager *transportMgr =
+                         G4TransportationManager::GetTransportationManager();
+       G4PropagatorInField* fFieldPropagator = 
+                                        transportMgr->GetPropagatorInField();
+       if (fFieldPropagator) fieldMgr = 
+                                  fFieldPropagator->GetCurrentFieldManager();
+    }
+
+    const G4Field* field = NULL;
+    if(fieldMgr)field = fieldMgr->GetDetectorField();
+
+    //    if (field && !(fieldMgr->DoesFieldChangeEnergy())) {
+    if (field) {
+       // G4cout << "++++ LOCAL VERSION OF G4 DECAY WITH SPIN !!!! ++++"<< G4endl;
+       G4double point[4];
+       point[0] = (aStep.GetPostStepPoint()->GetPosition())[0];
+       point[1] = (aStep.GetPostStepPoint()->GetPosition())[1];
+       point[2] = (aStep.GetPostStepPoint()->GetPosition())[2];
+       point[3] = aTrack.GetGlobalTime();
+
+       G4double fieldValue[3];
+       field -> GetFieldValue(point,fieldValue);
+
+       G4ThreeVector B(fieldValue[0],fieldValue[1],fieldValue[2]);
+
+       if ((B.mag2())>0) {         // Call the spin precession only for non-zero mag. field
+	 parent_polarization = Spin_Precession(aStep,B,fRemainderLifeTime);
+       }
+
+    }
+  }
+
+// decay table
+  G4DecayTable *decaytable = aParticleDef->GetDecayTable();
+
+  if (decaytable) {
+     G4MuonDecayChannelWithSpin *decaychannel;
+     decaychannel = (G4MuonDecayChannelWithSpin*)decaytable->SelectADecayChannel();
+     if (decaychannel) decaychannel->SetPolarization(parent_polarization);
+  }
+
+  G4ParticleChangeForDecay* pParticleChangeForDecay;
+
+  pParticleChangeForDecay = (G4ParticleChangeForDecay*)G4Decay::DecayIt(aTrack,aStep);
+
+  pParticleChangeForDecay->ProposePolarization(parent_polarization);
+
+  return pParticleChangeForDecay;
+
+}
+
+G4ThreeVector G4DecayWithSpin::Spin_Precession( const G4Step& aStep,
+                                        G4ThreeVector B, G4double deltatime )
+{
+  G4double Bnorm = std::sqrt(sqr(B[0])  + sqr(B[1]) +sqr(B[2]) );
+
+  G4double q = aStep.GetTrack()->GetDefinition()->GetPDGCharge();
+  G4double a = 1.165922e-3;
+  G4double s_omega = 8.5062e+7*rad/(s*kilogauss);
+
+  G4double omega = -(q*s_omega)*(1.+a) * Bnorm;
+
+  G4double rotationangle = deltatime * omega;
+
+  G4Transform3D SpinRotation = G4Rotate3D(rotationangle,B.unit());
+
+  G4Vector3D Spin = aStep.GetTrack() -> GetPolarization();
+
+  G4Vector3D newSpin = SpinRotation * Spin;
+
+#ifdef G4VERBOSE
+  if (GetVerboseLevel()>2) {
+    G4double normspin = std::sqrt(Spin*Spin);
+    G4double normnewspin = std::sqrt(newSpin*newSpin);
+    //G4double cosalpha = Spin*newSpin/normspin/normnewspin;
+    //G4double alpha = std::acos(cosalpha);
+
+    G4cout << "AT REST::: PARAMETERS " << G4endl;
+    G4cout << "Initial spin  : " << Spin  << G4endl;
+    G4cout << "Delta time    : " << deltatime  << G4endl;
+    G4cout << "Rotation angle: " << rotationangle/rad  << G4endl;
+    G4cout << "New spin      : " << newSpin  << G4endl;
+    G4cout << "Checked norms : " << normspin <<" " << normnewspin << G4endl;
+  }
+#endif
+
+  return newSpin;
+
+}

geant4/LEMuSR/src/MuDecayChannel.cc

@@ -0,0 +1,197 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+//
+// $Id: MuDecayChannel.cc,v 1.17 2006/06/29 19:25:34 gunter Exp $
+// GEANT4 tag $Name: geant4-09-00 $
+//
+// 
+// ------------------------------------------------------------
+//      GEANT 4 class header file
+//
+//      History: first implementation, based on object model of
+//      30 May  1997 H.Kurashige
+//
+//      Fix bug in calcuration of electron energy in DecayIt 28 Feb. 01 H.Kurashige 
+//2005
+// M. Melissas ( melissas AT cppm.in2p3.fr)
+// J. Brunner ( brunner AT cppm.in2p3.fr) 
+// Adding V-A fluxes for neutrinos using a new algortithm : 
+// ------------------------------------------------------------
+
+#include "G4ParticleDefinition.hh"
+#include "G4DecayProducts.hh"
+#include "G4VDecayChannel.hh"
+#include "MuDecayChannel.hh"
+#include "Randomize.hh"
+#include "G4LorentzVector.hh"
+#include "G4LorentzRotation.hh"
+#include "G4RotationMatrix.hh"
+
+MuDecayChannel::MuDecayChannel(const G4String& theParentName, 
+				       G4double        theBR)
+               :G4VDecayChannel("Muonium Decay",1)
+{
+  // set names for daughter particles
+  if (theParentName == "Mu") {
+    SetBR(theBR);
+    SetParent("Mu");
+    SetNumberOfDaughters(3);
+    SetDaughter(0, "e+");
+    SetDaughter(1, "nu_e");
+    SetDaughter(2, "anti_nu_mu");
+  } else {
+#ifdef G4VERBOSE
+    if (GetVerboseLevel()>0) {
+      G4cout << "MuDecayChannel:: constructor :";
+      G4cout << " parent particle is not muon but ";
+      G4cout << theParentName << G4endl;
+    }
+#endif
+  }
+}
+
+MuDecayChannel::~MuDecayChannel()
+{
+}
+
+G4DecayProducts *MuDecayChannel::DecayIt(G4double) 
+{
+  // this version neglects muon polarization,and electron mass  
+  //              assumes the pure V-A coupling
+  //              the Neutrinos are correctly V-A. 
+#ifdef G4VERBOSE
+  if (GetVerboseLevel()>1) G4cout << "MuDecayChannel::DecayIt ";
+#endif
+
+  if (parent == 0) FillParent();  
+  if (daughters == 0) FillDaughters();
+ 
+  // parent mass
+  G4double parentmass = parent->GetPDGMass();
+
+  //daughters'mass
+  G4double daughtermass[3]; 
+  G4double sumofdaughtermass = 0.0;
+  for (G4int index=0; index<3; index++){
+    daughtermass[index] = daughters[index]->GetPDGMass();
+    sumofdaughtermass += daughtermass[index];
+  }
+
+   //create parent G4DynamicParticle at rest
+  G4ThreeVector dummy;
+  G4DynamicParticle * parentparticle = new G4DynamicParticle( parent, dummy, 0.0);
+  //create G4Decayproducts
+  G4DecayProducts *products = new G4DecayProducts(*parentparticle);
+  delete parentparticle;
+
+  // calculate daughter momentum
+  G4double daughtermomentum[3];
+    // calcurate electron energy
+  G4double xmax = (1.0+daughtermass[0]*daughtermass[0]/parentmass/parentmass);
+  G4double x;
+  
+  G4double Ee,Ene;
+  
+  G4double gam;
+   G4double EMax=parentmass/2-daughtermass[0];
+   
+  
+   //Generating Random Energy
+do {
+  Ee=G4UniformRand();
+    do{
+      x=xmax*G4UniformRand();
+      gam=G4UniformRand();
+    }while (gam >x*(1.-x));
+    Ene=x;
+  } while ( Ene < (1.-Ee));
+ G4double Enm=(2.-Ee-Ene);
+
+
+ //initialisation of rotation parameters
+
+  G4double costheta,sintheta,rphi,rtheta,rpsi;
+  costheta= 1.-2./Ee-2./Ene+2./Ene/Ee;
+  sintheta=std::sqrt(1.-costheta*costheta);
+  
+
+  rphi=twopi*G4UniformRand()*rad;
+  rtheta=(std::acos(2.*G4UniformRand()-1.));
+  rpsi=twopi*G4UniformRand()*rad;
+
+  G4RotationMatrix rot;
+  rot.set(rphi,rtheta,rpsi);
+
+  //electron 0
+  daughtermomentum[0]=std::sqrt(Ee*Ee*EMax*EMax+2.0*Ee*EMax * daughtermass[0]);
+  G4ThreeVector direction0(0.0,0.0,1.0);
+
+  direction0 *= rot;
+
+  G4DynamicParticle * daughterparticle = new G4DynamicParticle ( daughters[0],	 direction0 * daughtermomentum[0]);
+
+  products->PushProducts(daughterparticle);
+  
+  //electronic neutrino  1
+
+  daughtermomentum[1]=std::sqrt(Ene*Ene*EMax*EMax+2.0*Ene*EMax * daughtermass[1]);
+  G4ThreeVector direction1(sintheta,0.0,costheta);
+
+  direction1 *= rot;
+
+  G4DynamicParticle * daughterparticle1 = new G4DynamicParticle ( daughters[1],	 direction1 * daughtermomentum[1]);
+  products->PushProducts(daughterparticle1);
+
+  //muonic neutrino 2
+  
+     daughtermomentum[2]=std::sqrt(Enm*Enm*EMax*EMax +2.0*Enm*EMax*daughtermass[2]);
+  G4ThreeVector direction2(-Ene/Enm*sintheta,0,-Ee/Enm-Ene/Enm*costheta);
+
+  direction2 *= rot;
+
+  G4DynamicParticle * daughterparticle2 = new G4DynamicParticle ( daughters[2],
+	 direction2 * daughtermomentum[2]);
+  products->PushProducts(daughterparticle2);
+
+
+
+
+ // output message
+#ifdef G4VERBOSE
+  if (GetVerboseLevel()>1) {
+    G4cout << "MuDecayChannel::DecayIt ";
+    G4cout << "  create decay products in rest frame " <<G4endl;
+    products->DumpInfo();
+  }
+#endif
+  return products;
+}
+
+
+
+
+
+

geant4/LEMuSR/src/MuDecayChannelWithSpin.cc

@@ -0,0 +1,266 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+// ------------------------------------------------------------
+//      GEANT 4 class header file
+//
+//      History:
+//               17 August 2004 P.Gumplinger and T.MacPhail
+//               samples Michel spectrum including 1st order
+//               radiative corrections
+//               Reference: Florian Scheck "Muon Physics", in Physics Reports
+//                          (Review Section of Physics Letters) 44, No. 4 (1978)
+//                          187-248. North-Holland Publishing Company, Amsterdam
+//                          at page 210 cc.
+//
+//                          W.E. Fisher and F. Scheck, Nucl. Phys. B83 (1974) 25.
+//
+// ------------------------------------------------------------
+//
+#include "MuDecayChannelWithSpin.hh"
+
+#include "Randomize.hh"
+#include "G4DecayProducts.hh"
+#include "G4LorentzVector.hh"
+
+MuDecayChannelWithSpin::MuDecayChannelWithSpin(const G4String& theParentName, 
+						       G4double        theBR)
+                           : MuDecayChannel(theParentName,theBR)
+{
+}
+
+MuDecayChannelWithSpin::~MuDecayChannelWithSpin()
+{
+}
+
+G4DecayProducts *MuDecayChannelWithSpin::DecayIt(G4double) 
+{
+  // This version assumes V-A coupling with 1st order radiative correctons,
+  //              the standard model Michel parameter values, but
+  //              gives incorrect energy spectrum for neutrinos
+
+#ifdef G4VERBOSE
+  if (GetVerboseLevel()>1) G4cout << "MuDecayChannelWithSpin::DecayIt ";
+#endif
+
+  if (parent == 0) FillParent();  
+  if (daughters == 0) FillDaughters();
+
+  // parent mass
+  G4double parentmass = parent->GetPDGMass();
+
+  EMMU = parentmass;
+
+  //daughters'mass
+  G4double daughtermass[3]; 
+  G4double sumofdaughtermass = 0.0;
+  for (G4int index=0; index<3; index++){
+    daughtermass[index] = daughters[index]->GetPDGMass();
+    sumofdaughtermass += daughtermass[index];
+  }
+
+  EMASS = daughtermass[0];
+
+  //create parent G4DynamicParticle at rest
+  G4ThreeVector dummy;
+  G4DynamicParticle * parentparticle = new G4DynamicParticle( parent, dummy, 0.0);
+  //create G4Decayproducts
+  G4DecayProducts *products = new G4DecayProducts(*parentparticle);
+  delete parentparticle;
+
+  // calcurate electron energy
+
+  G4double michel_rho   = 0.75; //Standard Model Michel rho
+  G4double michel_delta = 0.75; //Standard Model Michel delta
+  G4double michel_xsi   = 1.00; //Standard Model Michel xsi
+  G4double michel_eta   = 0.00; //Standard Model eta
+
+  G4double rndm, x, ctheta;
+
+  G4double FG; 
+  G4double FG_max = 2.00;
+
+  G4double W_mue  = (EMMU*EMMU+EMASS*EMASS)/(2.*EMMU);
+  G4double x0     =           EMASS/W_mue;
+
+  G4double x0_squared = x0*x0;
+
+  // ***************************************************
+  //     x0 <= x <= 1.   and   -1 <= y <= 1
+  //
+  //     F(x,y) = f(x)*g(x,y);   g(x,y) = 1.+g(x)*y
+  // ***************************************************
+
+  // ***** sampling F(x,y) directly (brute force) *****
+
+  do{
+
+    // Sample the positron energy by sampling from F
+
+    rndm = G4UniformRand();
+
+    x = x0 + rndm*(1.-x0);
+
+    G4double x_squared = x*x;
+
+    G4double F_IS, F_AS, G_IS, G_AS;
+
+    F_IS = 1./6.*(-2.*x_squared+3.*x-x0_squared);
+    F_AS = 1./6.*std::sqrt(x_squared-x0_squared)*(2.*x-2.+std::sqrt(1.-x0_squared));
+
+    G_IS = 2./9.*(michel_rho-0.75)*(4.*x_squared-3.*x-x0_squared);
+    G_IS = G_IS + michel_eta*(1.-x)*x0;
+
+    G_AS = 3.*(michel_xsi-1.)*(1.-x);
+    G_AS = G_AS+2.*(michel_xsi*michel_delta-0.75)*(4.*x-4.+std::sqrt(1.-x0_squared));
+    G_AS = 1./9.*std::sqrt(x_squared-x0_squared)*G_AS;
+
+    F_IS = F_IS + G_IS;
+    F_AS = F_AS + G_AS;
+
+    // *** Radiative Corrections ***
+
+    G4double R_IS = F_c(x,x0);
+
+    G4double F = 6.*F_IS + R_IS/std::sqrt(x_squared-x0_squared);
+
+    // *** Radiative Corrections ***
+
+    G4double R_AS = F_theta(x,x0);
+
+    rndm = G4UniformRand();
+
+    ctheta = 2.*rndm-1.;
+
+    G4double G = 6.*F_AS - R_AS/std::sqrt(x_squared-x0_squared);
+
+    FG = std::sqrt(x_squared-x0_squared)*F*(1.+(G/F)*ctheta);
+
+    if(FG>FG_max){
+      G4cout<<"***Problem in Muon Decay *** : FG > FG_max"<<G4endl;
+      FG_max = FG;
+    }
+
+    rndm = G4UniformRand();
+
+  }while(FG<rndm*FG_max);
+
+  G4double energy = x * W_mue;
+
+  rndm = G4UniformRand();
+
+  G4double phi = twopi * rndm;
+
+  if(energy < EMASS) energy = EMASS;
+
+  // calculate daughter momentum
+  G4double daughtermomentum[3];
+
+  daughtermomentum[0] = std::sqrt(energy*energy - EMASS*EMASS);
+
+  G4double stheta = std::sqrt(1.-ctheta*ctheta);
+  G4double cphi = std::cos(phi);
+  G4double sphi = std::sin(phi);
+
+  //Coordinates of the decay positron with respect to the muon spin
+
+  G4double px = stheta*cphi;
+  G4double py = stheta*sphi;
+  G4double pz = ctheta;
+
+  G4ThreeVector direction0(px,py,pz);
+
+  direction0.rotateUz(parent_polarization);
+
+  G4DynamicParticle * daughterparticle0 
+    = new G4DynamicParticle( daughters[0], daughtermomentum[0]*direction0);
+
+  products->PushProducts(daughterparticle0);
+
+
+  // daughter 1 ,2 (neutrinos)
+  // create neutrinos in the C.M frame of two neutrinos
+  G4double energy2 = parentmass*(1.0 - x/2.0); 
+  G4double vmass   = std::sqrt((energy2-daughtermomentum[0])*(energy2+daughtermomentum[0]));
+  G4double beta = -1.0*daughtermomentum[0]/energy2;
+  G4double costhetan = 2.*G4UniformRand()-1.0;
+  G4double sinthetan = std::sqrt((1.0-costhetan)*(1.0+costhetan));
+  G4double phin  = twopi*G4UniformRand()*rad;
+  G4double sinphin = std::sin(phin);
+  G4double cosphin = std::cos(phin);
+
+  G4ThreeVector direction1(sinthetan*cosphin,sinthetan*sinphin,costhetan);
+  G4DynamicParticle * daughterparticle1 
+    = new G4DynamicParticle( daughters[1], direction1*(vmass/2.));
+  G4DynamicParticle * daughterparticle2
+    = new G4DynamicParticle( daughters[2], direction1*(-1.0*vmass/2.));
+
+  // boost to the muon rest frame
+  G4LorentzVector p4;
+  p4 = daughterparticle1->Get4Momentum();
+  p4.boost( direction0.x()*beta, direction0.y()*beta, direction0.z()*beta);
+  daughterparticle1->Set4Momentum(p4);
+  p4 = daughterparticle2->Get4Momentum();
+  p4.boost( direction0.x()*beta, direction0.y()*beta, direction0.z()*beta);
+  daughterparticle2->Set4Momentum(p4);
+  products->PushProducts(daughterparticle1);
+  products->PushProducts(daughterparticle2);
+  daughtermomentum[1] = daughterparticle1->GetTotalMomentum();
+  daughtermomentum[2] = daughterparticle2->GetTotalMomentum();
+
+  // output message
+#ifdef G4VERBOSE
+  if (GetVerboseLevel()>1) {
+    G4cout << "MuDecayChannelWithSpin::DecayIt ";
+    G4cout << "  create decay products in rest frame " <<G4endl;
+    products->DumpInfo();
+  }
+#endif
+  return products;
+}
+
+G4double MuDecayChannelWithSpin::R_c(G4double x){
+
+  G4int n_max = (int)(100.*x);
+
+  if(n_max<10)n_max=10;
+
+  G4double L2 = 0.0;
+
+  for(G4int n=1; n<=n_max; n++){
+    L2 += std::pow(x,n)/(n*n);
+  }
+
+  G4double omega = std::log(EMMU/EMASS);
+
+  G4double r_c;
+
+  r_c = 2.*L2-(pi*pi/3.)-2.;
+  r_c = r_c + omega * (1.5+2.*std::log((1.-x)/x));
+  r_c = r_c - std::log(x)*(2.*std::log(x)-1.);
+  r_c = r_c + (3.*std::log(x)-1.-1./x)*std::log(1.-x);
+
+  return r_c;
+}

geant4/LEMuSR/src/lem4Axial2DElField.cc

@@ -0,0 +1,341 @@
+#include "lem4Axial2DElField.hh"
+#include "G4UnitsTable.hh"
+//#include "lem4Parameters.hh"
+
+lem4Axial2DElField::lem4Axial2DElField(const char* filename, G4double fieldValue, G4double lenUnit, G4double fieldNormalisation, G4LogicalVolume* logVolume, G4ThreeVector positionOfTheCenter) : F04ElementField(positionOfTheCenter, logVolume),
+ ffieldValue(fieldValue)
+
+//lem4Axial2DElField::lem4Axial2DElField(const G4String filename, double fieldValue, double lenUnit, double fieldNormalisation, double offset) : ffieldValue(fieldValue/1000.0), zOffset(offset), invertR(false), invertZ(false)
+{
+  //  double lenUnit   = decimeter; = 100   // Base unit mm
+  //  double fieldUnit = kV;        = 0.001 // Base unit MV
+  //  double fieldNorm = 0.00001 = 1E-5     // = 0.001/100
+  G4cout << "\n-----------------------------------------------------------"
+	 << "\n      Electric field"
+	 << "\n-----------------------------------------------------------"
+         << G4endl;
+  // G4cout << " kilovolt = "<< kilovolt << G4endl; // = 1e-3 MV - default G4 unit
+  ///G4cout << "\n Potential set to "<< fieldValue/1000.0/kilovolt << " kV"<< G4endl;
+  G4cout << "\n Potential set to "<< fieldValue/kilovolt << " kV"<< G4endl;
+  G4cout << "\n ---> " "Reading 2D E-field map from " << filename << " ... " << G4endl;
+  std::ifstream file(filename); // Open the file for reading
+
+  // Start reading file content
+  char buffer[256];
+  
+  // Read table dimensions first
+  file >> nr >> nz; // r - radial, z - longitudinal coordinate 
+
+  G4cout << "      2D field table dimensions (r-z): ["
+         << nr << ", " << nz << "] "
+         << G4endl;
+
+  // Set up storage space for table
+  rField.resize(nr);
+  zField.resize(nr);
+  int ir, iz;
+
+  for (ir = 0; ir < nr; ir++) {
+    rField[ir].resize(nz);
+    zField[ir].resize(nz);
+  }
+
+  // Ignore header information. All lines whose first character
+  // is '%' are considered to be part of the header.
+  do {
+    file.getline(buffer, 256);
+  } while (buffer[0] != '%');
+
+  // Read in the data: [r, z, Er, Ez]
+  double rval, zval, er, ez;
+  for (ir = 0; ir < nr; ir++) {
+    for (iz = 0; iz < nz; iz++) {
+      file >> rval >> zval >> er >> ez;
+      if (ir == 0 && iz == 0) {
+	minr = rval * lenUnit;
+	minz = zval * lenUnit;
+      }
+      rField[ir][iz] = er*fieldNormalisation;
+      zField[ir][iz] = ez*fieldNormalisation;
+    }
+  }
+  G4cout << "      Normalisation coeff.: " << fieldNormalisation << G4endl;
+  file.close();
+
+  maxr = rval * lenUnit;
+  maxz = zval * lenUnit;
+
+  G4cout << "\n ---> ... done reading (assumed order: r, z, Er, Ez)." << G4endl;
+  G4cout << "\n ---> Min values r, z: "
+	 << minr/cm << " " << minz/cm << " cm "
+	 << "\n ---> Max values r, z: "
+	 << maxr/cm << " " << maxz/cm << " cm " << G4endl;
+
+  // Should really check that the limits are not the wrong way around.
+  if (maxr < minr) {Invert("x");} ///{std::swap(maxr, minr); invertR = true;}
+  if (maxz < minz) {Invert("z");} ///{std::swap(maxz, minz); invertZ = true;}
+  if (maxr < minr || maxz < minz){ ///(invertR == true || invertZ == true){
+  G4cout << "\n      After reordering:"
+	 << "\n ---> Min values r, z: "
+	 << minr/cm << " " << minz/cm << " cm "
+	 << "\n ---> Max values r, z: "
+	 << maxr/cm << " " << maxz/cm << " cm " << G4endl;
+  }
+
+  dr = maxr - minr;
+  dz = maxz - minz;
+  
+  G4cout << " ---> Range of values: "
+	 << dr/cm << " cm (in r) and " << dz/cm << " cm (in z)."
+	 << "\n-----------------------------------------------------------\n" << G4endl;
+}
+
+
+///lem4Axial2DElField::~lem4Axial2DElField() /// Made virtual!
+///{
+///  delete [] &rField ;
+///  delete [] &zField ;
+///}
+
+
+void lem4Axial2DElField::addFieldValue(const G4double  point[4], 
+                                             G4double *field) const
+{
+  G4double B[3]; // Field value obtained from the field table
+  ///TS
+  ///G4cout<<"TTfileTT Global coord. ("<<point[0]/mm<<", "<<point[1]/mm<<", "<<point[2]/mm<<")."<<G4endl;
+  G4ThreeVector global(point[0],point[1],point[2]);
+  G4ThreeVector local;
+
+  local = global2local.TransformPoint(global);
+  ///TS
+  ///G4cout<<"TTfileTT Local coord. ("<<local[0]/mm<<", "<<local[1]/mm<<", "<<local[2]/mm<<")."<<G4endl;
+  ///G4cout<<"The LOGICAL volume is named "<<lvolume->GetName()<<G4endl;
+    
+  double r = sqrt(local.x()*local.x()+local.y()*local.y());
+  double z = fabs(local.z());
+  double z_sign = (local.z()>0) ? 1.:-1.;
+  
+  // Check that the point is within the defined region 
+  if ( r < maxr && z < maxz ) {
+    // Relative point position within region, normalized to [0,1].
+    double rfraction = (r - minr) / dr;
+    double zfraction = (z - minz) / dz;
+    
+    // Need addresses of these to pass to modf below.
+    // modf uses its second argument as an OUTPUT argument.
+    double rdindex, zdindex;
+    
+    // Position of the point within the cuboid defined by the
+    // nearest surrounding tabulated points
+    double rlocal = ( modf(rfraction*(nr-1), &rdindex));
+    double zlocal = ( modf(zfraction*(nz-1), &zdindex));
+    
+    // The indices of the nearest tabulated point whose coordinates
+    // are all less than those of the given point
+    int rindex = static_cast<int>(rdindex);
+    int zindex = static_cast<int>(zdindex);
+    
+    //cks  The following check is necessary - even though xindex and zindex should never be out of range,
+    //     it may happen (due to some rounding error ?).  It is better to leave the check here.
+    if ((rindex<0)||(rindex>(nr-2))) {
+      std::cout<<"SERIOUS PROBLEM:  rindex out of range!  rindex="<<rindex<<"   r="<<r<<"  rfraction="<<rfraction<<std::endl;
+      if (rindex<0) rindex=0;
+      else rindex=nr-2;
+    }
+    if ((zindex<0)||(zindex>(nz-2))) {
+      std::cout<<"SERIOUS PROBLEM:  zindex out of range!  zindex="<<zindex<<"   z="<<z<<"  zfraction="<<zfraction<<std::endl;
+      if (zindex<0) zindex=0;
+      else zindex=nz-2;
+    }
+
+    //    G4cout<<"xField["<<xindex<<"]["<<zindex<<"]="<<xField[xindex  ][zindex  ]<<G4endl;
+    //    G4cout<<"zField["<<xindex<<"]["<<zindex<<"]="<<zField[xindex  ][zindex  ]<<G4endl;
+   
+    // Interpolate between the neighbouring points
+    double Bfield_R =
+      rField[rindex  ][zindex  ] * (1-rlocal) * (1-zlocal) +
+      rField[rindex  ][zindex+1] * (1-rlocal) *    zlocal  +
+      rField[rindex+1][zindex  ] *    rlocal  * (1-zlocal) +
+      rField[rindex+1][zindex+1] *    rlocal  *    zlocal  ;
+    B[0] = (r>0) ? Bfield_R * (local.x() /r) : 0.;
+    B[1] = (r>0) ? Bfield_R * (local.y() /r) : 0.;
+    B[2] =
+      zField[rindex  ][zindex  ] * (1-rlocal) * (1-zlocal) +
+      zField[rindex  ][zindex+1] * (1-rlocal) *    zlocal  +
+      zField[rindex+1][zindex  ] *    rlocal  * (1-zlocal) +
+      zField[rindex+1][zindex+1] *    rlocal  *    zlocal  ;
+    
+    B[0] *= ffieldValue * z_sign;
+    B[1] *= ffieldValue * z_sign;
+    B[2] *= ffieldValue;
+
+    G4ThreeVector finalField(B[0],B[1],B[2]);
+    finalField = global2local.Inverse().TransformAxis(finalField);
+
+    field[0] += finalField.x();
+    field[1] += finalField.y();
+    field[2] += finalField.z();
+  }
+  //  G4cout<<"Kamil: Field: ("<<field[0]/tesla<<","<<field[1]/tesla<<","<<field[2]/tesla<<")"<<G4endl;
+
+}
+
+
+
+/* OLD IMPLEMENTATION - CHANGED WITH GLOBALFIELD! TS
+void lem4Axial2DElField::GetFieldValue(const double point[4], double *Efield) const
+{
+  //  musrEventAction* myEventAction= musrEventAction::GetInstance();
+  //  G4int evNr=myEventAction->GetLatestEventNr();
+  //  G4int evNrKriz=6795;  //457;  //14250
+  //  if (evNr==evNrKriz) {
+  //    std::cout<<"evNr="<<evNr<<std::endl;
+  //    printf ("for point= %f %f %f   B= %10.10f %10.10f %10.10f \n",
+  //    	    point[0],point[1],point[2],Bfield[0]/tesla,Bfield[1]/tesla,Bfield[2]/tesla);
+  //  }
+  Efield[0]=0.; Efield[1]=0.; Efield[2]=0.;
+
+  double r = sqrt(point[0]*point[0]+point[1]*point[1]);
+  //Apply a fixed offset (in mm) to the z - coordinate.
+  double rel_z = (point[2] - zOffset)/mm;
+  double z = fabs(rel_z);
+  double z_sign = (rel_z>0) ? 1.:-1.;
+  //if (evNr==evNrKriz) std::cout<<"r ="<<r<<"   maxr="<<maxr<<std::endl;
+
+#ifdef DEBUG_INTERPOLATING_FIELD
+double dst = sqrt(point[0]*point[0] + point[1]*point[1]);
+G4cout<<"POSITION:              "<< G4BestUnit(point[0], "Length")<<" "<< G4BestUnit(point[1], "Length") <<" "<< G4BestUnit(dst, "Length") <<" "<< G4BestUnit(point[2], "Length") <<G4endl;
+  G4cout<<"POSITION in field map: "<< G4BestUnit(r, "Length") <<" "<< G4BestUnit(z, "Length")<<G4endl;
+#endif
+
+
+  // Check that the point is within the defined region
+  if ( r<maxr && z<maxz ) {
+    // if (evNr>evNrKriz) std::cout<<"bol som tu"<<std::endl;
+
+    // Position of given point within region, normalized to the range
+    // [0,1]
+    double rfraction = (r - minr) / dr;
+    double zfraction = (z - minz) / dz;
+
+    if (invertR) { rfraction = 1 - rfraction;}
+    if (invertZ) { zfraction = 1 - zfraction;}
+    // Need addresses of these to pass to modf below.
+    // modf uses its second argument as an OUTPUT argument.
+    double rdindex, zdindex;
+
+    // Position of the point within the cuboid defined by the
+    // nearest surrounding tabulated points
+    double rlocal = ( modf(rfraction*(nr-1), &rdindex));
+    double zlocal = ( modf(zfraction*(nz-1), &zdindex));
+
+    // The indices of the nearest tabulated point whose coordinates
+    // are all less than those of the given point
+    int rindex = static_cast<int>(rdindex);
+    int zindex = static_cast<int>(zdindex);
+
+    //cks  The following check is necessary - even though xindex and zindex should never be out of range,
+    //     it may happen (due to some rounding error ?).  It is better to leave the check here.
+    if ((rindex<0)||(rindex>(nr-2))) {
+      std::cout<<"SERIOUS PROBLEM:  rindex out of range!  rindex="<<rindex<<"   r="<<r<<"  rfraction="<<rfraction<<std::endl;
+      if (rindex<0) rindex=0;
+      else rindex=nr-2;
+    }
+    if ((zindex<0)||(zindex>(nz-2))) {
+      std::cout<<"SERIOUS PROBLEM:  zindex out of range!  zindex="<<zindex<<"   z="<<z<<"  zfraction="<<zfraction<<std::endl;
+      if (zindex<0) zindex=0;
+      else zindex=nz-2;
+    }
+
+#ifdef DEBUG_INTERPOLATING_FIELD
+      G4cout << "Local r, z: " << rlocal << " " << zlocal << G4endl;
+      G4cout << "Index r, z: " << rindex << " " << zindex << G4endl;
+#endif
+
+    // Interpolate between the neighbouring points
+    double Efield_R =
+      rField[rindex  ][zindex  ] * (1-rlocal) * (1-zlocal) +
+      rField[rindex  ][zindex+1] * (1-rlocal) *    zlocal  +
+      rField[rindex+1][zindex  ] *    rlocal  * (1-zlocal) +
+      rField[rindex+1][zindex+1] *    rlocal  *    zlocal  ;
+    Efield[0] = (r>0) ? Efield_R * (point[0]/r) : 0.;
+    Efield[1] = (r>0) ? Efield_R * (point[1]/r) : 0.;
+    Efield[2] =
+      zField[rindex  ][zindex  ] * (1-rlocal) * (1-zlocal) +
+      zField[rindex  ][zindex+1] * (1-rlocal) *    zlocal  +
+      zField[rindex+1][zindex  ] *    rlocal  * (1-zlocal) +
+      zField[rindex+1][zindex+1] *    rlocal  *    zlocal  ;
+// ATTENTION if dealing with MAGNETIC FIELDS reverse x, y and z signs!!
+    Efield[0] = Efield[0] * ffieldValue; // * z_sign;
+    Efield[1] = Efield[1] * ffieldValue; // * z_sign;
+    Efield[2] = Efield[2] * ffieldValue * z_sign;
+  }
+
+
+
+  // Set some small field if field is almost zero (to avoid internal problems of Geant).
+  if (sqrt(Efield[0]*Efield[0]+Efield[1]*Efield[1]+Efield[2]*Efield[2])<1.0E-12*volt) {
+    //    if (evNr>evNrKriz) std::cout<<"bol som tuna"<<std::endl;
+    //    Bfield[0] = 0.0;
+    //    Bfield[1] = 0.0;
+    //    Bfield[2] = Bfield[2] + 0.00001*tesla;
+    #ifdef DEBUG_INTERPOLATING_FIELD
+    G4cout<<"Zero field case"<<G4endl;
+    #endif
+    Efield[2] = 1.0E-12*volt;
+  }
+  //  Print the field (for debugging)
+  //  if ((point[2]>-1*cm)&&(point[2]<1*cm)) {
+  //    printf ("for point= %f %f %f   B= %10.10f %10.10f %10.10f \n",
+  //  	    point[0],point[1],point[2],Bfield[0]/tesla,Bfield[1]/tesla,Bfield[2]/tesla);
+  //  }
+  //  if (evNr>evNrKriz) std::cout<<"this is the end"<<std::endl;
+
+#ifdef DEBUG_INTERPOLATING_FIELD
+//G4cout << " Volt/meter factor = "<< volt/meter << G4endl; // = 1e-9
+G4cout<<"Field Value " << G4BestUnit(Efield[0]*meter,"Electric potential") <<"/m " <<Efield[1]/volt*meter <<" V/m "<< Efield[2]/volt*meter <<" V/m " <<G4endl;
+G4cout<<"FieldVal " << ffieldValue/kilovolt << G4endl;
+#endif
+
+}
+
+*/
+
+G4double lem4Axial2DElField::GetNominalFieldValue() {
+  return ffieldValue;
+}
+
+void lem4Axial2DElField::SetNominalFieldValue(G4double newFieldValue) {
+  // Rescale the EM field to account for the new applied field value
+  ffieldValue=newFieldValue;
+  G4cout<<"lem4Axial2DElField.cc:   ffieldValue changed to = "<< ffieldValue/kilovolt<<" kV."<<G4endl;
+}
+
+void lem4Axial2DElField::Invert(const char* indexToInvert) {
+  // This function inverts the field table indices along a given axis (r or z).
+  // It should be called whenever x or z coordinates in the initial field table
+  // are ordered in a decreasing order.
+  std::vector< std::vector< double > > rFieldTemp(rField);
+  std::vector< std::vector< double > > zFieldTemp(zField);
+  G4bool invertR=false;
+  G4bool invertZ=false;
+
+  G4cout<<"Check that the lem4Axial2DElField::Invert() function works properly!"<<G4endl;
+  G4cout<<"It has not been tested yet!"<<G4endl;
+
+  if (strcmp(indexToInvert,"r")==0) {invertR=true; std::swap(maxr, minr);}
+  if (strcmp(indexToInvert,"z")==0) {invertZ=true; std::swap(maxz, minz);}
+
+  for (int ir=0; ir<nr; ir++) {
+    for (int iz=0; iz<nz; iz++) {
+      if (invertR) {
+	rField[ir][iz] = rFieldTemp[nr-1-ir][iz];
+      }
+      else if(invertZ) {
+	rField[ir][iz] = rFieldTemp[ir][nz-1-iz];
+      }
+    }
+  }
+  
+}

geant4/LEMuSR/src/lem4DetectorMessenger.cc

@@ -0,0 +1,210 @@
+#include "lem4DetectorMessenger.hh"
+#include "lem4DetectorConstruction.hh"
+#include "G4UIdirectory.hh"
+#include "G4UIcmdWithAString.hh"
+#include "G4UIcmdWithADoubleAndUnit.hh"
+#include "G4UIcmdWithAnInteger.hh"
+#include "G4UIcmdWithoutParameter.hh"
+#include "G4UIcmdWith3Vector.hh"
+#include "G4UIcmdWith3VectorAndUnit.hh"
+
+#include "G4RunManager.hh"   //cks  included in order to be able to change run ID
+#include "Randomize.hh"      //cks  included in order to initialise the random nr. generator by time
+#include <time.h>            //cks   -----------------------------||-------------------------------
+#include "lem4EventAction.hh" // cks needed for the initialisation of the random nr. generator by event nr.
+//#include <fstream>
+//#include <vector>
+#include "globals.hh"
+//#include "lem4Parameters.hh"
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+
+lem4DetectorMessenger::lem4DetectorMessenger(lem4DetectorConstruction* myDet)
+  :myDetector(myDet)
+{ 
+  lem4Dir = new G4UIdirectory("/lem4/");
+  lem4Dir->SetGuidance("UI commands specific to this example.");
+
+  CommandCmd = new G4UIcmdWithAString("/lem4/command",this);
+  CommandCmd->SetGuidance("This command will be used for the detector construction (and ignored by the default messenger.");
+  //  CommandCmd->SetParameterName("choice",false);
+  CommandCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
+
+  runDir = new G4UIdirectory("/lem4/run/");
+  runDir->SetGuidance("lem4 run control");
+
+  RunIDSetCmd = new G4UIcmdWithAnInteger("/lem4/run/runID",this);
+  RunIDSetCmd->SetGuidance("Set the run number");
+  RunIDSetCmd->SetParameterName("something",false);
+  RunIDSetCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
+
+  RandomOptionCmd = new G4UIcmdWithAnInteger("/lem4/run/randomOption",this);
+  RandomOptionCmd->SetGuidance("Specify the random number generator initialisation");
+  RandomOptionCmd->SetGuidance("   0 ... no initialisation (default)");
+  RandomOptionCmd->SetGuidance("   1 ... use actual computer time to initialise now");
+  RandomOptionCmd->SetGuidance("   2 ... use event number to initialise at the beginning of each event");
+  RandomOptionCmd->SetGuidance("   3 ... read in the random no. initial values for each event from a file");
+  RandomOptionCmd->SetParameterName("randomOpt",false);
+  RandomOptionCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
+
+  HowOftenToPrintEventCmd = new G4UIcmdWithAnInteger("/lem4/run/howOftenToPrintEvent",this);
+  HowOftenToPrintEventCmd->SetGuidance("Each n-th event will be notified.  Set _n_ by this command.");
+  HowOftenToPrintEventCmd->SetParameterName("howOftenToPrintEv",false);
+  HowOftenToPrintEventCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
+
+  detDir = new G4UIdirectory("/lem4/det/");
+  detDir->SetGuidance("detector control.");
+
+  //  WhichProcessesCmd = new G4UIcmdWithAString("/lem4/det/processes",this);
+  //  WhichProcessesCmd ->SetGuidance("Select Standard, Low Energy or Penelope processes");
+  //  WhichProcessesCmd ->SetParameterName("mes_processes",false);
+  //  WhichProcessesCmd ->AvailableForStates(G4State_PreInit,G4State_Idle);
+
+  UpdateCmd = new G4UIcmdWithoutParameter("/lem4/det/update",this);
+  UpdateCmd->SetGuidance("Update calorimeter geometry.");
+  UpdateCmd->SetGuidance("This command MUST be applied before \"beamOn\" ");
+  UpdateCmd->SetGuidance("if you changed geometrical value(s).");
+  UpdateCmd->AvailableForStates(G4State_Idle);
+ 
+  //  FieldCmd = new G4UIcmdWithADoubleAndUnit("/lem4/det/setField",this);  
+  //  FieldCmd->SetGuidance("Define magnetic field.");
+  //  FieldCmd->SetGuidance("Magnetic field will be in Z direction.");
+  //  FieldCmd->SetParameterName("Bz",false);
+  //  FieldCmd->SetUnitCategory("Magnetic flux density");
+  //  FieldCmd->AvailableForStates(G4State_PreInit,G4State_Idle);  
+
+  UFieldCmd = new G4UIcmdWithADoubleAndUnit("/lem4/det/setUniformField",this);  
+  UFieldCmd->SetGuidance("Define uniform magnetic field.");
+  UFieldCmd->SetGuidance("Magnetic field will be in Z direction.");
+  UFieldCmd->SetParameterName("Bz",false);
+  UFieldCmd->SetUnitCategory("Magnetic flux density");
+  UFieldCmd->AvailableForStates(G4State_PreInit,G4State_Idle);  
+
+  //  GFieldCmd = new G4UIcmdWithADoubleAndUnit("/lem4/det/setGaussianField",this);  
+  //  GFieldCmd = new G4UIcmdWith3VectorAndUnit("/lem4/det/setGaussianField",this);
+  GFieldCmd = new G4UIcmdWith3Vector("/lem4/det/setGaussianField",this);
+  GFieldCmd->SetGuidance("Define gaussian magnetic field: intensity in T, sigma in mm, and a dummy variable.");
+  GFieldCmd->SetGuidance("Magnetic field will be in Z direction.");
+  GFieldCmd->SetParameterName("Bz","sigmaBz","dummy",true,false);
+  //  GFieldCmd->SetUnitCategory("Magnetic flux density");
+  GFieldCmd->AvailableForStates(G4State_PreInit,G4State_Idle);  
+
+///  UEFieldCmd = new G4UIcmdWithADoubleAndUnit("/lem4/det/setUnifEField",this);  
+///  UEFieldCmd->SetGuidance("Define uniform electric field.");
+///  UEFieldCmd->SetGuidance("Electric field will be in Z direction.");
+///  UEFieldCmd->SetParameterName("Ez",false);
+///  UEFieldCmd->SetUnitCategory("Electric field");
+///  UEFieldCmd->AvailableForStates(G4State_PreInit,G4State_Idle);  
+
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+lem4DetectorMessenger::~lem4DetectorMessenger()
+{
+  //  delete WhichProcessesCmd;
+  delete UpdateCmd;
+  delete detDir;
+  delete lem4Dir;
+  delete CommandCmd;
+  //  delete FieldCmd;
+  delete UFieldCmd;
+  delete GFieldCmd;
+///  delete UEFieldCmd;
+  delete RunIDSetCmd;
+  delete RandomOptionCmd;
+  delete HowOftenToPrintEventCmd;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+void lem4DetectorMessenger::SetNewValue(G4UIcommand* command,G4String newValue)  { 
+  
+  //  if( command == WhichProcessesCmd )
+  //    { lem4Parameters* myParameters = lem4Parameters::GetInstance();
+  //      lem4Parameters	-> SetMyProcesses(newValue); }
+    //    lem4Parameters* myParameters = lem4Parameters::GetInstance();
+    //    myParameters -> strcnpy(lem4Parameters::myProcesses,newValue,99);
+    //    lem4Parameters::myProcesses[99]='\0';
+
+  if( command == UpdateCmd )
+    { myDetector->UpdateGeometry(); }
+
+  //  if( command == FieldCmd )
+  //    { myDetector->SetMagField("fieldprofiles/input.dat",FieldCmd->GetNewDoubleValue(newValue));}
+  
+  if( command == UFieldCmd )
+    { myDetector->SetUniformMagField(UFieldCmd->GetNewDoubleValue(newValue));}
+
+  if( command == GFieldCmd )
+    { myDetector->SetGaussianMagField(GFieldCmd->GetNew3VectorValue(newValue));}
+  
+///  if( command == UEFieldCmd )
+///    { myDetector->SetUniformElField(UEFieldCmd->GetNewDoubleValue(newValue));}
+
+  if( command == RunIDSetCmd )
+    { (G4RunManager::GetRunManager())->SetRunIDCounter(RunIDSetCmd->GetNewIntValue(newValue));}
+  
+  if( command == RandomOptionCmd )
+    { 
+      G4int RandomOption=RandomOptionCmd->GetNewIntValue(newValue);
+      if (RandomOption == 1) {
+	//	G4long seed=time(0); //returns time in seconds as an integer
+	//	HepRandom::setTheSeed(seed);//changes the seed of the random engine
+	G4cout << "******************************************" << G4endl;
+	G4cout << "*** Random Seed set by the system time ***" << G4endl;
+	G4cout << "******************************************" << G4endl;
+	long seeds[2];
+	time_t systime = time(NULL);
+	seeds[0] = (long) systime;
+	seeds[1] = (long) (systime*G4UniformRand());
+	G4cout << "seed1: " << seeds[0] << "; seed2: " << seeds[1] << G4endl;
+	CLHEP::HepRandom::setTheSeeds(seeds);
+	CLHEP::HepRandom::showEngineStatus();
+      }
+      else if (RandomOption == 2) {
+	G4cout << "*******************************************" << G4endl;
+	G4cout << "*** Random Seed set by the event number ***" << G4endl;
+	G4cout << "*******************************************" << G4endl;
+	lem4EventAction::setRandomNrSeedAccordingEventNr=1;
+	//	lem4EventAction::setMyEventNr(70);
+      }
+      else if (RandomOption == 3) {
+	G4cout << "*******************************************" << G4endl;
+	G4cout << "*** Random Seed set from external file  ***" << G4endl;
+	G4cout << "*******************************************" << G4endl;
+	lem4EventAction::setRandomNrSeedFromFile=1;
+
+	std::ifstream indata;
+	int num;
+
+	indata.open("randomNum.dat"); // opens the file
+	if(!indata) { // file couldn't be opened
+	  G4cout << "Error: file could not be opened" << G4endl;
+	  exit(1);
+	}
+	//	vector<int> * seedVector = new vector<int>;
+	vector<int> * seedVector = lem4EventAction::GetPointerToSeedVector();
+	indata >> num;
+	while ( !indata.eof() ) { // keep reading until end-of-file
+	  G4cout << "The next number is " << num << G4endl;
+	  seedVector->push_back(num);
+	  indata >> num; // sets EOF flag if no value found
+	  
+	  //	  lem4EventAction::RandomNrInitialisers->push_back(num);
+	}
+	indata.close();
+	G4cout << "End-of-file reached.." << seedVector->size()<<G4endl;
+	//	lem4EventAction::RandomNrInitialisers=seedVector;
+      }
+    }
+  if ( command == HowOftenToPrintEventCmd ) 
+    {
+      G4int n = HowOftenToPrintEventCmd->GetNewIntValue(newValue);
+      lem4EventAction::nHowOftenToPrintEvent=n;
+    }
+  
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

geant4/LEMuSR/src/lem4ErrorMessage.cc

@@ -0,0 +1,62 @@
+#include "lem4ErrorMessage.hh"
+
+lem4ErrorMessage::lem4ErrorMessage():nErrors(1)
+{
+  pointerToErrors=this;
+  severityWord[INFO]="INFO";
+  severityWord[WARNING]="WARNING";
+  severityWord[SERIOUS]="SERIOUS";
+  severityWord[FATAL]="FATAL";
+}
+
+lem4ErrorMessage::~lem4ErrorMessage() {}
+
+lem4ErrorMessage* lem4ErrorMessage::pointerToErrors=NULL;
+lem4ErrorMessage* lem4ErrorMessage::GetInstance() {
+  return pointerToErrors;
+}
+
+void lem4ErrorMessage::lem4Error(SEVERITY severity, G4String message, G4bool silent) {
+  std::map<G4String,ErrorStruct>::iterator it;
+  it = ErrorMapping.find(message);
+  if (it == ErrorMapping.end()) {      // The error message is called for the first time
+    ErrorStruct actualErrorMessage;
+    actualErrorMessage.mesSeverity = severity;
+    actualErrorMessage.nTimes = 1;
+    ErrorMapping[message]=actualErrorMessage;
+    G4cout<<"!!!"<<severityWord[severity]<<"!!! "<<message<<"  (First time occurrence)"<<G4endl;
+    nErrors++;
+  }
+  else {                                // The error message is called for more than the first time
+    (*it).second.nTimes++;
+  }
+
+  // Print out the error message if required
+  if ((!silent)||(severity==FATAL)) { 
+    if ((*it).second.nTimes>1) {
+      G4cout<<"!!!"<<severityWord[severity]<<"!!! "<<message
+	    <<" ("<<(*it).second.nTimes<<" occurences)"<<G4endl;
+    }
+  }
+  
+  if (severity==FATAL) {
+    G4cout<<"S T O P     F O R C E D!"<<G4endl;
+    exit(1);
+  }
+}
+
+
+
+void lem4ErrorMessage::PrintErrorSummary() {
+  std::map<G4String,ErrorStruct>::iterator it;
+  G4cout<<"------   ERROR SUMMARY:  -------------------------------------------------------"<<G4endl;
+  for (G4int i=0; i<4; i++) {
+    for ( it=ErrorMapping.begin() ; it != ErrorMapping.end(); it++ ) {
+      if ((*it).second.mesSeverity==i) {
+	G4cout<<severityWord[(*it).second.mesSeverity]<<" ("<<(*it).second.nTimes<<" times):"
+	      << (*it).first <<G4endl;
+      }
+    }
+  }
+G4cout<<"--------------------------------------------------------------------------------"<<G4endl;
+}

geant4/LEMuSR/src/lem4EventAction.cc

@@ -0,0 +1,182 @@
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+#include "lem4EventAction.hh"
+#include "G4Event.hh"
+#include "G4EventManager.hh"
+#include "G4TrajectoryContainer.hh"
+#include "G4Trajectory.hh"
+#include "G4VVisManager.hh"
+#include "G4ios.hh"
+#include "G4TransportationManager.hh"
+#include "G4FieldManager.hh"
+#include "lem4MagneticField.hh"
+#include "lem4TabulatedField3D.hh"
+#include "lem4TabulatedField2D.hh"
+#include "lem4RootOutput.hh"
+#include "lem4ErrorMessage.hh"
+#include "lem4SteppingAction.hh" ///
+#include "F04GlobalField.hh" /// Are these two really needed ??
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+G4bool lem4EventAction::setRandomNrSeedAccordingEventNr=0;
+G4bool lem4EventAction::setRandomNrSeedFromFile=0;
+G4int  lem4EventAction::nHowOftenToPrintEvent=10000;
+//vector<int> * lem4EventAction::RandomNrInitialisers=NULL;
+ 
+//long lem4EventAction::myEventNr=0;
+
+lem4EventAction::lem4EventAction() {
+  pointer=this;
+  fieldValueStart=0;
+  pointerToSeedVector = new vector<int>;
+  timeDependentField=false;
+  lastFieldValue=-10000*tesla;
+  pointerToMusrUniformField=NULL;
+  pointerToTabulatedField3D=NULL;
+  pointerToTabulatedField2D=NULL;
+  latestEventNr=-1;
+}
+lem4EventAction* lem4EventAction::pointer=0;
+lem4EventAction* lem4EventAction::GetInstance() {
+  return pointer;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+ 
+lem4EventAction::~lem4EventAction()
+{
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+void lem4EventAction::BeginOfEventAction(const G4Event* evt) {
+  // test error
+  //  lem4ErrorMessage::GetInstance()->lem4Error(SERIOUS,"test error",true);
+  //
+  
+  lem4SteppingAction::GetInstance()->DoAtTheBeginningOfEvent();
+
+  long thisEventNr = (long) (evt->GetEventID());
+
+  if (F04GlobalField::Exists()) {
+    F04GlobalField::getObject() -> CheckWhetherAnyNominalFieldValueNeedsToBeChanged(thisEventNr);
+  }
+  
+  
+  ///?long thisEventNr = (long) (evt->GetEventID());
+  latestEventNr = thisEventNr;
+  G4double actualFieldValue;
+  if (timeDependentField) {
+    //    actualFieldValue=fieldAtEnd-fieldAtBeginning
+    G4int i=int(double(thisEventNr)/double(maxEventNr)*fieldNrOfSteps);    // i ... nr of actual step in the field
+    actualFieldValue=fieldValueStart+fieldStep*i;
+    if (actualFieldValue!=lastFieldValue) {
+      lastFieldValue=actualFieldValue;
+      //      G4FieldManager* fieldMgr = G4TransportationManager::GetTransportationManager()->GetFieldManager();
+      //      //      fieldMgr->SetFieldValue(actualFieldValue);  //did not work
+      //      const G4Field* pointerToField = NULL;
+      //      pointerToField=fieldMgr->GetDetectorField();
+      //      pointerToField->GetFieldValue(0,0,0,0,
+      if (pointerToMusrUniformField) {
+	pointerToMusrUniformField->SetFieldValue(actualFieldValue);      
+        //      pointerToField->SetFieldValue(actualFieldValue); does not work
+	G4cout<<"Event "<<thisEventNr<<":  Uniform field value changed to ";
+	G4cout<<(actualFieldValue/tesla)<<"Tesla."<<G4endl;
+      }
+      else if (pointerToTabulatedField3D) {
+	pointerToTabulatedField3D->SetFieldValue(actualFieldValue);
+	G4cout<<"Event "<<thisEventNr<<":  Tabulated Field (3D) value changed to ";
+	G4cout<<(actualFieldValue/tesla)<<"Tesla."<<G4endl;
+      }
+      else if (pointerToTabulatedField2D) {
+	pointerToTabulatedField2D->SetFieldValue(actualFieldValue);
+	G4cout<<"Event "<<thisEventNr<<":  Tabulated Field (2D) value changed to ";
+	G4cout<<(actualFieldValue/tesla)<<"Tesla."<<G4endl;
+      }
+    }
+  }
+  else {actualFieldValue=fieldValueStart;}
+  lem4RootOutput* myRootOutput = lem4RootOutput::GetRootInstance();
+  myRootOutput->SetFieldValue(actualFieldValue);
+
+  //  if (lem4DetectorMessenger::setRandomNrSeedAccordingEventNr) {
+  if (setRandomNrSeedFromFile) {
+    //    G4cout<<"RandomNrInitialisers.size()="<<RandomNrInitialisers->size()<<G4endl;
+    if (thisEventNr < (long) pointerToSeedVector->size()) {
+      G4cout <<"lem4EventAction.cc: seed will be set to="<< pointerToSeedVector->at(thisEventNr)<<G4endl;
+      CLHEP::HepRandom::setTheSeed(pointerToSeedVector->at(thisEventNr));
+    }
+  }
+  else if (setRandomNrSeedAccordingEventNr) {
+    //    long seeds[2];
+    //    seeds[0] = (long) 234567890+thisEventNr*117;
+    //    seeds[1] = (long) 333222111+thisEventNr*173;
+    //
+    //    //    seeds[1] = (long) (evt->GetEventID());
+    //    //    seeds[0] = (long) 123456789;    // This leads to a gap in the decay time histogram fro N=100000 events
+    //    //    seeds[1] = (long) 333222111+thisEventNr;     // ----------------------------||------------------------------------
+    //    thisEventNr++;
+    //    CLHEP::HepRandom::setTheSeeds(seeds);
+    //    //    G4cout << "seed1: " << seeds[0] << "; seed2: " << seeds[1] << G4endl;
+    //
+    //    G4cout <<"      thisEventNr="<<thisEventNr;
+    CLHEP::HepRandom::setTheSeed(thisEventNr);
+    //    G4cout <<"     getTheSeed="<<CLHEP::HepRandom::getTheSeed()<< G4endl; 
+    CLHEP::RandGauss::setFlag(false);
+  }
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+ 
+void lem4EventAction::EndOfEventAction(const G4Event* evt)  {
+  //  cout << ":." << flush;
+  long thisEventNr = (long) evt->GetEventID();
+  
+  // get number of stored trajectories
+  //
+  G4TrajectoryContainer* trajectoryContainer = evt->GetTrajectoryContainer();
+  G4int n_trajectories = 0;
+  if (trajectoryContainer) n_trajectories = trajectoryContainer->entries();
+  
+  //  G4cout << ">>> Event " << evt->GetEventID() << G4endl;
+  
+  // periodic printing
+  //
+  //  if (thisEventNr != 0 and thisEventNr%10000 == 0) {
+  if (thisEventNr != 0 and thisEventNr%nHowOftenToPrintEvent == 0) {
+    time_t curr=time(0);
+    //char * ctime(const time_t * tp);
+    G4cout << ">>> Event " << evt->GetEventID() <<"\t at "<< ctime(&curr);
+    G4cout.flush();
+    //    G4cout << "                   seed set to "<< CLHEP::HepRandom::getTheSeed();//<< G4endl; 
+  }
+    
+  // extract the trajectories and draw them
+  //
+  if (G4VVisManager::GetConcreteInstance())  {
+    for (G4int i=0; i<n_trajectories; i++) 
+      { G4Trajectory* trj = (G4Trajectory*)
+	  ((*(evt->GetTrajectoryContainer()))[i]);
+	trj->DrawTrajectory(1000);
+      }
+  }
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+vector<int> * lem4EventAction::pointerToSeedVector=NULL;
+vector<int> * lem4EventAction::GetPointerToSeedVector() {
+  return pointerToSeedVector;
+}
+
+
+void lem4EventAction::SetTimeDependentField(G4bool setFieldToBeTimeDependend, G4double initialField,
+					    G4double finalField, G4int nrOfSteps) {
+  timeDependentField = setFieldToBeTimeDependend;
+  fieldValueStart    =  initialField;
+  fieldValueEnd      =  finalField;
+  fieldNrOfSteps     =  nrOfSteps;
+  fieldStep          =  (finalField-initialField)/(nrOfSteps-1);
+  G4cout<<"---&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&---"<<G4endl;
+}

geant4/LEMuSR/src/lem4GaussianField.cc

@@ -0,0 +1,28 @@
+#include "lem4GaussianField.hh"
+
+
+lem4GaussianField::lem4GaussianField(double fieldValue, double sigma):ffieldValue(fieldValue) {
+  fieldMagnitude=fieldValue;
+  RMS=sigma;
+  G4cout << "\n-----------------------------------------------------------"
+	 << "\n         Magnetic field ON"
+	 << "\n-----------------------------------------------------------"
+         << G4endl;
+  //  G4cout << " Gaussian magnetic field set to "<< fieldValue*1000 << " T,  with sigma in R="<< sigma<<" mm"<< G4endl;  
+  G4cout << "Gaussian magnetic field set to "<< fieldValue/tesla << " Tesla, with a radial sigma "<< sigma/mm<<" mm.\n"<< G4endl;  
+}
+
+void lem4GaussianField::GetFieldValue(const double point[4], double *Bfield ) const {
+  double x = point[0];
+  double y = point[1];
+  //  double z = point[2];
+  double r = sqrt(x*x+y*y);
+  Bfield[0] = 0;
+  Bfield[1] = 0;
+  Bfield[2] = fieldMagnitude*exp(-r*r/(2*RMS*RMS));
+  //  G4cout<<"z="<<z<<"  r="<<r<<"  B[2]="<<Bfield[2]<<G4endl;
+}
+
+G4double lem4GaussianField::GetFieldSetValue() {
+  return ffieldValue;
+}

geant4/LEMuSR/src/lem4MagneticField.cc

@@ -0,0 +1,70 @@
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+#include "lem4MagneticField.hh"
+#include "G4FieldManager.hh"
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+lem4MagneticField::lem4MagneticField()
+  : G4UniformMagField(G4ThreeVector())
+{
+  GetGlobalFieldManager()->SetDetectorField(this);
+  GetGlobalFieldManager()->CreateChordFinder(this);
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+lem4MagneticField::lem4MagneticField(G4ThreeVector fieldVector)
+  : G4UniformMagField(fieldVector)
+{
+  GetGlobalFieldManager()->SetDetectorField(this);    
+  GetGlobalFieldManager()->CreateChordFinder(this);
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+// Set the value of the Global Field to fieldValue along Z
+//
+void lem4MagneticField::SetFieldValue(G4double fieldValue)
+{
+   G4UniformMagField::SetFieldValue(G4ThreeVector(0,0,fieldValue));
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+// Set the value of the Global Field
+//
+void lem4MagneticField::SetFieldValue(G4ThreeVector fieldVector)
+{
+  // Find the Field Manager for the global field
+  G4FieldManager* fieldMgr= GetGlobalFieldManager();
+    
+  if(fieldVector!=G4ThreeVector(0.,0.,0.))
+  { 
+    G4UniformMagField::SetFieldValue(fieldVector);
+    fieldMgr->SetDetectorField(this);
+  } else {
+    // If the new field's value is Zero, then it is best to
+    //  insure that it is not used for propagation.
+    G4MagneticField* magField = NULL;
+    fieldMgr->SetDetectorField(magField);
+  }
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+lem4MagneticField::~lem4MagneticField()
+{
+  // GetGlobalFieldManager()->SetDetectorField(0);
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+#include "G4TransportationManager.hh"
+
+G4FieldManager*  lem4MagneticField::GetGlobalFieldManager()
+{
+  return G4TransportationManager::GetTransportationManager()->GetFieldManager();
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

geant4/LEMuSR/src/lem4MuFormation.cc

@@ -0,0 +1,106 @@
+//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
+//  Muonium Formation according to yield.cc function (through GetYields method).
+//  Id    : lem4MuFormation.cc, v 1.4
+//  Author: Taofiq PARAISO, T. Shiroka
+//  Date  : 2007-12
+//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
+
+#include "lem4MuFormation.hh"
+
+using namespace std;
+
+lem4MuFormation::lem4MuFormation(const G4String& name, G4ProcessType aType)
+               : G4VDiscreteProcess(name, aType){}
+
+lem4MuFormation::~lem4MuFormation(){}
+
+G4VParticleChange* lem4MuFormation::PostStepDoIt(const G4Track& trackData,
+                                                 const G4Step&  aStep)
+{ // Initialize ParticleChange  (by setting all its members equal to
+  //                             the corresponding members in G4Track)
+  fParticleChange.Initialize(trackData);
+
+  G4Track theNewTrack;
+  if(CheckCondition(aStep))
+    {
+      GetDatas(&aStep);
+      G4Step theStep;
+      PrepareSecondary( trackData);
+      
+      fParticleChange.AddSecondary(aSecondary);
+      fParticleChange.ProposeTrackStatus(fStopAndKill) ;
+    }  
+  else
+    {
+      fParticleChange.ProposeTrackStatus(trackData.GetTrackStatus()) ;
+    }
+  return &fParticleChange;
+}
+
+
+G4bool lem4MuFormation::CheckCondition(const G4Step& aStep)
+{ // Decide when to call the MuFormation process - i.e. for muons going through the C foil.
+  G4bool condition=false;
+  p_name = aStep.GetTrack()->GetDefinition()->GetParticleName(); // particle name  
+  //if(p_name == "mu+"&&aStep.GetTrack()->GetVolume()->GetLogicalVolume()->GetName()=="log_CFoil") 
+  std::string logVolName = aStep.GetTrack()->GetVolume()->GetLogicalVolume()->GetName();
+  if(p_name == "mu+" && ((logVolName=="log_coulombCFoil")||(logVolName=="log_CFoil")))
+    {
+      condition=true;
+    }
+  return condition;
+}
+
+
+G4double lem4MuFormation::GetMeanFreePath(const G4Track&, 
+                                                G4double,
+                                                G4ForceCondition* condition)
+{
+  *condition = Forced;
+   return DBL_MAX;
+}
+
+
+void lem4MuFormation::GetDatas(const G4Step* aStep)
+{    // Particle generation according to yield table
+     particleTable=G4ParticleTable::GetParticleTable();
+     rnd=G4UniformRand();
+     G4double E = aStep->GetTrack()->GetDynamicParticle()->GetKineticEnergy()/keV;
+     Gonin.GetYields(E,105.658369*1000,yvector); // Energy [keV], muon mass [keV/c2], yield table
+     G4String p_new = "Mu";
+      
+     // Positive muon
+     if(p_name=="mu+")
+       {
+	 if(rnd<yvector[0]) 
+	   {
+	     particle = particleTable->FindParticle(p_name) ;
+	   }
+	 else 
+	   {
+	     particle = particleTable->FindParticle(p_new);
+	   }
+
+     // Set the new dynamic particle DP
+        DP = new G4DynamicParticle(particle, 
+	         aStep->GetTrack()->GetDynamicParticle()->GetMomentumDirection(),
+	         aStep->GetTrack()->GetDynamicParticle()->GetKineticEnergy());
+	 
+	 // IMPORTANT : COPY THOSE DATA TO GET THE SAME PARTICLE PROPERTIES!!!
+	 // SHOULD BE KEPT WHEN BUILDING A PARTICLE CHANGE  
+	 DP->SetProperTime(  aStep->GetTrack()->GetDynamicParticle()->GetProperTime());
+	 DP->SetPolarization(aStep->GetTrack()->GetDynamicParticle()->GetPolarization().x(),
+	                     aStep->GetTrack()->GetDynamicParticle()->GetPolarization().y(),
+			     aStep->GetTrack()->GetDynamicParticle()->GetPolarization().z());
+	 DP->SetPreAssignedDecayProperTime(aStep->GetTrack()->GetDynamicParticle()->GetPreAssignedDecayProperTime());
+       }
+}
+
+
+void lem4MuFormation::PrepareSecondary(const G4Track& track)
+{
+  if(p_name=="mu+")
+    {
+      aSecondary = new G4Track(DP,track.GetGlobalTime(),track.GetPosition());
+    }
+}

geant4/LEMuSR/src/lem4MuScatter.cc

@@ -0,0 +1,81 @@
+//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
+//  Muonium "Scattering"
+//  Id    : lem4MuScatter.cc, v 1.4
+//  Author: Taofiq PARAISO, T. Shiroka
+//  Date  : 2007-12
+//  Notes : Simplified model for Mu scattering. Spin effects have been excluded.
+//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
+
+#include "lem4MuScatter.hh"
+
+using namespace std;
+
+lem4MuScatter::lem4MuScatter(const G4String& name,
+			     G4ProcessType  aType)
+               : G4VDiscreteProcess(name, aType){}
+
+lem4MuScatter:: ~lem4MuScatter(){}
+
+/*! - At the end of the step, the current volume is checked and if Muonium is in a solid 
+  material (except for the carbon foil where it is generated), it is stopped immediately. */
+G4VParticleChange* lem4MuScatter::PostStepDoIt(const G4Track& trackData,
+                                               const G4Step& aStep)
+{
+  fParticleChange.Initialize(trackData);
+  
+  //! Tao - Get time information */
+  itime = trackData.GetProperTime();
+  gtime = trackData.GetGlobalTime();
+  ftime = trackData.GetDynamicParticle()->GetPreAssignedDecayProperTime(); 
+  
+  deltatime = ftime - itime;
+  fParticleChange.ProposeGlobalTime(deltatime + itime -gtime);
+  
+  /*! - Set position, momentum, energy and time of the particle change. */
+  fParticleChange.ProposePosition(trackData.GetPosition());
+  fParticleChange.ProposeMomentumDirection(trackData.GetMomentumDirection());
+  fParticleChange.ProposeEnergy(trackData.GetKineticEnergy());
+  fParticleChange.ProposeGlobalTime(gtime);
+  fParticleChange.ProposeProperTime(itime);
+  fParticleChange.ProposeTrackStatus(trackData.GetTrackStatus()) ;
+  
+  /*! - Verify the condition of applying the process: if Mu is in a material 
+        different than vacuum and carbon foil, then stop it directly. */
+  if( CheckCondition(aStep))
+    {
+      fParticleChange.ProposePosition(trackData.GetStep()->GetPreStepPoint()->GetPosition());
+      fParticleChange.ProposeTrackStatus(fStopButAlive) ;
+    }
+  
+  /*! - Return the changed particle object. */
+  return &fParticleChange;
+}
+
+
+/*! - Muonium will be stopped as soon as it enters a material different than vacuum or C foil. */
+G4bool lem4MuScatter::CheckCondition(const G4Step& aStep)
+{
+  G4bool condition = false;
+  p_name = aStep.GetTrack()->GetDefinition()->GetParticleName(); // particle name  
+  if(p_name == "Mu" && aStep.GetTrack()->GetVolume()->GetLogicalVolume()->GetName()!="log_CFoil" &&
+  aStep.GetTrack()->GetVolume()->GetLogicalVolume()->GetMaterial()->GetName()!="G4_Galactic")
+    {
+      condition=true;
+    }
+  return condition;
+}  
+
+
+G4double lem4MuScatter::GetMeanFreePath(const G4Track&,
+					G4double,
+					G4ForceCondition* condition)
+{
+  *condition = Forced;
+   return DBL_MAX;
+}
+
+
+void lem4MuScatter::PrepareSecondary(const G4Track& track)
+{
+  aSecondary = new G4Track(DP,track.GetDynamicParticle()->GetPreAssignedDecayProperTime(),track.GetPosition());
+}

geant4/LEMuSR/src/lem4Muonium.cc

@@ -0,0 +1,107 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+//
+// $Id: lem4Muonium.cc,v 1.13 2007/03/15 06:53:58 kurasige Exp $
+// GEANT4 tag $Name: geant4-09-00 $
+//
+// 
+// ----------------------------------------------------------------------
+//      GEANT 4 class implementation file
+//
+//      History: first implementation, based on object model of
+//      4th April 1996, G. Cosmo
+// **********************************************************************
+// New implementation as an utility class  M. Asai, 26 July 2004
+// ----------------------------------------------------------------------
+
+#include "lem4Muonium.hh"
+#include "G4ParticleTable.hh"
+
+#include "MuDecayChannel.hh"
+#include "G4DecayTable.hh"
+
+// ######################################################################
+// ###                          MUONIUM                               ###
+// ######################################################################
+lem4Muonium* lem4Muonium::theInstance = 0;
+
+lem4Muonium* lem4Muonium::Definition()
+{
+  if (theInstance !=0) return theInstance;
+  const G4String name = "Mu";
+  // search in particle table]
+  G4ParticleTable* pTable = G4ParticleTable::GetParticleTable();
+  G4ParticleDefinition* anInstance = pTable->FindParticle(name);
+  if (anInstance ==0)
+  {
+  // create particle
+  //
+  //    Arguments for constructor are as follows
+  //               name             mass          width         charge
+  //             2*spin           parity  C-conjugation
+  //          2*Isospin       2*Isospin3       G-parity
+  //               type    lepton number  baryon number   PDG encoding
+  //             stable         lifetime    decay table
+  //             shortlived      subType    anti_encoding
+  anInstance = new G4ParticleDefinition(
+                 name,   0.1056584*GeV, 2.99591e-16*MeV,   0.*eplus, 
+		    1,               0,             0,          
+		    0,               0,             0,             
+	     "lepton",              -1,             0,         -1313,
+		false,      2197.03*ns,          NULL,
+             false,           "mu"
+              );
+   // Bohr magnetron of Muonium - T. Shiroka
+   // The magnetic moment of Mu is the sum of those of mu+ and e- with
+   // the respective gyromagnetic ratio anomalies as coefficients
+   
+   G4double muBmu =  0.5*eplus*hbar_Planck/(0.10565840*GeV/c_squared);
+   G4double muBel = -0.5*eplus*hbar_Planck/(0.51099906*MeV/c_squared);
+   G4double muB   =  1.0011659208*muBmu + 1.0011596521859*muBel;
+   
+   anInstance->SetPDGMagneticMoment( muB );
+
+  //create Decay Table 
+  G4DecayTable* table = new G4DecayTable();
+  // create a decay channel
+  G4VDecayChannel* mode = new MuDecayChannel("Mu",1.00);
+  table->Insert(mode);
+  anInstance->SetDecayTable(table);
+  }
+  theInstance = reinterpret_cast<lem4Muonium*>(anInstance);
+  return theInstance;
+}
+
+lem4Muonium*  lem4Muonium::MuoniumDefinition()
+{
+  return Definition();
+}
+
+lem4Muonium*  lem4Muonium::Muonium()
+{
+  return Definition();
+}
+

geant4/LEMuSR/src/lem4Parameters.cc

@@ -0,0 +1,71 @@
+#include "lem4Parameters.hh"
+
+///lem4Parameters::lem4Parameters() 
+///  :typeOfProcesses("standard")
+///{
+///  pointerToParameters=this;
+///}
+
+lem4Parameters::lem4Parameters(G4String steeringFileName) 
+  :typeOfProcesses("coulombAndMultiple") //lowenergy")
+{
+  pointerToParameters=this;
+
+  // Read in the parameters, which have to be known before the detector construction is run
+  // (and therefore the parameters can not be read in in the lem4DetectorConstruction.cc class).
+
+  FILE *fSteeringFile=fopen(steeringFileName.c_str(),"r");
+  if (fSteeringFile==NULL) {
+    G4cout<<"lem4Parameters::lem4Parameters:  steeringFileName=\""<<steeringFileName
+	  <<"\" not opened for some reason."<<G4endl;
+  } 
+  G4cout<<"lem4Parameters::lem4Parameters:  steeringFileName=\""<<steeringFileName<<"\" opened."<<G4endl;
+  char  line[501];
+
+  while (!feof(fSteeringFile)) {
+    fgets(line,500,fSteeringFile);
+    if ((line[0]!='#')&&(line[0]!='\n')&&(line[0]!='\r')) {
+      char tmpString0[100]="Unset";
+      sscanf(&line[0],"%s",tmpString0);
+     
+      // First find out how many events will be generated 
+      // (should be known at an early stage, if the field is to be set-up in steps):
+      if (strcmp(tmpString0,"/run/beamOn")==0) {
+	int nev;
+	sscanf(&line[0],"%*s %d", &nev);
+	lem4Parameters::nrOfEventsToBeGenerated = nev;
+      }
+      
+      // Now find out about some other private parameters that also need to be initialised at an early stage 
+      if (strcmp(tmpString0,"/lem4/command")!=0) {continue; }///{ break; }
+
+      char tmpString1[100]="Unset", tmpString2[100]="Unset";
+      sscanf(&line[0],"%*s %s %s",tmpString1,tmpString2);
+      
+//! First commented by TS. Currently not in use! or not strictly necessary.
+      if (strcmp(tmpString1,"G4GeneralParticleSource")==0){
+      	if (strcmp(tmpString2,"true")==0){ lem4Parameters::boolG4GeneralParticleSource = true; }
+      }
+
+      
+    }
+  }
+  fclose(fSteeringFile);
+}
+
+
+lem4Parameters::~lem4Parameters() {}
+
+lem4Parameters* lem4Parameters::pointerToParameters=NULL;
+lem4Parameters* lem4Parameters::GetInstance() {
+return pointerToParameters;
+}
+
+G4bool   lem4Parameters::storeOnlyEventsWithHits =true;
+G4double lem4Parameters::signalSeparationTime=100*nanosecond;
+G4bool   lem4Parameters::storeOnlyTheFirstTimeHit=false;
+G4bool   lem4Parameters::includeMuoniumProcesses =true;
+G4bool   lem4Parameters::field_DecayWithSpin=false; //Added by TS to confrom with the new StepAction ...
+G4bool   lem4Parameters::boolG4GeneralParticleSource=false; ///! This is not strictly necessary! TS
+G4int    lem4Parameters::nrOfEventsToBeGenerated=0;
+

geant4/LEMuSR/src/lem4PhysicsList.cc

@@ -0,0 +1,416 @@
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+#include "globals.hh"
+#include "G4ios.hh"
+#include "lem4PhysicsList.hh"
+#include "G4VPhysicsConstructor.hh"
+#include "G4ProcessManager.hh"
+#include "G4ParticleTypes.hh"
+
+#include "G4MuonDecayChannel.hh"
+#include "G4DecayTable.hh"
+//#include "lem4MuonDecayChannel.hh"
+//#include "lem4Decay.hh"
+//cks Added to have Geant default muon decay with spin
+#include "G4MuonDecayChannelWithSpin.hh"
+//#include "G4AtRestSpinPrecession.hh"
+
+//TS Classes which account for Muonium as "particle" and its spin
+#include "lem4Muonium.hh"
+#include "MuDecayChannel.hh"
+#include "MuDecayChannelWithSpin.hh"
+
+#include "lem4Parameters.hh"
+
+// Constructor and Destructor  
+lem4PhysicsList::lem4PhysicsList():G4VUserPhysicsList()
+{
+  defaultCutValue = 0.1*mm; // 1.0*cm; 
+  SetVerboseLevel(0);
+}
+
+lem4PhysicsList::~lem4PhysicsList()
+{}
+
+
+// Construction of the different particles (calls different construction methods)
+
+void lem4PhysicsList::ConstructParticle()
+{
+  ConstructBosons();
+  ConstructLeptons();
+  ConstructBaryons();
+}
+
+// Bosons
+
+void lem4PhysicsList::ConstructBosons()
+{
+  // pseudo-particles
+  G4Geantino::GeantinoDefinition();
+  G4ChargedGeantino::ChargedGeantinoDefinition();
+
+  // gamma
+  G4Gamma::GammaDefinition();
+}
+
+// Leptons
+
+void lem4PhysicsList::ConstructLeptons()
+{
+  //  e+/-
+  G4Electron::ElectronDefinition();
+  G4Positron::PositronDefinition();
+  // mu+/-
+  G4MuonPlus::MuonPlusDefinition();
+  G4MuonMinus::MuonMinusDefinition();
+  // Muonium - TS
+  lem4Muonium::MuoniumDefinition();
+  
+  G4NeutrinoE::NeutrinoEDefinition();
+  G4AntiNeutrinoE::AntiNeutrinoEDefinition();
+  // nu_mu
+  G4NeutrinoMu::NeutrinoMuDefinition();
+  G4AntiNeutrinoMu::AntiNeutrinoMuDefinition();
+
+  // Decays of muon and muonium
+  //cks:  Trial to use Geant4 muon decay with spin
+  G4DecayTable* MuonPlusDecayTable = new G4DecayTable();
+  MuonPlusDecayTable -> Insert(new G4MuonDecayChannelWithSpin("mu+",1.00));
+  G4MuonPlus::MuonPlusDefinition() -> SetDecayTable(MuonPlusDecayTable);
+  
+  //TS: Using the muonium decay with and without spin
+  G4DecayTable* MuoniumDecayTable = new G4DecayTable();
+  MuoniumDecayTable -> Insert(new MuDecayChannel("Mu",0.50));
+  MuoniumDecayTable -> Insert(new MuDecayChannelWithSpin("Mu",0.5));
+  lem4Muonium::MuoniumDefinition() -> SetDecayTable(MuoniumDecayTable);
+  //MuoniumDecayTable ->DumpInfo(); // Info on muonium decay channels
+
+}
+
+// Mesons (only some light mesons)
+
+void lem4PhysicsList::ConstructMesons()
+{
+  G4PionPlus::PionPlusDefinition();
+  G4PionMinus::PionMinusDefinition();
+  G4PionZero::PionZeroDefinition();
+}
+
+// Baryons
+
+void lem4PhysicsList::ConstructBaryons()
+{
+  G4Proton::ProtonDefinition();
+  G4AntiProton::AntiProtonDefinition();
+  G4Neutron::NeutronDefinition();
+  G4AntiNeutron::AntiNeutronDefinition();
+}
+
+
+
+
+// Physical processes - general
+
+void lem4PhysicsList::ConstructProcess()
+{
+  AddTransportation();
+  ConstructEM();
+  ConstructGeneral();
+}
+
+// Declaration of the different processes
+#include "G4ComptonScattering.hh"
+#include "G4GammaConversion.hh"
+#include "G4PhotoElectricEffect.hh"
+
+#include "G4MultipleScattering.hh"
+
+#include "G4eIonisation.hh"
+#include "G4eBremsstrahlung.hh"
+#include "G4eplusAnnihilation.hh"
+
+#include "G4MuIonisation.hh"
+#include "G4MuBremsstrahlung.hh"
+#include "G4MuPairProduction.hh"
+
+#include "G4hIonisation.hh"
+
+#include "G4UserSpecialCuts.hh"
+
+//#include "lem4AtRestSpinRotation.hh"
+
+// For low energy physics processes:
+#include "G4LowEnergyCompton.hh"
+//#include "G4LowEnergyPolarizedCompton.hh"
+#include "G4LowEnergyGammaConversion.hh"
+#include "G4LowEnergyPhotoElectric.hh"
+#include "G4LowEnergyRayleigh.hh"
+#include "G4LowEnergyBremsstrahlung.hh"
+#include "G4LowEnergyIonisation.hh"
+#include "G4hLowEnergyIonisation.hh"
+
+
+// For Penelope processes:
+#include "G4PenelopeCompton.hh"
+#include "G4PenelopeGammaConversion.hh"
+#include "G4PenelopePhotoElectric.hh"
+#include "G4PenelopeRayleigh.hh"
+#include "G4PenelopeIonisation.hh"
+#include "G4PenelopeBremsstrahlung.hh"
+#include "G4PenelopeAnnihilation.hh"
+
+// For Coulomb scattering instead of multiple scattering
+#include "G4CoulombScattering.hh"
+
+// For Muonium formation in the Carbon foil
+#include "lem4MuFormation.hh" // includes the yield function Y = Y(E).
+
+// For a simple Muonium "scattering" when Mu hits solid materials
+#include "lem4MuScatter.hh"
+
+
+// Construction methods for the different processes
+
+void lem4PhysicsList::ConstructEM()
+{
+  G4String myTypeOfProcesses  = lem4Parameters::GetInstance()->GetMyTypeOfProcesses();
+  G4cout<<"   uuuuuuuuu myTypeOfProcesses="<<myTypeOfProcesses<<G4endl;
+  
+  G4bool inclMuProcesses = lem4Parameters::includeMuoniumProcesses;
+  
+  theParticleIterator->reset();
+  while( (*theParticleIterator)() ){
+    G4ParticleDefinition* particle = theParticleIterator->value();
+    G4ProcessManager* pmanager = particle->GetProcessManager();
+    G4String particleName = particle->GetParticleName();
+    
+    if (particleName == "gamma") {               // gamma
+      if (myTypeOfProcesses=="lowenergy") {
+	pmanager->AddDiscreteProcess(new G4LowEnergyPhotoElectric);
+	pmanager->AddDiscreteProcess(new G4LowEnergyCompton);
+	pmanager->AddDiscreteProcess(new G4LowEnergyGammaConversion);
+	pmanager->AddDiscreteProcess(new G4LowEnergyRayleigh);
+      }
+      else if (myTypeOfProcesses=="penelope") {
+	pmanager->AddDiscreteProcess(new G4PenelopePhotoElectric);
+	pmanager->AddDiscreteProcess(new G4PenelopeCompton);
+	pmanager->AddDiscreteProcess(new G4PenelopeGammaConversion);
+	pmanager->AddDiscreteProcess(new G4PenelopeRayleigh);
+      }
+      else { // Standard G4 (default)
+	pmanager->AddDiscreteProcess(new G4PhotoElectricEffect);
+	pmanager->AddDiscreteProcess(new G4ComptonScattering);
+	pmanager->AddDiscreteProcess(new G4GammaConversion);
+      }
+
+    }
+    else if (particleName == "e-") {  //electron
+      if (myTypeOfProcesses=="lowenergy") {
+	pmanager->AddProcess(new G4MultipleScattering,     -1, 1,1);
+	pmanager->AddProcess(new G4LowEnergyIonisation,    -1, 2,2);
+	pmanager->AddProcess(new G4LowEnergyBremsstrahlung,-1,-1,3);    
+      }
+      else if (myTypeOfProcesses=="penelope") {
+	pmanager->AddProcess(new G4MultipleScattering,     -1, 1, 1);
+	pmanager->AddProcess(new G4PenelopeIonisation,     -1, 2, 2);
+	pmanager->AddProcess(new G4PenelopeBremsstrahlung, -1,-1, 3);
+      }
+      else if (myTypeOfProcesses=="coulomb") {
+	pmanager->AddDiscreteProcess(new G4CoulombScattering);
+	pmanager->AddProcess(new G4eIonisation,       -1, 2,2);
+	pmanager->AddProcess(new G4eBremsstrahlung,   -1, 3,3);      
+      }
+      else { // Standard G4 (default)
+	pmanager->AddProcess(new G4MultipleScattering,-1, 1,1);
+	pmanager->AddProcess(new G4eIonisation,       -1, 2,2);
+	pmanager->AddProcess(new G4eBremsstrahlung,   -1, 3,3);      
+      }
+    }
+    
+    else if (particleName == "e+") {
+      
+      if (myTypeOfProcesses=="penelope") {
+	pmanager->AddProcess(new G4MultipleScattering,     -1, 1, 1);
+	pmanager->AddProcess(new G4PenelopeIonisation,     -1, 2, 2);
+	pmanager->AddProcess(new G4PenelopeBremsstrahlung, -1,-1, 3);
+	pmanager->AddProcess(new G4PenelopeAnnihilation,    0,-1, 4);
+      }
+      else if (myTypeOfProcesses=="coulomb") {
+	pmanager->AddDiscreteProcess(new G4CoulombScattering);
+	pmanager->AddProcess(new G4eIonisation,       -1, 2,2);
+	pmanager->AddProcess(new G4eBremsstrahlung,   -1, 3,3);
+	pmanager->AddProcess(new G4eplusAnnihilation,  0,-1,4);
+      }
+      else {  // Standard G4 (default)
+	pmanager->AddProcess(new G4MultipleScattering,-1, 1,1);
+	pmanager->AddProcess(new G4eIonisation,       -1, 2,2);
+	pmanager->AddProcess(new G4eBremsstrahlung,   -1, 3,3);
+	pmanager->AddProcess(new G4eplusAnnihilation,  0,-1,4);
+      }
+    }
+    
+    else if ((particleName=="mu+")||(particleName=="mu-")) {  //muon  
+      
+      if (myTypeOfProcesses=="coulomb") {
+          pmanager->AddDiscreteProcess(new G4CoulombScattering);  // TS - Attention use Meyer!!
+	  }
+      else if (myTypeOfProcesses=="coulombAndMultiple") {
+	  std::cout <<"musrPhysicsList:  Switching between Coulomb and Multiple scattering for mu+"<<std::endl;
+	  pmanager->AddProcess(new G4MultipleScattering,-1, 1,1);
+	  pmanager->AddDiscreteProcess(new G4CoulombScattering);
+	  }
+      else {
+	  pmanager->AddProcess(new G4MultipleScattering,-1, 1,1); // TS - Attention use Meyer!!
+	  }
+	  
+      if (inclMuProcesses){ // This accounts ONLY for Mu formation!
+          G4VProcess* aMuoniumFormation = new lem4MuFormation();
+	  pmanager->AddProcess(aMuoniumFormation);
+	  pmanager->SetProcessOrdering(aMuoniumFormation,idxPostStep,2);
+	  //pmanager->AddProcess(new lem4MuFormation, -1,-1,2); // TS Muonium formation process - shorthand
+	  }
+      
+      pmanager->AddProcess(new G4MuIonisation,      -1, 2,2);
+      pmanager->AddProcess(new G4MuBremsstrahlung,  -1, 3,3);
+      pmanager->AddProcess(new G4MuPairProduction,  -1, 4,4);       
+      //cks Change to Geant 4 default muon decay with spin (instead of using the code of Taofiq).
+      //      pmanager->AddProcess(new lem4AtRestSpinRotation, 1, -1, -1);
+      //      lem4Decay* theDecayProcess = new lem4Decay();
+      //      pmanager->AddProcess(theDecayProcess);
+      //      pmanager ->SetProcessOrderingToLast(theDecayProcess, idxAtRest);
+      //      pmanager ->SetProcessOrdering(theDecayProcess, idxPostStep);
+      //
+      //      // The spin precession (rotation) at rest is already included in 
+      //      // the G4DecayWithSpin();
+      //      G4AtRestSpinPrecession* theSpinPrecession = new G4AtRestSpinPrecession();
+      //      pmanager->AddRestProcess(theSpinPrecession);
+      
+      
+      
+      if (particle->GetParticleName()=="mu+"){
+      G4DecayWithSpin* theDecayProcess = new G4DecayWithSpin();
+      //lem4DecayWithSpin* theDecayProcess = new lem4DecayWithSpin();
+      pmanager->AddProcess(theDecayProcess);
+      pmanager->SetProcessOrderingToLast(theDecayProcess, idxAtRest);
+      pmanager->SetProcessOrdering(theDecayProcess, idxPostStep);
+      }
+      }
+ 
+    
+    else if ((particle->GetParticleName()=="Mu")&&(inclMuProcesses)) { // other Mu processes
+      G4cout<<"\nAccounting for Muonium formation and other Mu processes.\n"<<G4endl;
+      //pmanager->AddProcess(new G4MultipleScattering, -1, 1, 1); 
+      //pmanager->AddProcess(new lem4MuScatter, -1, 1, 1); <--- ERROR ?!?
+      //pmanager->AddProcess(new lem4MuScatter, -1, -1, 1); //<--- ERROR ?!?
+      
+      // Muonium "scattering"
+      G4VProcess* aMuScatt = new lem4MuScatter();
+      pmanager->AddProcess(aMuScatt);
+      pmanager->SetProcessOrdering(aMuScatt, idxPostStep, 1);
+            
+      // Muonium decay process
+      G4Decay* theDecayProcess = new G4Decay();
+      //lem4DecayWithSpin* theDecayProcess = new lem4DecayWithSpin();
+      pmanager->AddProcess(theDecayProcess);
+      pmanager->SetProcessOrderingToLast(theDecayProcess, idxAtRest);
+      pmanager->SetProcessOrdering(theDecayProcess, idxPostStep);
+      }
+      
+      
+            
+      /*
+      else if (particle->GetParticleName()=="Mu")
+	{
+	  //!
+	    Half of the muonium has an isotropic decay.
+	  //
+	  G4DecayTable* MuoniumDecayTable = new G4DecayTable();
+	  MuoniumDecayTable -> Insert(new G4MuonDecayChannelWithSpin("Mu",0.5)); // ?? with spin? LEMuSRMuonDecayChannel("Mu",0.5));
+	  MuoniumDecayTable -> Insert(new G4MuonDecayChannel("Mu",0.5)); 
+	  MuoniumDecayTable ->DumpInfo();
+	  MuoniumParticle::MuoniumDefinition() -> SetDecayTable(MuoniumDecayTable);
+	  
+	  G4ProcessManager* pmanager = particle->GetProcessManager();
+	  if (theLEMuSRDecayProcess->IsApplicable(*particle)) 
+	    { 
+	      pmanager ->AddProcess(theLEMuSRDecayProcess);
+	      pmanager ->AddProcess(aStepLimiter);
+	      
+	      // set ordering 
+	      //	      pmanager ->SetProcessOrdering(aStepLimiter, idxPostStep, 1);  // not needed for the muonium
+	      pmanager ->SetProcessOrderingToLast(theLEMuSRDecayProcess, idxPostStep);
+	      pmanager ->SetProcessOrderingToLast(theLEMuSRDecayProcess, idxAtRest);
+	    }
+
+	      pmanager->DumpInfo();
+
+
+	} */
+      
+      //csk 
+    //}
+    
+    else if ((!particle->IsShortLived()) &&
+	       (particle->GetPDGCharge() != 0.0) && 
+	       (particle->GetParticleName() != "chargedgeantino")) {
+      // All stable, charged particles except geantino
+      pmanager->AddProcess(new G4MultipleScattering,     -1,1,1);
+      if (myTypeOfProcesses=="lowenergy") {
+	pmanager->AddProcess(new G4hLowEnergyIonisation, -1,2,2);
+      }
+      else { 
+	pmanager->AddProcess(new G4hIonisation,          -1,2,2);
+      }
+      ///pmanager->AddProcess(new G4UserSpecialCuts,  -1,-1,3);      
+    }
+  }
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+
+
+#include "G4Decay.hh"
+void lem4PhysicsList::ConstructGeneral()
+{
+}
+
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+#include "G4Region.hh"
+#include "G4RegionStore.hh"
+#include "G4ProductionCuts.hh"
+
+void lem4PhysicsList::SetCuts()
+{
+  //G4VUserPhysicsList::SetCutsWithDefault method sets 
+  //the default cut value for all particle types 
+  //
+  SetCutsWithDefault();
+
+  //cks  Set some cuts specific to a given region:
+  //  G4Region* region;
+  //  G4String regName;
+  //  G4ProductionCuts* cuts;
+  //  
+  //  regName="Target_region";
+  //  region = G4RegionStore::GetInstance()->GetRegion(regName);
+  //  if (region==NULL) {
+  //    G4cout << "lem4PhysicsList.cc: ERROR!  Region "<<regName<<" not found."<<G4endl;
+  //    G4cout << "    Program is forced to stop!"<<G4endl;
+  //    exit(EXIT_FAILURE);
+  //  }
+  //  cuts = new G4ProductionCuts;
+  //
+  //  cuts->SetProductionCut(0.005*mm,G4ProductionCuts::GetIndex("mu+"));
+  //  cuts->SetProductionCut(0.005*mm,G4ProductionCuts::GetIndex("e-"));
+  //  region->SetProductionCuts(cuts);
+  //csk
+    
+   if (verboseLevel>0) DumpCutValuesTable();
+   DumpCutValuesTable();
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+

geant4/LEMuSR/src/lem4PrimaryGeneratorAction.cc

@@ -0,0 +1,318 @@
+#include "lem4PrimaryGeneratorAction.hh"
+#include "lem4DetectorConstruction.hh"
+#include "lem4PrimaryGeneratorMessenger.hh"
+#include "G4Event.hh"
+#include "G4ParticleGun.hh"
+#include "G4ParticleTable.hh"
+#include "G4ParticleDefinition.hh"
+#include "Randomize.hh"
+#include "G4ios.hh"
+#include "G4ParticleGun.hh"
+#include "G4UnitsTable.hh"
+#include "globals.hh"
+#include "G4Gamma.hh"
+#include "G4ThreeVector.hh"
+#include "G4RunManager.hh"
+#include "time.h"
+#include <iomanip>
+#include "lem4RootOutput.hh"   //cks for storing some info in the Root output file
+#include "lem4ErrorMessage.hh"
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
+ 
+lem4PrimaryGeneratorAction::lem4PrimaryGeneratorAction(
+                                            lem4DetectorConstruction* lem4DC)
+  :lem4Detector(lem4DC), x0(0), y0(0), z0(-124*cm), xSigma(0), ySigma(0), zSigma(0), 
+   rMaxAllowed(1e10*mm), zMinAllowed(-1e10*mm), zMaxAllowed(1e10*mm),
+   p0(0), pSigma(0), pMinAllowed(0), pMaxAllowed(1e10*mm),
+   xangle0(0), yangle0(0), xangleSigma(0), yangleSigma(0), pitch(0),
+   UnpolarisedMuonBeam(false), xPolarisIni(1.), yPolarisIni(0.), zPolarisIni(0.),
+   muonDecayTimeMin(-1), muonDecayTimeMax(-1), muonMeanLife(2197.03*ns),
+   takeMuonsFromTurtleFile(false)
+						      //, firstCall(true)
+{
+  G4int n_particle = 1;
+  //cksdel  particleGun  = new lem4ParticleGun(n_particle);
+  particleGun  = new G4ParticleGun(n_particle);
+  
+  //create a messenger for this class
+  gunMessenger = new lem4PrimaryGeneratorMessenger(this);
+
+  // default particle kinematic
+  G4ParticleTable* particleTable = G4ParticleTable::GetParticleTable();
+  G4ParticleDefinition* particle= particleTable->FindParticle("mu+");
+  particleGun->SetParticleDefinition(particle);
+  mu_mass = particle->GetPDGMass();
+} 
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
+
+lem4PrimaryGeneratorAction::~lem4PrimaryGeneratorAction()
+{
+  delete particleGun;
+  delete gunMessenger;
+  if (takeMuonsFromTurtleFile) {fclose(fTurtleFile);}
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
+
+void lem4PrimaryGeneratorAction::GeneratePrimaries(G4Event* anEvent)
+{
+  // This function is called at the begining of event.
+
+  //  // First of all check the setting of some variables.  Do it only once (for the first event).
+  //  if (firstCall) {
+  //    firstCall=false;
+  //    char message[200];
+  //    cout<<"********************  called just once  **********************"<<G4endl;
+  //    // Check that the restriction of the generated position is reasonable:
+  //    if ( sqrt(rMaxAllowed-x0)*(rMaxAllowed-x0)+(rMaxAllowed-y0)*(rMaxAllowed-y0) > 
+  //         5*sqrt(xSigma*xSigma+ySigma*ySigma)  ) {
+  //      sprintf(message,"lem4PrimaryGeneratorAction::GeneratePrimaries: Too strict restriction on the generated radius.");
+  //      lem4ErrorMessage::GetInstance()->lem4Error(FATAL,"message",true);
+  //    }
+  //    // Check that the restriction on the z-coordinate of the generated postion is reasonable:
+  //    if ( ((-zMaxAllowed+z0) > 5*fabs(zSigma)) || ((zMinAllowed-z0) > 5*fabs(zSigma)) ) {
+  //      sprintf(message,"lem4PrimaryGeneratorAction::GeneratePrimaries: Too strict restriction on the generated z-coordinate.");
+  //      lem4ErrorMessage::GetInstance()->lem4Error(FATAL,"message",true);
+  //    }
+  //  }
+  
+  G4double x, y, z;
+  G4double p, ke_offset;
+  G4double xangle, yangle;
+
+  ke_offset = 3.73*keV; // Kin. energy offset due to a 3.73 kV acceleration at the Carbon foil
+  
+  if (takeMuonsFromTurtleFile) {
+    char  line[501];  
+    G4int checkNrOfCounts=0;
+    do {
+      float xTmp, yTmp, xAngleTmp, yAngleTmp, pTmp;
+      if (feof(fTurtleFile)) {rewind(fTurtleFile);G4cout<<"End of Turtle file."<<G4endl;}
+      fgets(line,500,fTurtleFile);
+      //    sscanf(&line[0],"%g %g %g %g %g %g %g",&x,&xangle,&y,&yangle,&p,&w,&pol);
+      sscanf(&line[0],"%g %g %g %g %g",&xTmp,&xAngleTmp,&yTmp,&yAngleTmp,&pTmp);
+      xangle = xAngleTmp*mrad;
+      yangle = yAngleTmp*mrad;
+      x      = xTmp*mm + z0*xangle ;       // usually z0 is negative
+      y      = yTmp*mm + z0*yangle ;
+      p      = pTmp*GeV;
+      // add some beam offset and beam tilt, if requested:
+      xangle = xangle + xangle0;
+      yangle = yangle + yangle0;
+      x      = x + x0;
+      y      = y + y0;
+      //      G4cout<<": ";
+      checkNrOfCounts++;
+      if (checkNrOfCounts>1000) {
+	G4cout<<"lem4PrimaryGeneratorAction::GeneratePrimaries:  Too strict requirements on the r position!"<<G4endl;
+      }
+    } while( (x*x+y*y)>(rMaxAllowed*rMaxAllowed) );
+    z=z0;
+    //    G4cout<<"x,y,z=("<<x/mm<<","<<y/mm<<","<<z/mm<<"),  angles="<<xangle/mrad<<","<<yangle/mrad<<"  p="<<p/MeV<<G4endl;
+  }
+
+  else {          // Generate the starting position of the muon by random
+    //  rMaxAllowed  ... maximal radius, within which the muon can be generated
+    //  x0, y0, z0   ... central point around which the muons are generated
+    //  xSigma, ySigma, zSigma  ... sigma of the (gaussian) distributions of the beam
+    //  x, y, z      ... actual initial position of the generated muon
+    
+    G4int checkNrOfCounts=0;
+    do {
+      if (xSigma>0)      {x = G4RandGauss::shoot(x0,xSigma);}           //  Gaussian distribution
+      else if (xSigma<0) {x = x0 + xSigma*(G4UniformRand()*2.-1.);}     //  Uniform step distribution
+      else               { x = x0;}                                     //  Point-like
+
+      if (ySigma>0)      {y = G4RandGauss::shoot(y0,ySigma);}
+      else if (ySigma<0) {y = y0 + ySigma*(G4UniformRand()*2.-1.);}
+      else               {y = y0;}
+
+      if (zSigma>0)      {z = G4RandGauss::shoot(z0,zSigma);}
+      else if (zSigma<0) {z = z0 + zSigma*(G4UniformRand()*2.-1.);}
+      else               {z = z0;}
+
+      checkNrOfCounts++;
+      if (checkNrOfCounts>1000) {
+	G4cout<<"lem4PrimaryGeneratorAction::GeneratePrimaries:  Too strict requirements on the r or z position!"<<G4endl;
+      }
+    } while( ((x*x+y*y)>(rMaxAllowed*rMaxAllowed))||(z>zMaxAllowed)||(z<zMinAllowed) );
+      // The generated muon has to stay within some well defined region, e.g. within the beampipe.
+  
+      
+    // If the user defines energy instead of momentum
+       // if (E0==0 && p0>0) {p = p0;}
+       // if (E0>0 && p0==0) {p0 = std::sqrt(E0*E0 + 2*mu_mass*E0);}
+       // else if (E0>0 && p0>0) {
+       //   G4cout<<"Define either kinetic energy or momentum, but not both!"<<G4endl;
+       //   G4cout << "S T O P    F O R C E D" << G4endl;
+       //   exit(1);
+       // }
+    
+              
+    // Now generate the momentum
+    checkNrOfCounts=0;
+    do {
+      if (pSigma>0) {p = G4RandGauss::shoot(p0,pSigma);}
+      else {p=p0;}
+      checkNrOfCounts++;
+      if (checkNrOfCounts>1000) {
+         G4cout<<"lem4PrimaryGeneratorAction::GeneratePrimaries:  Too strict requirements on the momentum!"<<G4endl;
+      }
+    } while ( (p>pMaxAllowed)||(p<pMinAllowed) );
+    //G4cout<<"Kamil: momentum p="<<p/MeV<<" MeV"<<G4endl;
+    
+    // Add some initial angle (px and py component of the momentum)
+    if (xangleSigma>0) { xangle = G4RandGauss::shoot(xangle0,xangleSigma); }
+    else { xangle = xangle0; }
+    //  Add the beam tilt, which depends on the distance from the beam centre.
+    if (xSigma>0) {xangle += - pitch * (x-x0)/(1*mm);} //xSigma; } // Changed to absolute units of pitch
+    
+    if (yangleSigma>0) { yangle = G4RandGauss::shoot(yangle0,yangleSigma); }
+    else { yangle = yangle0; }
+    //  Add the beam tilt, which depends on the distance from the beam centre.
+    if (ySigma>0) {yangle += - pitch * (y-y0)/(1*mm);} //ySigma; } // Changed to absolute units of pitch
+
+  }  // end of the part specific for the muons generated by random rather then from TURTLE
+  
+
+  // Calculate the final momentum
+  G4double px, py, pz;
+  px = p*sin(xangle);
+  py = p*sin(yangle);
+  pz = std::sqrt(p*p - px*px - py*py);
+
+  // Assign spin 
+  G4double xpolaris=0, ypolaris=0, zpolaris=0;
+  if (UnpolarisedMuonBeam) {
+    G4cout<<"lem4PrimaryGeneratorAction.cc:  Unpolarised muon beam not yet implemented!"<<G4endl;
+    G4cout<<"      =========>  S T O P"<<G4endl;
+    exit(0);
+    //  xpolaris = ;
+    //  ypolaris = ;
+    //  zpolaris = ;
+  }
+  else {
+    xpolaris = xPolarisIni;
+    ypolaris = yPolarisIni;
+    zpolaris = zPolarisIni;
+  }
+  
+  //  if (InitialMuonPolarization==3) {                       // longitudinal
+  //    zpolaris=-1;
+  //  }
+  //  else if (InitialMuonPolarization==2) {                  // transverse
+  //    xpolaris=1;
+  //  }
+  //  else if (InitialMuonPolarization==1) {                  // longitudinal
+  //    xpolaris = -px/p;
+  //    ypolaris = -py/p;
+  //    zpolaris = -pz/p;
+  //  }
+  //  else {                                                  // transverse
+  //    xpolaris = -pz/p;
+  //  ypolaris = -py/p;
+  //    zpolaris = -px/p;
+  //  }
+
+  particleGun->SetParticlePosition(G4ThreeVector(x,y,z));
+  //particleGun->SetParticleMomentum(G4ThreeVector(px,py,pz));
+  G4double particleEnergy = std::sqrt(p*p+mu_mass*mu_mass)-mu_mass;
+  particleGun->SetParticleEnergy(particleEnergy + ke_offset);
+  particleGun->SetParticleMomentumDirection(G4ThreeVector(px,py,pz));
+  particleGun->SetParticlePolarization(G4ThreeVector(xpolaris,ypolaris,zpolaris));
+  particleGun->GeneratePrimaryVertex(anEvent);
+
+  //  G4cout<<"lem4PrimaryGeneratorAction: Parameters:"<<G4endl;
+  //  G4cout<<"     x0,y0,z0="<<x0/mm<<","<<y0/mm<<","<<z0/mm<<"   Sigma="<<xSigma/mm<<","<<ySigma/mm<<","<<zSigma/mm<<G4endl;
+  //  G4cout<<"     rMaxAllowed="<<rMaxAllowed/mm<<"   zMaxAllowed="<<zMaxAllowed/mm<<"   zMinAllowed="<<zMinAllowed/mm<<G4endl;
+  //  G4cout<<"     p0="<<p0/MeV<<"   pSigma="<<pSigma/MeV
+  //	<<"   pMinAllowed="<<pMinAllowed/MeV<<"  pMaxAllowed=<<"<<pMaxAllowed/MeV<<G4endl;
+  //  G4cout<<"     angle0="<<xangle0/deg<<","<<yangle0/deg<<",nic"
+  //	<<"   Sigma="<<xangleSigma/deg<<","<<yangleSigma/deg<<",nic"<<G4endl;
+  //  G4cout<<"     pitch="<<pitch/deg<<G4endl;
+  //
+  //  G4cout<<"lem4PrimaryGeneratorAction: Generated muon:"<<G4endl;
+  //  G4cout<<"     x,y,z="<<x/mm<<","<<y/mm<<","<<z/mm<<"      angle="<<xangle/deg<<","<< yangle/deg<<",nic"<<G4endl;
+  //  G4cout<<"     p="<<px/MeV<<","<<py/MeV<<","<<pz/MeV<<"    E="<< (particleGun->GetParticleEnergy())/MeV<<G4endl;
+  //  G4cout<<"     polarisation="<<xpolaris<<","<<ypolaris<<","<<zpolaris<<G4endl;
+
+  
+
+
+  // if requested by "/gun/decaytimelimits", set the decay time of the muon such that it is within
+  // the required time window.  Otherwise the decay time is set internally by Geant.
+  if (muonDecayTimeMax>0.) {
+    //    G4cout<<"muonDecayTimeMin="<<muonDecayTimeMin/ns<<" ns ,  muonDecayTimeMax="<<muonDecayTimeMax/ns
+    //	  <<" ns ,   muonMeanLife="<<muonMeanLife/ns<<" ns."<<G4endl;
+    // find the primary muon
+    //    G4double decaytime;
+    //    do {                                        // generate the decaytime within the specified time window
+    //      decaytime = -muonMeanLife*log(1-G4UniformRand());
+    //    } while ((decaytime<muonDecayTimeMin)||(decaytime>muonDecayTimeMax));
+    //
+    //  This algorithm should be much faster then the previous one:
+    G4PrimaryParticle* generatedMuon = anEvent->GetPrimaryVertex(0)->GetPrimary(0);
+    //    G4double decayLowerLimit = 1-exp(-muonDecayTimeMin/muonMeanLife);
+    //    G4double decayUpperLimit = 1-exp(-muonDecayTimeMax/muonMeanLife);
+    //    G4double randomVal       = G4UniformRand()*(decayUpperLimit-decayLowerLimit) + decayLowerLimit;
+    //    G4double decaytime       = -muonMeanLife*log(1-randomVal);
+    //
+    //  The following code is numerically more stable compared to the commented lines above:
+    G4double expMin    = exp(-muonDecayTimeMin/muonMeanLife);
+    G4double expMax    = exp(-muonDecayTimeMax/muonMeanLife);
+    G4double decaytime = -muonMeanLife * log(G4UniformRand()*(expMax-expMin)+expMin);
+    //
+    //    G4cout<<"decaytime="<<decaytime/ns<<"ns."<< G4endl;
+    generatedMuon->SetProperTime(decaytime);
+  }
+
+  // Save variables into ROOT output file:
+  lem4RootOutput* myRootOutput = lem4RootOutput::GetRootInstance();
+  myRootOutput->SetInitialMuonParameters(x,y,z,px,py,pz,xpolaris,ypolaris,zpolaris);
+  
+}
+
+///////////////////////////////////////////////////////////////////////
+//
+//
+
+
+void lem4PrimaryGeneratorAction::SetInitialMuonPolariz(G4ThreeVector vIniPol)
+{
+  G4double magnitude=vIniPol.mag();
+  if(magnitude<0.00000001) {
+    G4cout<< "Unpolarised initial muons"<<G4endl;
+    UnpolarisedMuonBeam=true;
+  }
+  else {
+    xPolarisIni=vIniPol(0)/magnitude;
+    yPolarisIni=vIniPol(1)/magnitude;
+    zPolarisIni=vIniPol(2)/magnitude;
+    G4cout<< "Initial Muon Polarisation set to ("<<xPolarisIni<<","<<yPolarisIni<<","<<zPolarisIni<<")"<<G4endl;
+  }
+}
+
+void lem4PrimaryGeneratorAction::SetMuonDecayTimeLimits(G4ThreeVector decayTimeLimits) {
+  muonDecayTimeMin = decayTimeLimits[0];
+  muonDecayTimeMax = decayTimeLimits[1];
+  muonMeanLife     = decayTimeLimits[2];
+  // store the muon decay time parameters to the Root output
+  lem4RootOutput* myRootOutput = lem4RootOutput::GetRootInstance();
+  myRootOutput->StoreGeantParameter(2,muonDecayTimeMin/microsecond);
+  myRootOutput->StoreGeantParameter(3,muonDecayTimeMax/microsecond); 
+  myRootOutput->StoreGeantParameter(4,muonMeanLife/microsecond); 
+}
+
+void lem4PrimaryGeneratorAction::SetTurtleInput(G4String turtleFileName) {
+  takeMuonsFromTurtleFile = true;
+  fTurtleFile = fopen(turtleFileName.c_str(),"r");
+  if (fTurtleFile==NULL) {
+    G4cout << "E R R O R :    Failed to open TURTLE input file \"" << turtleFileName 
+	   <<"\"."<< G4endl;
+    G4cout << "S T O P    F O R C E D" << G4endl;
+    exit(1);
+  }
+  else {G4cout << "Turtle input file  \"" << turtleFileName <<"\" opened."<< G4endl;}
+}

geant4/LEMuSR/src/lem4PrimaryGeneratorMessenger.cc

@@ -0,0 +1,136 @@
+#include "lem4PrimaryGeneratorMessenger.hh"
+#include "lem4PrimaryGeneratorAction.hh"
+#include "G4UIcmdWithAString.hh"
+#include "G4UIcmdWithADoubleAndUnit.hh"
+#include "G4UIcmdWithADouble.hh"
+#include "G4UIcmdWithAnInteger.hh"
+#include "G4UIcmdWith3Vector.hh"
+#include "G4UIcmdWith3VectorAndUnit.hh"
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
+
+lem4PrimaryGeneratorMessenger::lem4PrimaryGeneratorMessenger(lem4PrimaryGeneratorAction* lem4Gun)
+:lem4Action(lem4Gun)
+{ 
+  setvertexCmd = new G4UIcmdWith3VectorAndUnit("/gun/vertex",this);
+  setvertexCmd->SetGuidance(" Set x0, y0, z0 of the generated muons (with unit)");
+  setvertexCmd->SetParameterName("mes_x0","mes_y0","mes_z0",true,true);
+  setvertexCmd->SetDefaultUnit("mm");
+
+  setvertexSigmaCmd = new G4UIcmdWith3VectorAndUnit("/gun/vertexsigma",this);
+  setvertexSigmaCmd->SetGuidance(" Set xSigma, ySigma, ySigma of the generated muons (with unit)");
+  setvertexSigmaCmd->SetParameterName("mes_xSigma","mes_ySigma","mes_zSigma",true,true);
+  setvertexSigmaCmd->SetDefaultUnit("mm");
+
+  setvertexBoundaryCmd = new G4UIcmdWith3VectorAndUnit("/gun/vertexboundary",this);
+  setvertexBoundaryCmd->SetGuidance(" Set maximum allowed radius, zmin, zmax of the generated vertex (with unit)");
+  setvertexBoundaryCmd->SetParameterName("mes_rMaxAllowed","mes_zMinAllowed","mes_zMaxAllowed",true,true);
+  setvertexBoundaryCmd->SetDefaultUnit("mm");
+  
+  setEnergyCmd = new G4UIcmdWithADoubleAndUnit("/gun/kenergy",this);
+  setEnergyCmd->SetGuidance(" Set kinetic energy of the generated muons (with unit)");
+  setEnergyCmd->SetParameterName("mes_E0",true);
+  setEnergyCmd->SetDefaultUnit("keV");
+//setEnergyCmd->SetUnitCandidates("eV keV MeV GeV");
+  
+  setMomentumCmd = new G4UIcmdWithADoubleAndUnit("/gun/momentum",this);
+  setMomentumCmd->SetGuidance(" Set mean momentum of the generated muons (with unit)");
+  setMomentumCmd->SetParameterName("mes_p0",true);
+  setMomentumCmd->SetDefaultUnit("MeV");
+
+  setMomentumSmearingCmd = new G4UIcmdWithADoubleAndUnit("/gun/momentumsmearing",this);
+  setMomentumSmearingCmd->SetGuidance(" Set sigma of the momentum of the generated muons (with unit)");
+  setMomentumSmearingCmd->SetParameterName("mes_pSigma",true);
+  setMomentumSmearingCmd->SetDefaultUnit("MeV");
+
+  setMomentumBoundaryCmd = new G4UIcmdWith3VectorAndUnit("/gun/momentumboundary",this);
+  setMomentumBoundaryCmd->SetGuidance(" Set minimum and maximum momentum allowed (with unit, z component ignored)");
+  setMomentumBoundaryCmd->SetParameterName("mes_pMinAllowed","mes_pMaxAllowed","mes_dummy",true,true);
+  setMomentumBoundaryCmd->SetDefaultUnit("MeV");
+
+  setTiltAngleCmd = new G4UIcmdWith3VectorAndUnit("/gun/tilt",this);
+  setTiltAngleCmd->SetGuidance(" Set tilt angle of the generated muons (with unit, z component ignored)");
+  setTiltAngleCmd->SetParameterName("mes_xangle","mes_yangle","dummy",true,true);
+  setTiltAngleCmd->SetDefaultUnit("deg");
+
+  setSigmaTiltAngleCmd = new G4UIcmdWith3VectorAndUnit("/gun/tiltsigma",this);
+  setSigmaTiltAngleCmd->SetGuidance(" Set sigma of the tilt angle (with unit, z component ignored)");
+  setSigmaTiltAngleCmd->SetParameterName("mes_xangleSigma","mes_yangleSigma","mes_zangleSigma",true,true);
+  setSigmaTiltAngleCmd->SetDefaultUnit("deg");
+
+  setPitchCmd = new G4UIcmdWithADoubleAndUnit("/gun/pitch",this);
+  setPitchCmd->SetGuidance(" Set pitch angle of the generated muons (with unit)");
+  setPitchCmd->SetParameterName("mes_pitch",true);
+  setPitchCmd->SetDefaultUnit("deg");
+
+  //  setMuonPolarizCmd = new G4UIcmdWithAnInteger("/gun/muonpolarization",this);
+  //  setMuonPolarizCmd->SetGuidance(" Set initial mu polariz: 0=transverse, 1=longitudinal ");
+  //  setMuonPolarizCmd->SetParameterName("IniPol",true);
+  //  setMuonPolarizCmd->SetDefaultValue(0) ;
+
+  setMuonPolarizCmd = new G4UIcmdWith3Vector("/gun/muonPolarizVector",this);
+  setMuonPolarizCmd->SetGuidance("Set initial mu polarisation as a vector (without unit)");
+  setMuonPolarizCmd->SetGuidance("    The vector does not have to be normalised to 1");
+  setMuonPolarizCmd->SetParameterName("mes_polarisX","mes_polarisY","mes_polarisZ",true,true);
+
+  setMuonDecayTimeCmd = new G4UIcmdWith3VectorAndUnit("/gun/decaytimelimits",this);
+  setMuonDecayTimeCmd->SetGuidance(" Set minimum and maximum decay time and the muon mean life ");
+  setMuonDecayTimeCmd->SetParameterName("decayMin","decayMax","decayTime",true,true);
+  setMuonDecayTimeCmd->SetDefaultUnit("ns");
+
+  setTurtleCmd = new G4UIcmdWithAString("/gun/turtlefilename",this);
+  setTurtleCmd->SetGuidance("Set the filename of the TURTLE input file.");
+  setTurtleCmd->SetGuidance("If this varialble is set, TURTLE input will be used. for initial muons");
+  setTurtleCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
+
+lem4PrimaryGeneratorMessenger::~lem4PrimaryGeneratorMessenger()
+{
+  delete setvertexCmd;
+  delete setvertexSigmaCmd;
+  delete setvertexBoundaryCmd;
+  delete setEnergyCmd;
+  delete setMomentumCmd;
+  delete setMomentumSmearingCmd;
+  delete setMomentumBoundaryCmd;
+  delete setTiltAngleCmd;
+  delete setSigmaTiltAngleCmd;
+  delete setPitchCmd;
+  delete setMuonPolarizCmd;
+  delete setMuonDecayTimeCmd;
+  delete setTurtleCmd;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
+
+void lem4PrimaryGeneratorMessenger::SetNewValue(G4UIcommand *command, G4String newValue)
+{ 
+  if( command == setvertexCmd)
+   { lem4Action->Setvertex(setvertexCmd->GetNew3VectorValue(newValue));}
+  else if( command == setvertexSigmaCmd)
+   { lem4Action->SetvertexSigma(setvertexSigmaCmd->GetNew3VectorValue(newValue));}
+  else if( command == setvertexBoundaryCmd)
+   { lem4Action->SetvertexBoundary(setvertexBoundaryCmd->GetNew3VectorValue(newValue));}
+  else if( command == setEnergyCmd)
+   { lem4Action->SetEnergy(setEnergyCmd->GetNewDoubleValue(newValue));}
+  else if( command == setMomentumCmd)
+   { lem4Action->SetMomentum(setMomentumCmd->GetNewDoubleValue(newValue));}
+  else if( command == setMomentumSmearingCmd)
+    { lem4Action->SetMomentumSmearing(setMomentumSmearingCmd->GetNewDoubleValue(newValue));}
+  else if( command == setMomentumBoundaryCmd)
+   { lem4Action->SetMomentumBoundary(setMomentumBoundaryCmd->GetNew3VectorValue(newValue));}
+  else if( command == setTiltAngleCmd)
+   { lem4Action->SetTilt(setTiltAngleCmd->GetNew3VectorValue(newValue));}
+  else if( command == setSigmaTiltAngleCmd)
+   { lem4Action->SetSigmaTilt(setSigmaTiltAngleCmd->GetNew3VectorValue(newValue));}
+  else if( command == setPitchCmd)
+    { lem4Action->SetPitch(setPitchCmd->GetNewDoubleValue(newValue));}
+  else if( command == setMuonPolarizCmd)
+    { lem4Action->SetInitialMuonPolariz(setMuonPolarizCmd->GetNew3VectorValue(newValue));}
+  else if( command == setMuonDecayTimeCmd)
+    { lem4Action->SetMuonDecayTimeLimits(setMuonDecayTimeCmd->GetNew3VectorValue(newValue)); }
+  else if ( command == setTurtleCmd)
+    { lem4Action->SetTurtleInput(newValue); }
+}

geant4/LEMuSR/src/lem4RootOutput.cc

@@ -0,0 +1,353 @@
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+#include "lem4RootOutput.hh"
+#include "G4RunManager.hh"
+#include "G4Run.hh"
+//#include "globals.hh"
+#include "lem4ErrorMessage.hh"
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+lem4RootOutput::lem4RootOutput() {
+  pointerToRoot=this;
+  boolIsAnySpecialSaveVolumeDefined=false;
+  nFieldNomVal=0;
+ 
+  //  SensDetectorMapping["log_ScintBU"]=1;
+  //  SensDetectorMapping["log_ScintBD"]=2;
+  //  SensDetectorMapping["log_ScintBL"]=3;
+  //  SensDetectorMapping["log_ScintBR"]=4;
+  //  SensDetectorMapping["log_ScintFU"]=5;
+  //  SensDetectorMapping["log_ScintFD"]=6;
+  //  SensDetectorMapping["log_ScintFL"]=7;
+  //  SensDetectorMapping["log_ScintFR"]=8;
+  
+  //  SensDetectorMapping["logicScintBU"]=1;
+  //  SensDetectorMapping["logicScintBD"]=2;
+  //  SensDetectorMapping["logicScintBL"]=3;
+  //  SensDetectorMapping["logicScintBR"]=4;
+  //  SensDetectorMapping["logicScintFU"]=5;
+  //  SensDetectorMapping["logicScintFD"]=6;
+  //  SensDetectorMapping["logicScintFL"]=7;
+  //  SensDetectorMapping["logicScintFR"]=8;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+lem4RootOutput::~lem4RootOutput() {}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+lem4RootOutput* lem4RootOutput::pointerToRoot=0;
+lem4RootOutput* lem4RootOutput::GetRootInstance() {
+  return pointerToRoot;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+G4bool lem4RootOutput::store_runID = true;
+G4bool lem4RootOutput::store_eventID = true;
+G4bool lem4RootOutput::store_BFieldAtDecay = true;
+G4bool lem4RootOutput::store_muIniPosX = true;
+G4bool lem4RootOutput::store_muIniPosY = true;
+G4bool lem4RootOutput::store_muIniPosZ = true;
+G4bool lem4RootOutput::store_muIniMomX = true;
+G4bool lem4RootOutput::store_muIniMomY = true;
+G4bool lem4RootOutput::store_muIniMomZ = true;
+G4bool lem4RootOutput::store_muIniPolX = true;
+G4bool lem4RootOutput::store_muIniPolY = true;
+G4bool lem4RootOutput::store_muIniPolZ = true;
+G4bool lem4RootOutput::store_muDecayDetID= true;
+G4bool lem4RootOutput::store_muDecayPosX = true;
+G4bool lem4RootOutput::store_muDecayPosY = true;
+G4bool lem4RootOutput::store_muDecayPosZ = true;
+G4bool lem4RootOutput::store_muDecayTime = true;
+G4bool lem4RootOutput::store_muDecayPolX = true;
+G4bool lem4RootOutput::store_muDecayPolY = true;
+G4bool lem4RootOutput::store_muDecayPolZ = true;
+G4bool lem4RootOutput::store_muTargetTime = true;
+G4bool lem4RootOutput::store_muTargetPolX = true;
+G4bool lem4RootOutput::store_muTargetPolY = true;
+G4bool lem4RootOutput::store_muTargetPolZ = true;
+G4bool lem4RootOutput::store_posIniMomX = true;
+G4bool lem4RootOutput::store_posIniMomY = true;
+G4bool lem4RootOutput::store_posIniMomZ = true;
+G4bool lem4RootOutput::store_globalTime = true;
+G4bool lem4RootOutput::store_fieldValue = true;
+G4bool lem4RootOutput::store_det_ID = true;
+G4bool lem4RootOutput::store_det_edep = true;
+G4bool lem4RootOutput::store_det_edep_el = true;
+G4bool lem4RootOutput::store_det_edep_pos = true;
+G4bool lem4RootOutput::store_det_edep_gam = true;
+G4bool lem4RootOutput::store_det_edep_mup = true;
+G4bool lem4RootOutput::store_det_nsteps = true;
+G4bool lem4RootOutput::store_det_length = true;
+G4bool lem4RootOutput::store_det_start = true;
+G4bool lem4RootOutput::store_det_end = true;
+G4bool lem4RootOutput::store_det_x = true;
+G4bool lem4RootOutput::store_det_y = true;
+G4bool lem4RootOutput::store_det_z = true;
+G4bool lem4RootOutput::store_fieldNomVal = true;
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+void lem4RootOutput::BeginOfRunAction() {
+  G4cout << "lem4RootOutput::BeginOfRunAction()  Defining Root tree and branches ..."<<G4endl;
+  G4int tmpRunNr=(G4RunManager::GetRunManager())->GetCurrentRun()->GetRunID();
+  char RootOutputFileName[200];
+  sprintf(RootOutputFileName, "data/lem4_%i.root", tmpRunNr);
+  //  G4cout<<"RootOutputFileName="<<RootOutputFileName<<"----"<<G4endl;
+  //  rootFile=new TFile("lem4.root","update");
+  rootFile=new TFile(RootOutputFileName,"recreate");
+  rootTree=new TTree("t1","a simple Tree with simple variables");
+  if (store_runID)        {rootTree->Branch("runID",&runID_t,"runID/I");}
+  if (store_eventID)      {rootTree->Branch("eventID",&eventID_t,"eventID/I");}
+  if (store_BFieldAtDecay){rootTree->Branch("BFieldAtDecay",&B_t,"Bx/D:By:Bz:B3:B4:B5");}
+  if (store_muIniPosX)    {rootTree->Branch("muIniPosX",&muIniPosX_t,"muIniPosX/D");}
+  if (store_muIniPosY)    {rootTree->Branch("muIniPosY",&muIniPosY_t,"muIniPosY/D");}
+  if (store_muIniPosZ)    {rootTree->Branch("muIniPosZ",&muIniPosZ_t,"muIniPosZ/D");}
+  if (store_muIniMomX)    {rootTree->Branch("muIniMomX",&muIniMomX_t,"muIniMomX/D");}
+  if (store_muIniMomY)    {rootTree->Branch("muIniMomY",&muIniMomY_t,"muIniMomY/D");}
+  if (store_muIniMomZ)    {rootTree->Branch("muIniMomZ",&muIniMomZ_t,"muIniMomZ/D");}
+  if (store_muIniPolX)    {rootTree->Branch("muIniPolX",&muIniPolX_t,"muIniPolX/D");}
+  if (store_muIniPolY)    {rootTree->Branch("muIniPolY",&muIniPolY_t,"muIniPolY/D");}
+  if (store_muIniPolZ)    {rootTree->Branch("muIniPolZ",&muIniPolZ_t,"muIniPolZ/D");}
+  if (store_muDecayDetID) {rootTree->Branch("muDecayDetID",&muDecayDetID_t,"muDecayDetID/I");}
+  if (store_muDecayPosX)  {rootTree->Branch("muDecayPosX",&muDecayPosX_t,"muDecayPosX/D");}
+  if (store_muDecayPosY)  {rootTree->Branch("muDecayPosY",&muDecayPosY_t,"muDecayPosY/D");}
+  if (store_muDecayPosZ)  {rootTree->Branch("muDecayPosZ",&muDecayPosZ_t,"muDecayPosZ/D");}
+  if (store_muDecayTime)  {rootTree->Branch("muDecayTime",&muDecayTime_t,"muDecayTime/D");}
+  if (store_muDecayPolX)  {rootTree->Branch("muDecayPolX",&muDecayPolX_t,"muDecayPolX/D");}
+  if (store_muDecayPolY)  {rootTree->Branch("muDecayPolY",&muDecayPolY_t,"muDecayPolY/D");}
+  if (store_muDecayPolZ)  {rootTree->Branch("muDecayPolZ",&muDecayPolZ_t,"muDecayPolZ/D");}
+  if (store_muTargetTime) {rootTree->Branch("muTargetTime",&muTargetTime_t,"muTargetTime/D");}
+  if (store_muTargetPolX) {rootTree->Branch("muTargetPolX",&muTargetPolX_t,"muTargetPolX/D");}
+  if (store_muTargetPolY) {rootTree->Branch("muTargetPolY",&muTargetPolY_t,"muTargetPolY/D");}
+  if (store_muTargetPolZ) {rootTree->Branch("muTargetPolZ",&muTargetPolZ_t,"muTargetPolZ/D");}
+  if (store_posIniMomX)   {rootTree->Branch("posIniMomX",&posIniMomx_t,"posIniMomX/D");}
+  if (store_posIniMomY)   {rootTree->Branch("posIniMomY",&posIniMomy_t,"posIniMomY/D");}
+  if (store_posIniMomZ)   {rootTree->Branch("posIniMomZ",&posIniMomz_t,"posIniMomZ/D");}
+  if (store_globalTime)   {rootTree->Branch("globalTime",&globalTime_t,"globalTime/D");}
+  if (store_fieldValue)   {rootTree->Branch("fieldValue",&fieldValue_t,"fieldValue/D");}
+
+  //  rootTree->Branch("nSubTracks",&nSubTracks,"nSubTracks/I");
+  //  rootTree->Branch("particleID",&particleID_t,"particleID[nSubTracks]/I");
+  //  rootTree->Branch("trackID",&trackID_t,"trackID[nSubTracks]/I");
+  //  rootTree->Branch("logicalVolumeID",&logicalVolumeID_t,"logicalVolumeID[nSubTracks]/I");
+  //  rootTree->Branch("edep",&edep_t,"edep[nSubTracks]/D");
+  //  rootTree->Branch("x",&x_t,"x[nSubTracks]/D");
+  //  rootTree->Branch("y",&y_t,"y[nSubTracks]/D");
+  //  rootTree->Branch("z",&z_t,"z[nSubTracks]/D");
+  //  rootTree->Branch("post_x",&post_x_t,"post_x[nSubTracks]/D");
+  //  rootTree->Branch("post_y",&post_y_t,"post_y[nSubTracks]/D");
+  //  rootTree->Branch("post_z",&post_z_t,"post_z[nSubTracks]/D");
+  //  rootTree->Branch("kineticEnergy",&kineticEnergy_t,"kineticEnergy[nSubTracks]/D");
+  //  rootTree->Branch("stepLength",&stepLength_t,"stepLength[nSubTracks]/D");
+  //  rootTree->Branch("nrOfSubsteps",&nrOfSubsteps_t,"nrOfSubsteps[nSubTracks]/I");
+
+  rootTree->Branch("det_n",&det_n,"det_n/I");
+  if (store_det_ID)       {rootTree->Branch("det_ID",&det_ID,"det_ID[det_n]/I");}
+  if (store_det_edep)     {rootTree->Branch("det_edep",&det_edep,"det_edep[det_n]/D");}
+  if (store_det_edep_el)  {rootTree->Branch("det_edep_el",&det_edep_el,"det_edep_el[det_n]/D");}
+  if (store_det_edep_pos) {rootTree->Branch("det_edep_pos",&det_edep_pos,"det_edep_pos[det_n]/D");}
+  if (store_det_edep_gam) {rootTree->Branch("det_edep_gam",&det_edep_gam,"det_edep_gam[det_n]/D");}
+  if (store_det_edep_mup) {rootTree->Branch("det_edep_mup",&det_edep_mup,"det_edep_mup[det_n]/D");}
+  if (store_det_nsteps)   {rootTree->Branch("det_nsteps",&det_nsteps,"det_nsteps[det_n]/I");}
+  if (store_det_length)   {rootTree->Branch("det_length",&det_length,"det_length[det_n]/D");}
+  if (store_det_start)    {rootTree->Branch("det_time_start",&det_time_start,"det_time_start[det_n]/D");}
+  if (store_det_end)      {rootTree->Branch("det_time_end",&det_time_end,"det_time_end[det_n]/D");}
+  if (store_det_x)        {rootTree->Branch("det_x",&det_x,"det_x[det_n]/D");}
+  if (store_det_y)        {rootTree->Branch("det_y",&det_y,"det_y[det_n]/D");}
+  if (store_det_z)        {rootTree->Branch("det_z",&det_z,"det_z[det_n]/D");}
+
+  if (boolIsAnySpecialSaveVolumeDefined) {
+    rootTree->Branch("save_n",&save_n,"save_n/I");
+    rootTree->Branch("save_detID",&save_detID,"save_detID[save_n]/I");
+    rootTree->Branch("save_particleID",&save_particleID,"save_particleID[save_n]/I");
+    rootTree->Branch("save_ke",&save_ke,"save_ke[save_n]/D");
+    rootTree->Branch("save_x", &save_x, "save_x[save_n]/D");
+    rootTree->Branch("save_y", &save_y, "save_y[save_n]/D");
+    rootTree->Branch("save_z", &save_z, "save_z[save_n]/D");
+    rootTree->Branch("save_px",&save_px,"save_px[save_n]/D");
+    rootTree->Branch("save_py",&save_py,"save_py[save_n]/D");
+    rootTree->Branch("save_pz",&save_pz,"save_pz[save_n]/D");
+  }
+
+  //  htest1 = new TH1F("htest1","The debugging histogram 1",50,-4.,4.);
+  //  htest2 = new TH1F("htest2","The debugging histogram 2",50,0.,3.142);
+  htest1 = new TH2F("htest1","x, y",50,-200.,200.,50,-200.,200.);
+  htest2 = new TH2F("htest2","R, z",50,0.,250.,50,-150.,150.);
+  htest3 = new TH1F("htest3","Energy in MeV",55,0.,55.);
+  htest4 = new TH1F("htest4","Radioactive electron kinetic energy",250,0.,2.5);
+  htest5 = new TH1F("htest5","The debugging histogram 5",50,-4.,4.);
+  htest6 = new TH1F("htest6","The debugging histogram 6",50,0.,3.142);
+  htest7 = new TH1F("htest7","The debugging histogram 7",50,-4.,4.);
+  htest8 = new TH1F("htest8","The debugging histogram 8",50,0.,3.142);
+
+  G4cout << "lem4RootOutput::BeginOfRunAction()  Root tree and branches were defined.\n"<<G4endl;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+
+void lem4RootOutput::EndOfRunAction() {
+  G4cout << "\nlem4RootOutput::EndOfRunAction() - Writing out the Root tree ..."<<G4endl;
+  rootTree->Write();
+  htest1->Write();
+  htest2->Write();
+  htest3->Write();
+  htest4->Write();
+  htest5->Write();
+  htest6->Write();
+  htest7->Write();
+  htest8->Write();
+  // Variables exported from Geant simulation to the Root output
+  //  static const Int_t nGeantParamD=10;
+  TVectorD TVector_GeantParametersD(maxNGeantParameters);
+  for (Int_t i=0; i<maxNGeantParameters; i++) {
+    TVector_GeantParametersD[i]=GeantParametersD[i];
+  }
+  TVector_GeantParametersD.Write("geantParametersD");
+  rootFile->Close();
+  G4cout<<"lem4RootOutput::EndOfRunAction() - Root tree written out.\n"<<G4endl;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+void lem4RootOutput::FillEvent() {
+  //  G4cout << "hhhhh: lem4RootOutput::FillEvent()"<<G4endl;
+  //  G4cout<<"Kamil: Fill the Root Tree:"<<G4endl;
+  //  G4ThreeVector ttt=(posIniMomx_t,posIniMomy_t,posIniMomz_t);
+  //  htest5->Fill(atan2(ttt.y(),ttt.x()));
+  //  htest6->Fill(atan2(sqrt(ttt.x()*ttt.x()+ttt.y()*ttt.y()),ttt.z())); 
+  htest5->Fill(atan2(posIniMomy_t,posIniMomx_t));
+  htest6->Fill(atan2(sqrt(posIniMomx_t*posIniMomx_t+posIniMomy_t*posIniMomy_t),posIniMomz_t));
+  //  G4double PolModulus=sqrt(muDecayPolX_t*muDecayPolX_t+muDecayPolY_t*muDecayPolY_t+muDecayPolZ_t*muDecayPolZ_t);
+  //  G4double PolModulus0=sqrt(muTargetPolX_t*muTargetPolX_t+muTargetPolY_t*muTargetPolY_t+muTargetPolZ_t*muTargetPolZ_t);
+  //  if ((muPolx_t>1.0001)||((muPolx_t<-1.0001)&&(muPolx_t>-999.))||(muPolx0_t>1.0001)||((muPolx0_t<-1.0001)&&(muPolx0_t>-999.))) {
+  //  if ((PolModulus>1.001)||((PolModulus0>1.001)&&(muTargetTime_t>-999))) {
+  //    G4cout <<"lem4RootOutput.cc: Strange polarisation in run="<<runID_t<<" event="<<eventID_t
+  //	   <<" PolModulus="<<PolModulus<<" PolModulus0="<<PolModulus0<<G4endl;
+  //    G4cout <<"    muPol=("<<muDecayPolX_t<<","<<muDecayPolY_t<<","<<muDecayPolZ_t<<");"
+  //           <<"    mupol0=("<<muPolx0_t<<","<<muPoly0_t<<","<<muPolz0_t<<");"<<G4endl;
+  //  }
+  //  G4cout << "eventID="<<eventID_t<<";  Deposited E (el, pos, gam, mu)="<<det_edep_el<<", "
+  //	 << det_edep_pos<<", "<< det_edep_gam<<", "<< det_edep_mup<<G4endl;
+  //  G4cout<<"fieldValue="<<fieldValue_t<<G4endl;
+  rootTree->Fill();
+  //  G4cout<<"Kamil: end of Filling the Root Tree:"<<G4endl;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+void lem4RootOutput::ClearAllRootVariables() {
+  runID_t=-1000;
+  eventID_t=-1000;
+  B_t[0]=-1000.;B_t[1]=-1000.;B_t[2]=-1000.;B_t[3]=-1000.;B_t[4]=-1000.;B_t[5]=-1000.;
+  muIniPosX_t=-1000; muIniPosY_t=-1000; muIniPosZ_t=-1000;
+  muIniMomX_t=-1000; muIniMomY_t=-1000; muIniMomZ_t=-1000;
+  muIniPolX_t=-1000; muIniPolY_t=-1000; muIniPolZ_t=-1000;
+  muDecayDetID_t=-1000;
+  muDecayPolX_t=-1000; muDecayPolY_t=-1000; muDecayPolZ_t=-1000;
+  muTargetPolX_t=-1000; muTargetPolY_t=-1000; muTargetPolZ_t=-1000;
+  muDecayPosX_t=-1000;muDecayPosY_t=-1000;muDecayPosZ_t=-1000;
+  muDecayTime_t=-1000;
+  posIniMomx_t=-1000;posIniMomy_t=-1000;posIniMomz_t=-1000;
+  globalTime_t=-1000;
+  fieldValue_t=-1000;
+  muTargetTime_t=-1000;
+
+  //  nSubTracks=0;
+  //  for (G4int i=0; i<maxNSubTracks; i++) {
+  //    particleID_t[i]=-1000;
+  //    trackID_t[i]=-1000;
+  //    logicalVolumeID_t[i]=-1000;
+  //    edep_t[i]=-1000;
+  //    x_t[i]=-1000;
+  //    y_t[i]=-1000;
+  //    z_t[i]=-1000;
+  //    post_x_t[i]=-1000;
+  //    post_y_t[i]=-1000;
+  //    post_z_t[i]=-1000;
+  //    kineticEnergy_t[i]=-1000;
+  //    stepLength_t[i]=-1000;
+  //    nrOfSubsteps_t[i]=-1000;
+  //  }
+  
+  det_n=0;
+  //  for (G4int i=0; i<NrOfLogicalVolumes; i++) {
+  //    det_ID[i]=-1000;
+  //    det_edep[i]=-1000;
+  //    det_nsteps[i]=-1000;
+  //    det_length[i]=-1000;
+  //  }
+
+  save_n=0;
+
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+
+void lem4RootOutput::SetVolumeIDMapping(std::string logivol, int volumeID) {
+  //  This function assigns a unique number to each sensitive detector name.
+  //  The numbers are used in the root tree, as it is easier to work with numbers
+  //  rather than with strings.
+  if (SensDetectorMapping[logivol]) {
+    char message[100];  
+    sprintf(message,"lem4RootOutput::SetVolumeIDMapping: Sensitive volume %s already assigned.",logivol.c_str());
+    lem4ErrorMessage::GetInstance()->lem4Error(FATAL,message,false);
+  }
+  else{
+    SensDetectorMapping[logivol]=volumeID;
+  }
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+G4int lem4RootOutput::ConvertVolumeToID(std::string logivol) {
+  G4int volumeID = SensDetectorMapping[logivol];
+  if (volumeID==0) {
+    char message[100];  
+    sprintf(message,"lem4RootOutput::ConvertVolumeToID: No ID number assigned to sensitive volume %s .",logivol.c_str());
+    lem4ErrorMessage::GetInstance()->lem4Error(SERIOUS,"message",true);
+  }
+  return volumeID;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+void lem4RootOutput::SetSaveDetectorInfo (G4int ID, G4int particleID,  G4double ke, 
+                          G4double x, G4double y, G4double z, G4double px, G4double py, G4double pz) {
+  if (save_n>=save_nMax) {
+    char message[200];
+    sprintf(message,"lem4RootOutput.cc::SetSaveDetectorInfo(): more \"save\" hits then allowed: save_nMax=%i",save_nMax);
+    lem4ErrorMessage::GetInstance()->lem4Error(SERIOUS,message,true);
+  }
+  else {
+    save_detID[save_n]=ID;
+    save_particleID[save_n]=particleID;
+    save_ke[save_n]=ke/keV;
+    save_x[save_n]=x/mm;
+    save_y[save_n]=y/mm;
+    save_z[save_n]=z/mm;
+    save_px[save_n]=px/MeV;
+    save_py[save_n]=py/MeV;
+    save_pz[save_n]=pz/MeV;
+
+    save_n++;
+  }
+}
+
+void lem4RootOutput::SetFieldNomVal(G4int i, G4double value) {
+  if (i<maxNFieldnNominalValues) {
+    fieldNomVal[i]=value/tesla; /// ATTENTION CHANGE BEFORE, TO ACCOUNT FOR EM FIELDS !! TS
+  } 
+  else {
+    char message[200];
+    sprintf(message,
+	    "lem4RootOutput.cc::SetFieldNomVal(): more electromagnetic fields then allowed: maxNFieldnNominalValues=%i",
+	    maxNFieldnNominalValues);
+    lem4ErrorMessage::GetInstance()->lem4Error(SERIOUS,message,true);
+  }
+}
+

geant4/LEMuSR/src/lem4RunAction.cc

@@ -0,0 +1,85 @@
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+// Make G4Timer appear first!
+#include "G4Timer.hh"
+#include "lem4RunAction.hh"
+#include "lem4EventAction.hh"
+#include "G4Run.hh"
+#include "lem4ErrorMessage.hh"
+#include "F04GlobalField.hh"
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+lem4RunAction::lem4RunAction() {
+  timer = new G4Timer;
+}
+
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+lem4RunAction::~lem4RunAction() {
+  delete timer;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+void lem4RunAction::BeginOfRunAction(const G4Run* aRun)  {
+  timer->Start();
+  G4int run_id= aRun->GetRunID();
+  //  if (run_id%100 == 0) {
+  G4cout << "### Run " << run_id << G4endl;
+  //  }
+  // Set nr. of events that will be processed in this run to lem4EventAction class, as it will
+  // be needed for the time dependent magnetic field;
+  lem4EventAction* pointerToEventAction = lem4EventAction::GetInstance();
+  pointerToEventAction->SetNumberOfEventsInThisRun(aRun->GetNumberOfEventToBeProcessed());
+  //
+  lem4RootOutput::GetRootInstance()->BeginOfRunAction();
+  //
+  // Initiate global electromagnetic field (if it exists):
+  if (F04GlobalField::Exists()) {
+    FieldList* fields = F04GlobalField::getObject()->getFields();
+
+    if (fields) {
+      if (fields->size()>0) {
+        G4int jjj=0;
+	G4cout<<"\n------------ The following fields were defined:  ----------------\n"<<G4endl;
+	FieldList::iterator i;
+	for (i=fields->begin(); i!=fields->end(); ++i) { 
+	(*i)->construct();
+	// Get the nominal field value for the given field and store it in the Root output
+	G4double nomFieldValue = (*i)->GetNominalFieldValue();
+	lem4RootOutput::GetRootInstance()->SetFieldNomVal(jjj,nomFieldValue);
+	jjj++;
+	}
+	G4cout<<"-----------------------------------------------------------------"<<G4endl;
+      }
+    }  
+    
+    // Print out the field values at the points user requested to be printed out:
+    F04GlobalField::getObject()->PrintFieldAtRequestedPoints();
+  }
+
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+void lem4RunAction::EndOfRunAction(const G4Run* aRun)  { 
+  lem4RootOutput::GetRootInstance()->EndOfRunAction();
+  lem4ErrorMessage::GetInstance()->PrintErrorSummary();
+  timer->Stop();
+  G4cout << "lem4RunAction::EndOfRunAction:"<<G4endl;
+  G4cout << "    Number of events    = " << aRun->GetNumberOfEvent()<<G4endl;
+  //         << " " << *timer << G4endl;
+  G4cout << "    User elapsed time   = "<<timer->GetUserElapsed()/3600<<"h   = "
+	 <<timer->GetUserElapsed()/60<<"min   = "<<timer->GetUserElapsed()<<"s."<<G4endl;
+  G4cout << "    Real elapsed time   = "<<timer->GetRealElapsed()/3600<<"h   = "
+	 <<timer->GetRealElapsed()/60<<"min   = "<<timer->GetRealElapsed()<<"s."<<G4endl;
+  G4cout << "    System elapsed time = "<<timer->GetSystemElapsed()/3600<<"h   = "
+	 <<timer->GetSystemElapsed()/60<<"min   = "<<timer->GetSystemElapsed()<<"s."<<G4endl;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+
+

geant4/LEMuSR/src/lem4ScintHit.cc

@@ -0,0 +1,156 @@
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+#include "lem4ScintHit.hh"
+#include "G4UnitsTable.hh"
+#include "G4VVisManager.hh"
+#include "G4Circle.hh"
+#include "G4Colour.hh"
+#include "G4VisAttributes.hh"
+#include "G4ios.hh"
+#include "G4MagneticField.hh"
+#include "G4FieldManager.hh"
+#include "G4TransportationManager.hh"
+#include "globals.hh"
+#include "G4Transform3D.hh"
+#include "G4ProcessManager.hh"
+#include "G4Track.hh"
+#include "G4ThreeVector.hh"
+#include "G4RunManager.hh"
+#include "G4Run.hh"
+#include <fstream>
+#include <iostream>
+#include <iomanip>
+
+G4Allocator<lem4ScintHit> lem4ScintHitAllocator;
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+lem4ScintHit::lem4ScintHit() {
+}
+
+G4int lem4ScintHit::ScintMultihit=0;
+G4int lem4ScintHit::runIDoldScint=-1;
+G4int lem4ScintHit::eventIDoldScint=-1;
+G4int lem4ScintHit::NIS=0;
+G4int lem4ScintHit::ScintChamberNbold=-1;
+G4int lem4ScintHit::verboseLevel=0;
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+lem4ScintHit::~lem4ScintHit() {
+  //save the Tree header. The file will be automatically closed
+  //when going out of the function scope
+  //  rootTree->Write();
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+lem4ScintHit::lem4ScintHit(const lem4ScintHit& right)
+  : G4VHit()
+{
+  particleName = right.particleName;
+  trackID   = right.trackID;
+  edep      = right.edep;
+  pre_pos       = right.pre_pos;
+  pol       = right.pol;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+const lem4ScintHit& lem4ScintHit::operator=(const lem4ScintHit& right)
+{
+  particleName = right.particleName;
+  trackID   = right.trackID;
+  edep      = right.edep;
+  pre_pos       = right.pre_pos;
+  pol       = right.pol;
+  return *this;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+G4int lem4ScintHit::operator==(const lem4ScintHit& right) const
+{
+  return (this==&right) ? 1 : 0;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+void lem4ScintHit::Draw()
+{
+  G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
+  if(pVVisManager)
+  {
+    G4Circle circle(pre_pos);
+    circle.SetScreenSize(0.04);
+    circle.SetFillStyle(G4Circle::filled);
+    G4Colour colour(1.,0.,0.);
+    G4VisAttributes attribs(colour);
+    circle.SetVisAttributes(attribs);
+    pVVisManager->Draw(circle);
+  }
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+void lem4ScintHit::Print()
+{
+  if (verboseLevel>2) G4cout<<"VERBOSE 3: Kamil:  lem4ScintHit::Print()"<<G4endl;
+  
+  G4RunManager* fRunManager = G4RunManager::GetRunManager();
+  eventID = fRunManager->GetCurrentEvent()->GetEventID();
+  runID   = fRunManager->GetCurrentRun()->GetRunID();
+  G4int ScintMultihitSwitch=0;
+  
+  if (runID != runIDoldScint)  {
+      NIS=0;
+      ScintMultihit = 0;
+      eventIDoldScint = -1;
+      ScintChamberNbold = -1;
+    }
+  
+  //cks  if (particleName== "e+" and (eventIDoldScint != eventID or ScintChamberNbold != IBchamberNb)) {
+  if (particleName== "e+") {
+    if (eventIDoldScint == eventID) {
+      ScintMultihit++;
+      ScintMultihitSwitch=1;
+    }
+    NIS++;
+
+    G4FieldManager *fMgr=G4TransportationManager::GetTransportationManager()->GetFieldManager();
+    point[0]=0.;
+    point[1]=0.;
+    point[2]=0.;
+    B[2]=0.0;
+    if(!fMgr->DoesFieldChangeEnergy())  {          //then we have a magnetic field
+      mfield = fMgr->GetDetectorField();
+      mfield->GetFieldValue(point,B);
+      B[0]=B[0]/tesla;
+      B[1]=B[1]/tesla;
+      B[2]=B[2]/tesla;
+    }
+    //      G4cout << "  Segment: " << IBchamberNb << G4endl;
+    //      G4cout <<"Position " << pos.x()/cm<<" "<<pos.y()/cm <<" "<< pos.z()/cm <<G4endl;
+    //	 G4cout << "Field is "<< B[2]<<G4endl;
+    
+    std::ofstream posfile1;
+    posfile1.open ("scint.dat", std::ios::out | std::ios::app);
+    posfile1 << runID << " " << eventID 
+	   << " " << logicalVolume
+	   << " " << ScintMultihitSwitch 
+	   <<" " << edep
+	   << " " << fabs(B[2]) 
+           <<" "<< pre_pos.x()/cm<<" "<<pre_pos.y()/cm <<" "<< pre_pos.z()/cm  
+	   << " " << globalTime/s 
+        // << " " << IBchamberNb 
+      //	     << " first=" << firstStepInVolume << " last=" << lastStepInVolume
+	   << G4endl;
+    posfile1.close();
+  }
+  eventIDoldScint=eventID;
+  runIDoldScint = runID;
+  //  ScintChamberNbold = IBchamberNb; 
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+

geant4/LEMuSR/src/lem4ScintSD.cc

@@ -0,0 +1,382 @@
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+//cksdel #include "lem4RunAction.hh"
+#include "lem4ScintSD.hh"
+#include "G4HCofThisEvent.hh"
+#include "G4Step.hh"
+#include "G4ThreeVector.hh"
+#include "G4SDManager.hh"
+#include "G4ios.hh"
+//#include "G4MagneticField.hh"
+//#include "G4FieldManager.hh"
+//#include "G4TransportationManager.hh"
+#include <algorithm>   // needed for the sort() function
+#include "G4VProcess.hh"  // needed for the degugging message of the process name
+#include "G4RunManager.hh"
+#include "G4Run.hh"
+#include "lem4Parameters.hh"
+#include "lem4ErrorMessage.hh"
+#include <vector>
+
+//bool myREMOVEfunction (int i,int j) { return (i<j); }
+//bool timeOrdering (lem4ScintHit hit1, lem4ScintHit hit2) { 
+//  return (hit1.GetGlobalTime()<hit2.GetGlobalTime());
+//}
+//
+//bool timeOrdering2 (std::map<int,double>::iterator i1, std::map<int,double>::iterator m2) {
+//  return ( (*i1).first()<(*i2).second() );
+//}
+//
+//bool timeOrdering2 (std::pair<int,double> p1, std::pair<int,double> p2) {
+//  return ( p1.first()<p2.second() );
+//}
+//
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+lem4ScintSD::lem4ScintSD(G4String name)
+:G4VSensitiveDetector(name)
+{
+  G4String HCname;
+  collectionName.insert(HCname="scintCollection");
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+lem4ScintSD::~lem4ScintSD(){ }
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+void lem4ScintSD::Initialize(G4HCofThisEvent* HCE) {
+  if (verboseLevel>1) G4cout<<"VERBOSE 2:  lem4ScintSD::Initialize\n";
+  //  Positron_momentum_already_stored=0;
+  lem4RootOutput* myRootOutput = lem4RootOutput::GetRootInstance();
+  myRootOutput->ClearAllRootVariables();
+
+  scintCollection = new lem4ScintHitsCollection
+                          (SensitiveDetectorName,collectionName[0]); 
+  static G4int HCID = -1;
+  if(HCID<0) { 
+    HCID = G4SDManager::GetSDMpointer()->GetCollectionID(collectionName[0]);
+    if (verboseLevel>1) G4cout<<"VERBOSE 2:  lem4ScintSD::HCID was <0\n, now HCID="<<HCID<<"\n";
+  }
+  HCE->AddHitsCollection( HCID, scintCollection ); 
+  myStoreOnlyEventsWithHits = lem4Parameters::storeOnlyEventsWithHits;
+  mySignalSeparationTime    = lem4Parameters::signalSeparationTime;
+  myStoreOnlyTheFirstTimeHit= lem4Parameters::storeOnlyTheFirstTimeHit;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+G4bool lem4ScintSD::ProcessHits(G4Step* aStep,G4TouchableHistory*)
+{
+  if (verboseLevel>1) G4cout<<"VERBOSE 2:  lem4ScintSD::ProcessHits\n";
+  G4double edep = aStep->GetTotalEnergyDeposit();
+  if(edep==0.) {
+    return false;
+  }
+
+  G4Track* aTrack = aStep->GetTrack();
+  G4String actualVolume=aTrack->GetVolume()->GetLogicalVolume()->GetName();
+  //  G4cout <<"actualVolume=="<<actualVolume<<G4endl;
+  ///if (actualVolume=="Target") { // Perhaps not necessary! TS.
+    ///return false;
+  ///}
+  //  else if ((strncmp(actualVolume.c_str(),"Shield",6)==0)||(strncmp(actualVolume.c_str(),"shield",6)==0)) {
+    // delete track if the particle is far away from the detector (i.e. in the "shield" volume)
+  //    aTrack->SetTrackStatus(fSuspend);
+  //  }
+
+  // If requested, store only the hit that happened first (usefull for some special studies, not for a serious simulation)
+  if (myStoreOnlyTheFirstTimeHit) {
+    G4int NbHits = scintCollection->entries(); 
+    if (NbHits>0) {
+      aTrack->SetTrackStatus(fStopAndKill);
+      return false;
+    }
+  }
+
+
+  //cks  Ignore hits from the particles that had been created at the time when the muon 
+  //     was stopping in the target - not a correct thing to do, however no better way
+  //     to suppres wrong timing information of the hit found yet.
+  //  lem4RootOutput* myRootOutput = lem4RootOutput::GetRootInstance();
+  //  G4double muonArrivedInTarget = myRootOutput->GetTimeInTarget();
+  //  if (muonArrivedInTarget>0.) {
+  //    G4double timeOfThisTrack = aTrack->GetGlobalTime();
+  //    if (fabs(muonArrivedInTarget-timeOfThisTrack)<(2*ns)) {
+  //      return false;
+  //    }
+  //  }
+  //  else {
+  //    //    G4cout<<"Kamil: in the hit before muon has arrived into the target"<<G4endl;
+  //  }
+  //  if ( (aTrack->GetGlobalTime()) < (0.03*microsecond) )  return false;
+  lem4ScintHit* newHit = new lem4ScintHit();
+  //  G4RunManager* fRunManager = G4RunManager::GetRunManager();
+  //  newHit->SetEventID(fRunManager->GetCurrentEvent()->GetEventID());
+  //  newHit->SetRunID(fRunManager->GetCurrentRun()->GetRunID());
+  newHit->SetParticleName (aTrack->GetDefinition()->GetParticleName());
+  newHit->SetParticleID (aTrack->GetDefinition()->GetPDGEncoding());
+  //  if (aTrack->GetDefinition()->GetPDGEncoding()==-13) {
+  //  if ((aTrack->GetGlobalTime())<(0.015*microsecond)) {
+  //    G4cout<<"PROCESS: detected particle="<<aTrack->GetDefinition()->GetParticleName()
+  //	  <<"   TIME="<<aTrack->GetGlobalTime()<<G4endl;
+  //    const G4VProcess* interestingProcess = aStep->GetPostStepPoint()->GetProcessDefinedStep();
+  //    //  G4cout<<"GetProcessName()="<<interestingProcess->GetProcessName()<<G4endl;
+  //    const G4VProcess* creatorProcess =aTrack->GetCreatorProcess();
+  //    G4cout<<"Process that limitted this step: "; interestingProcess->DumpInfo();
+  //    if (creatorProcess!=NULL) {G4cout<<"Process that created this particle: "; creatorProcess->DumpInfo();}
+  //  }
+  newHit->SetTrackID   (aTrack->GetTrackID());
+  newHit->SetEdep      (edep);
+  newHit->SetPrePos    (aStep->GetPreStepPoint()->GetPosition());
+  newHit->SetPostPos   (aStep->GetPostStepPoint()->GetPosition());
+  newHit->SetPol       (aTrack->GetPolarization());
+  newHit->SetLogVolName(aTrack->GetVolume()->GetLogicalVolume()->GetName());
+  newHit->SetGlobTime  (aTrack->GetGlobalTime());
+  
+  /// Printout to check proper assignment of Global Time!
+  //G4cout<<"StepTime="<<aStep->GetDeltaTime()<<"\t";
+  //G4cout<<"GlobalTime="<<aTrack->GetGlobalTime()<<"      LocalTime="<<aTrack->GetLocalTime()<<"      ProperTime="<<aTrack->GetProperTime();
+  //G4cout<<"\t trackID="<<aTrack->GetTrackID() <<"\t actualVolume="<<actualVolume<<G4endl;
+  
+  //  Warning - aStep->IsFirstStepInVolume() only available in Geant version >= 4.8.2 !
+  //  newHit->SetFirstStepInVolumeFlag(aStep->IsFirstStepInVolume());
+  //  newHit->SetLastStepInVolumeFlag(aStep->IsLastStepInVolume());
+  newHit->SetKineticEnergy(aTrack->GetVertexKineticEnergy());
+  // newHit->SetKineticEnergy(aTrack->GetKineticEnergy()+edep);
+  newHit->SetStepLength   (aStep->GetStepLength());
+  //  G4double BFieldAtOrigin[6] = {0.,0.,0.,0.,0.,0.};
+  //  G4double Origin[4] ={0.,0.,0.,0.};
+  //  G4FieldManager *fMgr=G4TransportationManager::GetTransportationManager()->GetFieldManager();
+  //  if (fMgr!=NULL) {
+  //    if(!fMgr->DoesFieldChangeEnergy())  {            //then we have a magnetic field
+  //      fMgr->GetDetectorField()->GetFieldValue(Origin,BFieldAtOrigin);
+  //    }
+  //    else{
+  //    }
+  //    //    G4cout<<"Kamil: pole="<<BFieldAtOrigin[0]/tesla<<" "<<BFieldAtOrigin[1]/tesla<<" "<<BFieldAtOrigin[2]/tesla
+  //    //	  <<" "<<BFieldAtOrigin[3]/tesla<<" "<<BFieldAtOrigin[4]/tesla<<" "<<BFieldAtOrigin[5]/tesla<<G4endl;
+  //  }
+  //  newHit->SetBField(BFieldAtOrigin);
+  scintCollection->insert( newHit );
+  //  newHit->Print();
+  newHit->Draw();
+  return true;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+void lem4ScintSD::EndOfEvent(G4HCofThisEvent*) {
+  if (verboseLevel>1) { 
+    G4cout<<"VERBOSE 2:  lem4ScintSD::EndOfEvent"<<G4endl;
+    G4int NbHits = scintCollection->entries();
+    G4cout << "\n-------->Hits Collection: in this event they are " << NbHits 
+	   << " hits in the scint chambers: " << G4endl;
+    //    for (G4int i=0;i<NbHits;i++) (*scintCollection)[i]->Print();
+  } 
+  
+  //  Positron_momentum_already_stored=0;
+  lem4RootOutput* myRootOutput = lem4RootOutput::GetRootInstance();
+
+  G4RunManager* fRunManager = G4RunManager::GetRunManager();
+  myRootOutput->SetRunID(fRunManager->GetCurrentRun()->GetRunID());
+  myRootOutput->SetEventID(fRunManager->GetCurrentEvent()->GetEventID());
+
+  G4int NbHits = scintCollection->entries(); 
+  if ((NbHits<=0)&&(myStoreOnlyEventsWithHits)) {
+    myRootOutput->ClearAllRootVariables();
+    return;
+  }
+
+  //  Sort out hits and fill them into root
+  if (NbHits>0) {
+    lem4ScintHit* firstHit = (*scintCollection)[0];
+    myRootOutput->SetGlobTime(firstHit->GetGlobalTime());
+
+    const G4int det_IDmax = lem4RootOutput::det_nMax;
+    G4double det_edep[det_IDmax];
+    G4int    det_nsteps[det_IDmax];
+    G4double det_length[det_IDmax];
+    G4int    det_ID[det_IDmax];
+    G4double det_edep_el[det_IDmax];
+    G4double det_edep_pos[det_IDmax];
+    G4double det_edep_gam[det_IDmax];
+    G4double det_edep_mup[det_IDmax];
+    G4double det_time_start[det_IDmax];
+    G4double det_time_end[det_IDmax];
+    G4double det_x[det_IDmax];
+    G4double det_y[det_IDmax];
+    G4double det_z[det_IDmax];
+    //    for (G4int ii=0; ii<det_IDmax; ii++) {
+    //      det_edep[ii]=0.;
+    //      det_nsteps[ii]=0;
+    //      det_length[ii]=0.;
+    //      det_ID[ii]=-1000;
+    //      det_edep_el[ii]=0.;
+    //      det_edep_pos[ii]=0.;
+    //      det_edep_gam[ii]=0.;
+    //      det_edep_mup[ii]=0.;
+    //    }
+
+    //    const G4int subtrack_max=lem4RootOutput::maxNSubTracks;
+    //    G4int particleID[subtrack_max];
+    //    G4int trackID[subtrack_max];
+    //    G4int logicalVolumeID[subtrack_max];
+    //    G4double edep[subtrack_max];
+    //    G4double x[subtrack_max];
+    //    G4double y[subtrack_max];
+    //    G4double  z[subtrack_max];
+    //    G4double post_x[subtrack_max];
+    //    G4double  post_y[subtrack_max];
+    //    G4double post_z[subtrack_max];
+    //    G4double kineticEnergy[subtrack_max];
+    //    G4double stepLength[subtrack_max];
+    //    G4int nrOfSubsteps[subtrack_max];
+    //    for (G4int ii=0; ii<subtrack_max; ii++) {
+    //      particleID[ii]=-1000;
+    //      trackID[ii]=-1000;
+    //      logicalVolumeID[ii]=-1000;
+    //      edep[ii]=-1000;
+    //      x[ii]=-1000;
+    //      y[ii]=-1000;
+    //      z[ii]=-1000;
+    //      post_x[ii]=-1000;
+    //      post_y[ii]=-1000;
+    //      post_z[ii]=-1000;
+    //      kineticEnergy[ii]=-1000;
+    //      stepLength[ii]=-1000;
+    //      nrOfSubsteps[ii]=-1000;
+    //    }
+    
+    //    G4String aLogicalVolume_old="Unset";
+    //    G4String aParticleName_old="Unset";
+    //    G4int det_index=-1;
+    //    G4int subtrack_index=-1;
+    //    G4cout<<G4endl;
+
+    //    int myints[] = {32,71,12,45,26,80,53,33};
+    //    std::vector<int> myvector (myints, myints+8);               // 32 71 12 45 26 80 53 33
+    //    std::vector<int>::iterator it;
+    //    sort (myvector.begin(), myvector.end(), myREMOVEfunction);
+    //    // print out content:
+    //    G4cout << "myvector contains:";
+    //    for (it=myvector.begin(); it!=myvector.end(); ++it)
+    //      G4cout << " " << *it;
+    //    G4cout << G4endl;
+
+
+    //  Sort hits according to the time.  Using std::map is convenient, because it sorts
+    //  its entries according to the key (the first variable of the pair).
+    std::map<G4double,G4int> myHitTimeMapping;
+    std::map<G4double,G4int>::iterator it;
+    for (G4int i=0; i<NbHits; i++) {
+      lem4ScintHit* aHit = (*scintCollection)[i];
+      G4double tmptime=aHit->GetGlobalTime();
+      //      G4cout<<"Hit nr "<<i<<"  at time="<<tmptime<<"  with edep="<<aHit->GetEdep()/MeV
+      //	    <<"   detID="<<myRootOutput->ConvertVolumeToID(aHit->GetLogVolName())<< G4endl;
+      myHitTimeMapping.insert ( std::pair<G4double,G4int>(tmptime,i) );
+    }
+
+    //  Loop over all hits (which are sorted according to their time):
+    G4int nSignals=0;
+    for (it=myHitTimeMapping.begin(); it!=myHitTimeMapping.end(); it++) {
+      //      G4cout << "Key:" << it->first;
+      //      G4cout << "  Value:" << it->second << "\n";
+      G4int ii = it->second;      // ii  is the index of the hits, which is sorted according to time
+      lem4ScintHit* aHit = (*scintCollection)[ii];
+      G4String aHitVolumeName = aHit->GetLogVolName();
+      G4int    aHitVolumeID   = myRootOutput->ConvertVolumeToID(aHitVolumeName);
+      G4double aHitTime       = aHit->GetGlobalTime();
+
+      // Loop over all already defined signals and check whether the hit falls into any of them
+      G4bool signalAssigned=false;
+      for (G4int j=0; j<nSignals; j++) {
+	if ( (aHitVolumeID==det_ID[j]) && ((aHitTime-det_time_end[j])<mySignalSeparationTime) ) {
+	  signalAssigned=true;
+	  det_edep[j]                 += aHit->GetEdep();
+	  det_nsteps[j]++;
+	  det_length[j]               += aHit->GetStepLength();
+	  det_time_end[j]              = aHitTime;
+	  G4String aParticleName       = aHit->GetParticleName();
+	  if (aParticleName=="e-") {
+	    det_edep_el[j]            += aHit->GetEdep();
+	  }  else if (aParticleName=="e+") {
+	    det_edep_pos[j]           += aHit->GetEdep();
+	  }  else if (aParticleName=="gamma") {
+	    det_edep_gam[j]           += aHit->GetEdep();
+	  }  else if (aParticleName=="mu+") {
+	    det_edep_mup[j]           += aHit->GetEdep();
+	  }  else {
+	    char message[200];
+	    sprintf(message,"lem4ScintSD.cc::EndOfEvent(): untreated particle \"%s\" deposited energy.",aParticleName.c_str());
+	    lem4ErrorMessage::GetInstance()->lem4Error(WARNING,message,true);
+	  }
+	  break;
+	}
+      }
+      if (!signalAssigned) {    // The hit does not belong to any existing signal --> create a new signal.
+	// Check, whether the maximum number of signals was not exceeded:
+	if ( nSignals >= (det_IDmax-1) ) {
+	  char message[200];
+	  sprintf(message,"lem4ScintSD.cc::EndOfEvent(): number of signals exceeds maximal allowed value.");
+	  lem4ErrorMessage::GetInstance()->lem4Error(WARNING,message,true);
+	}
+	else {
+	  det_edep[nSignals]                  = aHit->GetEdep();
+	  det_nsteps[nSignals]                = 1;
+	  det_length[nSignals]                = aHit->GetStepLength();
+	  det_ID[nSignals]                    = aHitVolumeID;
+	  det_time_start[nSignals]            = aHitTime;
+	  det_time_end[nSignals]              = aHitTime;
+	  det_edep_el[nSignals]               = 0;
+	  det_edep_pos[nSignals]              = 0;
+	  det_edep_gam[nSignals]              = 0;
+	  det_edep_mup[nSignals]              = 0;
+	  G4String aParticleName              = aHit->GetParticleName();
+	  if (aParticleName=="e-") {
+	    det_edep_el[nSignals]            += aHit->GetEdep();
+	  }  else if (aParticleName=="e+") {
+	    det_edep_pos[nSignals]           += aHit->GetEdep();
+	  }  else if (aParticleName=="gamma") {
+	    det_edep_gam[nSignals]           += aHit->GetEdep();
+	  }  else if (aParticleName=="mu+") {
+	    det_edep_mup[nSignals]           += aHit->GetEdep();
+	  }  else {
+	    char message[200];
+	    sprintf(message,"lem4ScintSD.cc::EndOfEvent(): UNTREATED PARTICLE \"%s\" deposited energy.",aParticleName.c_str());
+	    lem4ErrorMessage::GetInstance()->lem4Error(WARNING,message,true);
+	  }
+	  G4ThreeVector prePos = aHit->GetPrePos();
+	  det_x[nSignals]=prePos.x();
+	  det_y[nSignals]=prePos.y();
+	  det_z[nSignals]=prePos.z();
+	  nSignals++;
+	}
+      }   // end of "if (!signalAssigned)"
+    }  // end of the for loop over the hits
+
+    // Sort the signals according to the energy (in decreasing order)
+    std::map<G4double,G4int> mySignalMapping;
+    std::map<G4double,G4int>::iterator itt;
+    for (G4int i=0; i<nSignals; i++) {
+      mySignalMapping.insert ( std::pair<G4double,G4int>(-det_edep[i],i) );
+    }
+
+    // Write out the signals (sorted according to energy) to the lem4RootOutput class:
+    G4int jj=-1;
+    for (itt=mySignalMapping.begin(); itt!=mySignalMapping.end(); itt++) {
+      jj++;
+      G4int ii = itt->second;
+      myRootOutput->SetDetectorInfo(jj,det_ID[ii],det_edep[ii],det_edep_el[ii],det_edep_pos[ii],
+				    det_edep_gam[ii],det_edep_mup[ii],det_nsteps[ii],det_length[ii],
+				    det_time_start[ii],det_time_end[ii],det_x[ii],det_y[ii],det_z[ii]);
+    }
+
+  }   //end "if (NbHits>0)"
+
+  myRootOutput->FillEvent();
+  myRootOutput->ClearAllRootVariables();
+}  
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

geant4/LEMuSR/src/lem4ShieldHit.cc

@@ -0,0 +1,99 @@
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+#include "lem4ShieldHit.hh"
+#include "G4UnitsTable.hh"
+#include "G4VVisManager.hh"
+#include "G4Circle.hh"
+#include "G4Colour.hh"
+#include "G4VisAttributes.hh"
+#include <fstream>
+#include <iostream>
+#include "G4ios.hh"
+#include "G4MagneticField.hh"
+#include "G4FieldManager.hh"
+#include "G4TransportationManager.hh"
+#include <iomanip>
+#include "globals.hh"
+#include "G4Transform3D.hh"
+#include "G4ProcessManager.hh"
+#include "G4Track.hh"
+#include "G4ThreeVector.hh"
+#include "G4Event.hh"
+#include "G4EventManager.hh"
+#include "G4RunManager.hh"
+#include "G4Run.hh"
+
+G4Allocator<lem4ShieldHit> lem4ShieldHitAllocator;
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+lem4ShieldHit::lem4ShieldHit() {}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+lem4ShieldHit::~lem4ShieldHit() {}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+lem4ShieldHit::lem4ShieldHit(const lem4ShieldHit& right)
+  : G4VHit()
+{
+
+  trackID   = right.trackID;
+  particle_name = right.particle_name;
+  edep      = right.edep;
+  pos       = right.pos;
+  pol       = right.pol;
+  logicalvolume = right.logicalvolume;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+const lem4ShieldHit& lem4ShieldHit::operator=(const lem4ShieldHit& right)
+{
+
+  trackID   = right.trackID;
+  particle_name = right.particle_name;
+  edep      = right.edep;
+  pos       = right.pos;
+  pol       = right.pol;
+  logicalvolume=right.logicalvolume;
+  return *this;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+G4int lem4ShieldHit::operator==(const lem4ShieldHit& right) const
+{
+  return (this==&right) ? 1 : 0;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+void lem4ShieldHit::Draw()
+{
+  G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
+  if(pVVisManager)
+  {
+    G4Circle circle(pos);
+    circle.SetScreenSize(0.04);
+    circle.SetFillStyle(G4Circle::filled);
+    G4Colour colour(1.,0.,0.);
+    G4VisAttributes attribs(colour);
+    circle.SetVisAttributes(attribs);
+    pVVisManager->Draw(circle);
+  }
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+void lem4ShieldHit::Print()
+{
+
+  G4EventManager* fEventManager = G4EventManager::GetEventManager();
+  fEventManager->AbortCurrentEvent();
+
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+

geant4/LEMuSR/src/lem4ShieldSD.cc

@@ -0,0 +1,82 @@
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+#include "lem4ShieldSD.hh"
+#include "G4HCofThisEvent.hh"
+#include "G4Step.hh"
+#include "G4ThreeVector.hh"
+#include "G4SDManager.hh"
+#include "G4ios.hh"
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+  ///
+  /// The Shield sensitive detector. This object collects the
+  /// information of a particle's interaction with this part
+  /// of the geometry
+  ///
+
+lem4ShieldSD::lem4ShieldSD(G4String name)
+:G4VSensitiveDetector(name)
+{
+  G4String HCname;
+  collectionName.insert(HCname="shieldCollection");
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+lem4ShieldSD::~lem4ShieldSD(){ }
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+void lem4ShieldSD::Initialize(G4HCofThisEvent* HCE)
+{
+  shieldCollection = new lem4ShieldHitsCollection
+                          (SensitiveDetectorName,collectionName[0]); 
+  static G4int HCID = -1;
+  if(HCID<0)
+  { HCID = G4SDManager::GetSDMpointer()->GetCollectionID(collectionName[0]); }
+  HCE->AddHitsCollection( HCID, shieldCollection ); 
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+G4bool lem4ShieldSD::ProcessHits(G4Step* aStep,G4TouchableHistory*)
+{
+  ///
+  /// Collect the information regarding the interaction of a particle
+  /// and the sensitive detector.
+  ///
+  G4double edep = aStep->GetTotalEnergyDeposit();
+
+  if(edep==0.) return false;
+
+  lem4ShieldHit* newHit = new lem4ShieldHit();
+  newHit->SetParticleName (aStep->GetTrack()->GetDefinition()->GetParticleName());
+  newHit->SetTrackID  (aStep->GetTrack()->GetTrackID());
+  newHit->SetEdep     (edep);
+  newHit->SetPos      (aStep->GetPostStepPoint()->GetPosition());
+  newHit->SetPol      (aStep->GetTrack()->GetPolarization());
+  newHit->SetLogVolName (aStep->GetTrack()->GetVolume()->GetLogicalVolume()->GetName());
+  shieldCollection->insert( newHit );
+  
+  newHit->Print();
+  newHit->Draw();
+
+
+
+  return true;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+void lem4ShieldSD::EndOfEvent(G4HCofThisEvent*)
+{
+  if (verboseLevel>0) { 
+     G4int NbHits = shieldCollection->entries();
+     G4cout << "\n-------->Hits Collection: in this event they are " << NbHits 
+            << " hits: " << G4endl;
+     for (G4int i=0;i<NbHits;i++) (*shieldCollection)[i]->Print();
+    } 
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+

geant4/LEMuSR/src/lem4SteppingAction.cc

@@ -0,0 +1,337 @@
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+#include "lem4SteppingAction.hh"
+//cksdel#include "lem4RunAction.hh"
+#include "G4SteppingManager.hh"
+#include "G4UnitsTable.hh"
+#include "lem4RootOutput.hh"
+#include "G4RunManager.hh"  // needed for the event nr. comparison
+#include "G4Run.hh"         // ---------------||------------------
+#include "G4MagneticField.hh"          // needed for storing the magnetic field to the Root class
+#include "G4FieldManager.hh"           // ---------------||------------------
+#include "G4TransportationManager.hh"  // ---------------||------------------
+#include "lem4ErrorMessage.hh"
+#include "lem4Parameters.hh"
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+lem4SteppingAction::lem4SteppingAction()  { 
+ pointer=this;
+ // oldEventID=-1000;
+ muPlusProcessManager=NULL;
+ multipleToCoulombScatteringIsPossible=false;
+ coulombScatteringIsActive=false;
+ multipleScatteringIndex=1000;
+ coulombScatteringIndex=1000;
+ boolIsAnySpecialSaveVolumeDefined = false;
+ lastActualVolume="Unset";
+}
+
+lem4SteppingAction::~lem4SteppingAction()  { 
+}
+
+
+ lem4SteppingAction* lem4SteppingAction::pointer=0;
+ lem4SteppingAction* lem4SteppingAction::GetInstance()
+{
+  return pointer;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+void lem4SteppingAction::DoAtTheBeginningOfEvent() {
+  //  G4cout<<"lem4SteppingAction::DoAtTheBeginningOfEvent:  KAMIL"<<G4endl;
+  radioactiveElectronAlreadySavedInThisEvent=false;
+  muAlreadyWasInTargetInThisEvent=false;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+void lem4SteppingAction::UserSteppingAction(const G4Step* aStep)  { 
+  // sleep(1);
+  // For debugging purposes: To find out the number of steps during one event:
+  //  G4RunManager* fRunManager = G4RunManager::GetRunManager();
+  //  G4int debugEventID = fRunManager->GetCurrentEvent()->GetEventID();
+  //  nrOfSteps++;
+  //  if (debugOldEventID != debugEventID) {
+  //    G4cout<<"lem4SteppingAction:  Event nr. "<<debugOldEventID<<"  has"<<nrOfSteps<<" steps."<<G4endl;
+  //    nrOfSteps=0;
+  //    debugOldEventID=debugEventID;
+  //  }
+
+  G4Track* aTrack = aStep->GetTrack();
+  //  if (nrOfSteps > 100000) {
+  //    G4cout<<"lem4SteppingAction.cc : event nr. "<<debugEventID
+  //      <<":   nrOfSteps>100000   ==> KILL THE CURRENT TRACK with" 
+  //      <<aTrack->GetDynamicParticle()->GetDefinition()->GetParticleName() <<" at"
+  //       <<aStep->GetPostStepPoint()->GetPosition() <<G4endl;
+  //    G4cout<<"GetCurrentStepNumber()="<<aTrack->GetCurrentStepNumber() <<G4endl;
+  //    aTrack->SetTrackStatus(fStopAndKill); // suspend the track if too many steps have already happened
+  //                                          // (should be done in a more clever way, but I do not know how yet).
+  //    nrOfSteps=0;
+  //  }
+
+  //  suspend the track if too many steps have already happened (relevant at high fields)
+  if (aTrack->GetCurrentStepNumber()>100000) {
+    lem4ErrorMessage::GetInstance()->lem4Error(WARNING,
+    	  "lem4SteppingAction: Current number of steps for the track > 100000 ==> TRACK KILLED",true);
+    //
+    //    G4cout<<"lem4SteppingAction.cc : event nr. "<<oldEventID
+    //	  <<"  Current number of steps for the track > 100000 ==> KILL THIS TRACK: " <<G4endl;
+    //	  <<aTrack->GetDynamicParticle()->GetDefinition()->GetParticleName() <<" at"
+    //	  <<aStep->GetPostStepPoint()->GetPosition() 
+    //	  <<"  E_kin_vertex="<<aTrack->GetVertexKineticEnergy()/MeV<<" MeV."<<G4endl;
+    //
+    lem4RootOutput* myRootOutput = lem4RootOutput::GetRootInstance();
+    G4double x=aStep->GetPostStepPoint()->GetPosition().x()/mm;
+    G4double y=aStep->GetPostStepPoint()->GetPosition().y()/mm;
+    G4double z=aStep->GetPostStepPoint()->GetPosition().z()/mm;
+    G4double E=aTrack->GetVertexKineticEnergy()/MeV;
+    myRootOutput->htest1->Fill(x,y);
+    myRootOutput->htest2->Fill(sqrt(x*x+y*y),z);
+    myRootOutput->htest3->Fill(E);
+    
+    aTrack->SetTrackStatus(fStopAndKill);
+  }
+
+  
+  if (aTrack->GetDefinition()) {
+    G4ParticleDefinition* p_definition = aTrack->GetDynamicParticle()->GetDefinition();
+    G4String              p_name       = p_definition->GetParticleName();
+    //    G4ProcessManager*     p_manager    = p_definition->GetProcessManager();
+    //    G4String p_name=aTrack->GetDynamicParticle()->GetDefinition()->GetParticleName();
+    G4String actualVolume=aTrack->GetVolume()->GetLogicalVolume()->GetName();
+
+    
+    
+//! First Commented by TS. Currently not in use! or not strictly necessary
+
+    
+    //  This are the data just for the radioactive decay (when using the radioactive source):
+    if ((lem4Parameters::boolG4GeneralParticleSource))  {
+      //      &&(!radioactiveElectronAlreadySavedInThisEvent)) {
+      if (aTrack->GetTrackID() != 1 ){
+	if (aTrack->GetCreatorProcess()->GetProcessName() == "RadioactiveDecay") {
+	//	if (aStep->GetPostStepPoint()->GetProcessDefinedStep()->GetProcessName() == "RadioactiveDecay") {   did not work out
+	  // emitted particles
+	  //	  if (fTrack->GetDefinition()->GetParticleType() != "nucleus") {
+	  //  G4String particleName = fTrack->GetDefinition()->GetParticleName();
+          if (aTrack->GetDefinition()->GetParticleName()=="e-") {
+	    //	  G4double particleName = G4double (fTrack->GetDefinition()->GetPDGEncoding());
+	    //          G4double time = fStep->GetPreStepPoint()->GetGlobalTime() ;
+	    //          //- fStep->GetPreStepPoint()->GetLocalTime();
+	    //          G4double weight = fStep->GetPreStepPoint()->GetWeight() ;
+	    //          G4double energy = fStep->GetPreStepPoint()->GetKineticEnergy();
+	    //
+	    //          exrdmAnalysisManager::getInstance()->AddParticle(particleName, energy, weight, time);
+	    //hovno
+	    //	    G4cout<<"aTrack->GetCurrentStepNumber()="<<aTrack->GetCurrentStepNumber()<<"     ";
+	    if (aTrack->GetCurrentStepNumber()==1) {
+	      G4double electron_kinetic_energy=aStep->GetPreStepPoint()->GetKineticEnergy();
+	      lem4RootOutput* myRootOutput = lem4RootOutput::GetRootInstance();
+	      myRootOutput->htest4->Fill(electron_kinetic_energy);
+	      //	      G4cout<<"First kinetic energy="<<aStep->GetPreStepPoint()->GetKineticEnergy()<<"     ";
+	      //	      G4cout<<"GetKineticEnergy()="<<aTrack->GetKineticEnergy()<<G4endl;
+	    }
+	    //	    //	    G4ThreeVector radioactivePositronMomentum = aStep->GetPreStepPoint()->GetMomentum();
+	    //	    G4ThreeVector radioactivePositronMomentum = aTrack->GetMomentum();
+	    //	    G4double Apx=radioactivePositronMomentum.x();
+	    //	    G4double Apy=radioactivePositronMomentum.y();
+	    //	    G4double Apz=radioactivePositronMomentum.z();
+	    //	    lem4RootOutput* myRootOutput = lem4RootOutput::GetRootInstance();
+	    //	    myRootOutput->SetInitialMuonParameters(0,0,0,Apx,Apy,Apz,0,0,0);
+	    //	    radioactiveElectronAlreadySavedInThisEvent=true;
+	    //	    //	    G4cout<<"Apx,Apy,Apz="<<Apx<<" "<<Apy<<" "<<Apz<<G4endl;
+	  }
+        }
+      }
+    }
+
+        
+    //hovno
+    // Check if in the special 
+    if (boolIsAnySpecialSaveVolumeDefined) {
+      //    G4bool isFirstStepInVolume=aStep->IsFirstStepInVolume();
+      //          This does not work!!! (aStep->IsFirstStepInVolume() is always zero.)  I do not understand why!
+      G4bool isFirstStepInVolume=false;
+      if (actualVolume!=lastActualVolume) {
+	lastActualVolume=actualVolume;
+	isFirstStepInVolume=true;
+      }
+
+      if (isFirstStepInVolume) {
+	G4int tmpVolumeID=saveVolumeMapping[actualVolume];
+	if (tmpVolumeID!=0) {
+	  G4int particle_id_save=p_definition->GetPDGEncoding();
+	  G4double ke_save=aStep->GetPreStepPoint()->GetKineticEnergy()/keV;
+	  G4double  x_save=aStep->GetPreStepPoint()->GetPosition().x()/mm;
+	  G4double  y_save=aStep->GetPreStepPoint()->GetPosition().y()/mm;
+	  G4double  z_save=aStep->GetPreStepPoint()->GetPosition().z()/mm;
+	  G4double px_save=aStep->GetPreStepPoint()->GetMomentum().x()/MeV;
+	  G4double py_save=aStep->GetPreStepPoint()->GetMomentum().y()/MeV;
+	  G4double pz_save=aStep->GetPreStepPoint()->GetMomentum().z()/MeV;
+	  lem4RootOutput* myRootOutput = lem4RootOutput::GetRootInstance();
+	  myRootOutput->SetSaveDetectorInfo(tmpVolumeID,particle_id_save,ke_save,x_save,y_save,z_save,px_save,py_save,pz_save);
+	}
+      }
+    }
+
+    
+      // Store information about when mu+ or Mu enter the target for the fist time
+      // in a given event (i.e. the code has to be called just once during the event).      
+    if ((p_name == "mu+") || (p_name == "Mu"))  {  
+       if (actualVolume=="log_target") {
+	  //	G4RunManager* fRunManager = G4RunManager::GetRunManager();
+	  //      	G4int eventID = fRunManager->GetCurrentEvent()->GetEventID();
+	  //	if (oldEventID != eventID) {
+	  //	  oldEventID=eventID;
+	if (!muAlreadyWasInTargetInThisEvent) {
+	  muAlreadyWasInTargetInThisEvent=true;
+	  lem4RootOutput* myRootOutput = lem4RootOutput::GetRootInstance();
+	  myRootOutput->SetPolInTarget(aTrack->GetPolarization());
+	  myRootOutput->SetTimeInTarget(aTrack->GetGlobalTime());
+	  //G4cout<<"particle = "<<p_name<<"    TOF = "<<(aTrack->GetGlobalTime())/ns<<G4endl;
+	}
+      }
+    }
+      
+      //  Store the pointer to the mu+ process manager, and the indexes of the "msc" and "eCoulombScat" processes.
+      //  This is needed for switching beween the multiple scattering and coulomb scattering in some volumes.
+    if (p_name == "mu+")	{
+      if (muPlusProcessManager==NULL) {   // The muPlusProcessManager should be NULL only once, at the beginning of the run.
+	muPlusProcessManager = p_definition->GetProcessManager();
+	G4ProcessVector* v = muPlusProcessManager->GetProcessList();
+	size_t np = v->size();
+	for(size_t i=0; i<np; i++) {
+	  //	  std::cout<<" "<<(*v)[i]->GetProcessName();
+	  if( (*v)[i]->GetProcessName() == "msc" ) {
+	    multipleScatteringIndex = i;
+	  }
+	  if( (*v)[i]->GetProcessName() == "eCoulombScat" ) {
+	    coulombScatteringIndex = i;
+	  }
+	}
+	//	std::cout<<std::endl;
+	//	std::cout<<"multipleScatteringIndex,coulombScatteringIndex ="<<multipleScatteringIndex<<","<<coulombScatteringIndex<<std::endl;
+	if ((multipleScatteringIndex<1000)&&(coulombScatteringIndex<1000)) {    // Both multiple and Coulomb scattering processes for muon found
+	  multipleToCoulombScatteringIsPossible=true;
+	  std::cout<<"lem4SteppingAction: Switching between Coulomb and multiple scattering processes possible"<<std::endl;
+	  // Ensure that just one of them is active.  Let the active one be the multiple scattering at the beginning.
+	  muPlusProcessManager->SetProcessActivation(multipleScatteringIndex, true);
+	  muPlusProcessManager->SetProcessActivation(coulombScatteringIndex,  false);
+	}
+	else {                // At least one of the "multiple scattering" and "coulomb scattering" was not found.
+                              // Perhaps they were not defined in the physics list ?
+	  if (lem4Parameters::GetInstance()->GetMyTypeOfProcesses()=="coulombAndMultiple") {
+	    if (coulombScatteringIndex==1000) {std::cout<<"lem4SteppingAction: Coulomb scattering process for mu+ not found!"<<std::endl;}
+	    if (multipleScatteringIndex==1000) {std::cout<<"lem4SteppingAction: Multiple scattering process for mu+ not found!"<<std::endl;}
+	    lem4ErrorMessage::GetInstance()->lem4Error(SERIOUS,
+		                      "lem4SteppingAction:  It is not possible to switch between Coulomb and multiple scattering.",true);
+  
+	    muPlusProcessManager->DumpInfo();
+	  }
+	}
+      }
+      
+      // switch between G4MultipleScattering and G4CoulombScattering
+      if (multipleToCoulombScatteringIsPossible) {
+	if (strncmp(actualVolume.c_str(),"log_coulomb",11)==0) {
+	  if (!coulombScatteringIsActive) {
+	    //	    std::cout<<"Activating coulomb; volume= "<<actualVolume<<std::endl;
+	    muPlusProcessManager->SetProcessActivation(multipleScatteringIndex, false);
+	    muPlusProcessManager->SetProcessActivation(coulombScatteringIndex,  true);
+	    coulombScatteringIsActive=true;
+	  }
+	}
+	else if (coulombScatteringIsActive) {
+	  //	  std::cout<<"Deactivating coulomb; volume= "<<actualVolume<<std::endl;
+	  muPlusProcessManager->SetProcessActivation(multipleScatteringIndex, true);
+	  muPlusProcessManager->SetProcessActivation(coulombScatteringIndex,  false);
+	  coulombScatteringIsActive=false;
+	}
+      }
+      
+      //  Store the information about the muon decay into the Root Class. 
+      //     Pick up process "DecayWithSpin":
+      const G4VProcess* process = aStep->GetPostStepPoint()->GetProcessDefinedStep();
+      if (process!=NULL) {
+	G4String processName = process->GetProcessName();
+	if (processName=="DecayWithSpin") {
+	  lem4Parameters::field_DecayWithSpin=true;
+	  //	  std::cout<<"lem4SteppingAction: DecayWithSpin"<<std::endl;
+	  // store the information about the decaying muon
+	  lem4RootOutput* myRootOutput = lem4RootOutput::GetRootInstance();
+	  G4double timeOfDecay_tmp=aTrack->GetGlobalTime();
+	  myRootOutput->SetDecayTime(timeOfDecay_tmp);
+	  myRootOutput->SetDecayPolarisation(aTrack->GetPolarization());
+	  G4ThreeVector positionOfDecay_tmp = aStep->GetPostStepPoint()->GetPosition();
+	  myRootOutput->SetDecayPosition(positionOfDecay_tmp);
+	  // store the detector ID in which the muon decayed
+	  myRootOutput->SetDecayDetectorID(actualVolume);
+	  // store the information about the magnetic field at the place where the muon decays
+	  G4double BFieldAtOrigin[6] = {0.,0.,0.,0.,0.,0.};
+	  G4double PointOfDecay[4] ={positionOfDecay_tmp.x(),positionOfDecay_tmp.y(),positionOfDecay_tmp.z(),timeOfDecay_tmp};
+	  G4FieldManager *fMgr=G4TransportationManager::GetTransportationManager()->GetFieldManager();
+	  if (fMgr!=NULL) {
+	    if(!fMgr->DoesFieldChangeEnergy())  {            //then we have a magnetic field
+	      fMgr->GetDetectorField()->GetFieldValue(PointOfDecay,BFieldAtOrigin);
+	      myRootOutput->SetBField(BFieldAtOrigin);
+	    }
+	    else{
+	    }
+	  }
+	  
+	  // store the information about the emerging positron
+	  G4TrackVector* secondary = fpSteppingManager->GetSecondary();
+	  G4int n_secondaries= (*secondary).size();
+	  for (G4int i=0; i<n_secondaries; i++) {
+	    //	    G4cout <<"Secondary ["<<i<<"]="<<(*secondary)[i]->GetDefinition()->GetParticleName()<<", ";
+	    if ( ((*secondary)[i]->GetDefinition()->GetParticleName()) == "e+" ) {
+	      myRootOutput->SetInitialPositronMomentum((*secondary)[i]->GetMomentum());
+	      
+	      // These two times seem to be equivalent:    (*secondary)[i]->GetGlobalTime()
+	      //                                           aTrack->GetGlobalTime()
+	      //	      G4cout <<"Positron initial momentum="<<(*secondary)[i]->GetMomentum()<<G4endl;
+	      //	      G4cout <<"Positron time="<<(*secondary)[i]->GetGlobalTime()<<G4endl;
+	      //	      G4cout <<"astep time="<<aTrack->GetGlobalTime()<<G4endl;
+	    }
+	  }
+	}
+      }
+      //csk
+      
+      G4ThreeVector position = aStep->GetPostStepPoint()->GetPosition();
+      //    G4double tof=aTrack->GetLocalTime();
+      //    G4double energy=aTrack->GetDynamicParticle()->GetKineticEnergy();
+      G4ThreeVector polarization=aTrack->GetDynamicParticle()->GetPolarization();
+      
+      //      G4cout << "Stepping action: mu+ properties \n"
+      //	     << "position "      << G4BestUnit(position,"Length") <<"; \n"
+      //        << "time of flight " << G4BestUnit(tof,"Time")        <<"; \n"
+      //        << "kinetic energy  "<< G4BestUnit(energy,"Energy")   <<"; \n"
+      //        <<  "polarization   "<< polarization <<";\n"
+      //	     <<G4endl;
+    }
+    
+    else {   // particle is not muon
+      // Delete track if the particle is far away from the detector (i.e. in the "shield" volume).
+      // There is an example how to delete the track in example/novice/N04.
+      // It is done in a different way here, because the example/novice/N04 was not doing
+      // exactly what I wanted.
+/*      if ((lem4Parameters::killAllPositrons)&&(p_name == "e+")){
+	aTrack->SetTrackStatus(fStopAndKill);   // suspend the track
+      }
+      */
+      if((actualVolume(0,10)=="log_shield")||(actualVolume(0,10)=="log_Shield")) { 
+	aTrack->SetTrackStatus(fStopAndKill);   // suspend the track
+      }
+    }
+  }
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+
+void lem4SteppingAction::SetLogicalVolumeAsSpecialSaveVolume(G4String logicName, G4int volumeID)  { 
+  boolIsAnySpecialSaveVolumeDefined = true;
+  saveVolumeMapping[logicName]=volumeID;
+}

geant4/LEMuSR/src/lem4SteppingVerbose.cc

@@ -0,0 +1,151 @@
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+#include "lem4SteppingVerbose.hh"
+
+#include "G4SteppingManager.hh"
+#include "G4UnitsTable.hh"
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+lem4SteppingVerbose::lem4SteppingVerbose()
+{}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+lem4SteppingVerbose::~lem4SteppingVerbose()
+{}
+ 
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+void lem4SteppingVerbose::StepInfo()
+{
+  CopyState();
+  
+  G4int prec = G4cout.precision(3);
+
+  if( verboseLevel >= 1 ){
+    if( verboseLevel >= 4 ) VerboseTrack();
+    if( verboseLevel >= 3 ){
+      G4cout << G4endl;    
+      G4cout << std::setw( 5) << "#Step#"     << " "
+	     << std::setw( 6) << "X"          << "    "
+	     << std::setw( 6) << "Y"          << "    "  
+	     << std::setw( 6) << "Z"          << "    "
+	     << std::setw( 9) << "KineE"      << " "
+	     << std::setw( 9) << "dEStep"     << " "  
+	     << std::setw(10) << "StepLeng"     
+	     << std::setw(10) << "TrakLeng" 
+	     << std::setw(10) << "Volume"    << "  "
+	     << std::setw(10) << "Process"   << G4endl;	          
+    }
+
+    G4cout << std::setw(5) << fTrack->GetCurrentStepNumber() << " "
+	<< std::setw(6) << G4BestUnit(fTrack->GetPosition().x(),"Length")
+	<< std::setw(6) << G4BestUnit(fTrack->GetPosition().y(),"Length")
+	<< std::setw(6) << G4BestUnit(fTrack->GetPosition().z(),"Length")
+	<< std::setw(6) << G4BestUnit(fTrack->GetKineticEnergy(),"Energy")
+	<< std::setw(6) << G4BestUnit(fStep->GetTotalEnergyDeposit(),"Energy")
+	<< std::setw(6) << G4BestUnit(fStep->GetStepLength(),"Length")
+	<< std::setw(6) << G4BestUnit(fTrack->GetTrackLength(),"Length")
+	<< "  ";
+
+    // if( fStepStatus != fWorldBoundary){ 
+    if( fTrack->GetNextVolume() != 0 ) { 
+      G4cout << std::setw(10) << fTrack->GetVolume()->GetName();
+    } else {
+      G4cout << std::setw(10) << "OutOfWorld";
+    }
+
+    if(fStep->GetPostStepPoint()->GetProcessDefinedStep() != NULL){
+      G4cout << "  " 
+        << std::setw(10) << fStep->GetPostStepPoint()->GetProcessDefinedStep()
+	                                ->GetProcessName();
+    } else {
+      G4cout << "   UserLimit";
+    }
+
+    G4cout << G4endl;
+
+    if( verboseLevel == 2 ){
+      G4int tN2ndariesTot = fN2ndariesAtRestDoIt +
+	                    fN2ndariesAlongStepDoIt +
+	                    fN2ndariesPostStepDoIt;
+      if(tN2ndariesTot>0){
+	G4cout << "    :----- List of 2ndaries - "
+	       << "#SpawnInStep=" << std::setw(3) << tN2ndariesTot 
+	       << "(Rest="  << std::setw(2) << fN2ndariesAtRestDoIt
+	       << ",Along=" << std::setw(2) << fN2ndariesAlongStepDoIt
+	       << ",Post="  << std::setw(2) << fN2ndariesPostStepDoIt
+	       << "), "
+	       << "#SpawnTotal=" << std::setw(3) << (*fSecondary).size()
+	       << " ---------------"
+	       << G4endl;
+
+	for(size_t lp1=(*fSecondary).size()-tN2ndariesTot; 
+                        lp1<(*fSecondary).size(); lp1++){
+	  G4cout << "    : "
+		 << std::setw(6)
+		 << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(),"Length")
+		 << std::setw(6)
+		 << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(),"Length")
+		 << std::setw(6)
+		 << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(),"Length")
+		 << std::setw(6)
+		 << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(),"Energy")
+		 << std::setw(10)
+		 << (*fSecondary)[lp1]->GetDefinition()->GetParticleName();
+	  G4cout << G4endl;
+	}
+              
+	G4cout << "    :-----------------------------"
+	       << "----------------------------------"
+	       << "-- EndOf2ndaries Info ---------------"
+	       << G4endl;
+      }
+    }
+    
+  }
+  G4cout.precision(prec);
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+void lem4SteppingVerbose::TrackingStarted()
+{
+
+  CopyState();
+G4int prec = G4cout.precision(3);
+  if( verboseLevel > 0 ){
+
+    G4cout << std::setw( 5) << "Step#"      << " "
+           << std::setw( 6) << "X"          << "    "
+	   << std::setw( 6) << "Y"          << "    "  
+	   << std::setw( 6) << "Z"          << "    "
+	   << std::setw( 9) << "KineE"      << " "
+	   << std::setw( 9) << "dEStep"     << " "  
+	   << std::setw(10) << "StepLeng"  
+	   << std::setw(10) << "TrakLeng"
+	   << std::setw(10) << "Volume"     << "  "
+	   << std::setw(10) << "Process"    << G4endl;	     
+
+    G4cout << std::setw(5) << fTrack->GetCurrentStepNumber() << " "
+	<< std::setw(6) << G4BestUnit(fTrack->GetPosition().x(),"Length")
+	<< std::setw(6) << G4BestUnit(fTrack->GetPosition().y(),"Length")
+	<< std::setw(6) << G4BestUnit(fTrack->GetPosition().z(),"Length")
+	<< std::setw(6) << G4BestUnit(fTrack->GetKineticEnergy(),"Energy")
+	<< std::setw(6) << G4BestUnit(fStep->GetTotalEnergyDeposit(),"Energy")
+	<< std::setw(6) << G4BestUnit(fStep->GetStepLength(),"Length")
+	<< std::setw(6) << G4BestUnit(fTrack->GetTrackLength(),"Length")
+	<< "  ";
+
+    if(fTrack->GetNextVolume()){
+      G4cout << std::setw(10) << fTrack->GetVolume()->GetName();
+    } else {
+      G4cout << std::setw(10) << "OutOfWorld";
+    }
+    G4cout  << "    initStep" << G4endl;
+  }
+  G4cout.precision(prec);
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

geant4/LEMuSR/src/lem4TabulatedElementField2D.cc

@@ -0,0 +1,402 @@
+#include "lem4TabulatedElementField2D.hh"
+//#include "lem4EventAction.hh"    // cks: just to get the event nr. if needed.
+#include "lem4Parameters.hh" /// Comment by TS - is this really needed?
+///#include "lem4ErrorMessage.hh" -> PUT SOME LIMIT DURING WRONG UNIT CONVERSIONS
+#include "G4UnitsTable.hh"
+#include <string>
+
+//lem4TabulatedElementField2D::lem4TabulatedElementField2D(const char* filename, G4double fieldValue, G4double lenUnit, G4double fieldNormalisation, G4LogicalVolume* logVolume, G4ThreeVector positionOfTheCenter) : F04ElementField(positionOfTheCenter, logVolume),
+//  ffieldValue(fieldValue)
+
+
+///G4double lenUnit, G4double fieldNormalisation,
+
+lem4TabulatedElementField2D::lem4TabulatedElementField2D(const char* filename, const char fieldType, G4double fieldValue, G4LogicalVolume* logVolume, G4ThreeVector positionOfTheCenter) : F04ElementField(positionOfTheCenter, logVolume),
+fldType(fieldType), ffieldValue(fieldValue)
+{
+  G4cout << "\n-----------------------------------------------------------";
+
+  // The DEFAULT user-defined field units for E and B (kilovolt/mm and tesla)
+  // NOTE: Should be the same as EMfieldUnit defined in DetectorConstruction.cc!
+  if      (fldType == 'E') {G4cout << ("\n      Electric field 2D"); fUnit = "kV/mm"; fieUnit= kilovolt/mm;}
+  else if (fldType == 'B') {G4cout << ("\n      Magnetic field 2D"); fUnit = "T";     fieUnit = tesla;}
+
+  G4cout << "\n-----------------------------------------------------------" << G4endl;
+  G4cout << "\n ---> Reading the "<< fldType <<"-field map from " << filename << " ... " << G4endl;
+
+  // Open the file for reading
+  std::ifstream file( filename );
+
+  ///char buffer[256]; //not needed with file peek
+  // Ignore first blank line
+  // file.getline(buffer,256);
+
+  // Read table dimensions
+  //G4String lUnit, fUnit;
+  //G4double cFact;
+  //fieldNormalisation = cFact;
+  //lenUnit = 1*cm,
+  //fieldNormalisation = 0.00001;
+  //  101           1        1001      cm    tesla   0.00001
+  //G4double fieldNorm, lenNorm;
+  //G4cout<< lUnit << " XXXX " << fUnit << G4endl;
+  //G4cout<< "Tesla in G4 is "<< tesla << ", while kV/mm is " << kilovolt/mm << G4endl;
+
+  ///file >> nr >> nDummy >> nz >> lUnit >> fUnit >> fieldNormalisation; // Note dodgy order
+  // Read the file header
+  file >> nr >> nz >> lUnit >> fieldNormalisation;
+  // Add manually the length unit and norm. factor in the field-map file if missing!
+  
+  G4cout << "      The grid consists of [" << nr << " x " << nz << "] r and z values" << G4endl;
+ 
+  // Get the field map LENGTH unit and its value in G4 native units.
+  lenUnit = G4UnitDefinition::GetValueOf(lUnit);
+  G4cout << "      Field length unit = " << lUnit << ", in G4 native units = " << lenUnit << G4endl;
+
+  /*
+  // Get the EM field AMPLITUDE unit and its value in G4 native units.
+  // Separate the E case from B, since E presents complex units (e.g. kV/mm)
+  if (fldType == 'E') {
+  G4double volNorm, lenNorm;
+    std::string::size_type pos = fUnit.find("/");
+    std::string v_unit = fUnit.substr(0, pos); // Voltage unit
+    std::string l_unit = fUnit.substr(pos+1);  // Length  unit
+
+    volNorm = G4UnitDefinition::GetValueOf(v_unit);
+    lenNorm = G4UnitDefinition::GetValueOf(l_unit);
+    ///G4cout<< v_unit << "  " << l_unit << G4endl;
+    ///G4cout<< volNorm << "  " << lenNorm << G4endl;
+
+    fNorm = volNorm/lenNorm; // Electric field unit = [Voltage]/[Length]
+    G4cout << "      Electric field unit = " << fUnit << ", in G4 native units = " << fNorm << G4endl;
+  }
+
+  else if (fldType == 'B') {
+    fNorm   = G4UnitDefinition::GetValueOf(fUnit);
+    G4cout << "      Magnetic field unit = " << fUnit << ", in G4 native units = " << fNorm << G4endl;
+  }
+  */
+  G4cout << "      Field map normalisation factor = " << fieldNormalisation << G4endl;
+
+
+  ///fieldValue = fieldValue*fNorm/tesla; // Convert
+
+  ///fieldValue = fieldValue/fNorm; // Convert
+  //double lenUnit  = meter;
+  //double fieldUnit= tesla;
+
+  //lenNorm   = G4UnitDefinition::GetValueOf(leng_unit);
+  //lenNorm   = G4UnitDefinition::GetValueOf(lUnit);
+  //fieldNorm = G4UnitDefinition::GetValueOf(fNorm);
+
+
+  //G4double GetNewDoubleValue(const char*)
+  //fieldNorm = G4UIcmdWithADouble::SetNewDoubleValue(fNorm);
+  //fieldNorm = G4UIcmdWithADoubleAndUnit::GetNewUnitValue(fNorm); //GetNewDoubleRawValue(fNorm);
+
+
+/*
+
+  G4cout << "    Length Unit = " << leng_unit << G4endl; //lUnit
+  G4cout << "    Field  Unit = " << leng_unit << G4endl; //lUnit
+
+  G4cout << "    Length Unit = " << leng_unit << G4endl; //lUnit
+  G4cout << "    Conv.  Unit = " << lenNorm << G4endl;
+  G4cout << "    Field  Unit = " << fNorm << G4endl;
+  G4cout << "    Conv.  Unit = " << fieldNorm << G4endl;
+  G4cout << "    Norm.  Fact = " << cFact << G4endl;
+
+  */
+  /// FIELD NORMALISATION FACTOR INSIDE FIELD MAPS IS SUCH THAT (MAX. FIELD VALUE)*FNORMFACT = 1!
+  /// CHANGE SIGN TO REVERT FIELD DIRECTION! THE FIELD MAP HAS NO UNITS.
+  
+  ///G4cout << " Field set to "<< fieldValue/fNorm << " " << fUnit << G4endl; ///????
+  ///G4cout << " Field set to "<< fieldValue*fNorm << " " << fUnit << G4endl;
+  ///G4cout << "      Field set to "<< fieldValue << " " << fUnit << G4endl;
+  
+  
+  // Set up storage space for the 2D table
+  rField.resize(nr);
+  zField.resize(nr);
+  int ir, iz;
+  for (ir=0; ir<nr; ir++) {
+    rField[ir].resize(nz);
+    zField[ir].resize(nz);
+  }
+
+  // Ignore header information. All lines whose first character
+  // is '%' are considered to be part of the header.
+  do {
+     file.ignore(256, '\n');
+   } while (file.peek() == '%');
+  
+  /// Attention: The old version works only ONCE, i.e. at a STOP signal, e.g. !
+  //do {
+  //     file.getline(buffer, 256, '!');
+  //} while (buffer[0] != '!');
+
+
+  // Read in the data: [r, z, EMr, EMz]
+  double rval, zval, fr, fz;
+  for (ir=0; ir<nr; ir++) {
+    for (iz=0; iz<nz; iz++) {
+      file >> rval >> zval >> fr >> fz;
+      //G4cout << rval << " v " << zval << " v " << fr << " v " << fz << G4endl;
+      if ( ir==0 && iz==0 ) {
+	minimumr = rval * lenUnit;
+	minimumz = zval * lenUnit;
+      }
+      rField[ir][iz] = fr*fieldNormalisation;
+      zField[ir][iz] = fz*fieldNormalisation;
+    }
+  }
+  file.close();
+
+  maximumr = rval * lenUnit;
+  maximumz = zval * lenUnit;
+
+  G4String volumeName = logVolume->GetName().substr(4);
+
+  G4cout << "      ... done reading " << G4endl;
+  G4cout << "\n ---> " << fldType << "-field in volume "<< volumeName 
+         << " set to: " << fieldValue/fieUnit << " " << fUnit << G4endl;
+  G4cout << "\n ---> Assumed order: r, z, "<< fldType <<"r, "<< fldType <<"z "
+	 << "\n      Min values r, z: "
+	 << minimumr/cm << " " << minimumz/cm << " cm "
+	 << "\n      Max values r, z: "
+	 << maximumr/cm << " " << maximumz/cm << " cm" << G4endl;
+
+
+  // Should really check that the limits are not the wrong way around.
+  if (maximumr < minimumr) {Invert("r");}
+  if (maximumz < minimumz) {Invert("z");}
+  
+  if ((maximumr < minimumr) || (maximumz < minimumz)) {
+  G4cout << "\n ---> After reordering:"
+	 << "\n      Min values r, z: "
+	 << minimumr/cm << " " << minimumz/cm << " cm "
+	 << "\n      Max values r, z: "
+	 << maximumr/cm << " " << maximumz/cm << " cm " << G4endl;
+  }
+  
+  dr = maximumr - minimumr;
+  dz = maximumz - minimumz;
+
+  G4cout << "      Range of values: "
+	 << dr/cm << " cm (in r) and " << dz/cm << " cm (in z)"
+	 << "\n-----------------------------------------------------------\n" << G4endl;
+
+}
+
+
+void lem4TabulatedElementField2D::addFieldValue(const G4double point[4],
+				      G4double *field ) const
+{
+  
+  ///G4cout << "addFieldValue is being called" << G4endl;
+  G4double EMf[3];  // EM field value obtained from the field map
+  ///TS
+  ///G4cout<<"TTfileTT Global coord. ("<<point[0]/mm<<", "<<point[1]/mm<<", "<<point[2]/mm<<")."<<G4endl;
+  G4ThreeVector global(point[0],point[1],point[2]);
+  G4ThreeVector local;
+
+  local = global2local.TransformPoint(global);
+  ///TS
+  ///G4cout<<"TTfileTT Local coord. ("<<local[0]/mm<<", "<<local[1]/mm<<", "<<local[2]/mm<<")."<<G4endl;
+  ///G4cout<<"The LOGICAL volume is named "<<lvolume->GetName()<<G4endl;
+
+  double r = sqrt(local.x()*local.x()+local.y()*local.y());
+  double z = local.z(); //Modified by TS
+///  double z = fabs(local.z());
+///  double z_sign =(local.z()>0) ? 1.:-1.;
+
+//  G4cout<<"Global points= "<<point[0]<<", "<<point[1]<<", "<<point[2]<<",  Local point= "<<x<<", "<<y<<", "<<z<<G4endl;
+	 
+  // Check that the point is within the defined region
+  if ( r<maximumr && z<maximumz ) {
+    // if (evNr>evNrKriz) std::cout<<"bol som tu"<<std::endl;
+
+    // Position of given point within region, normalized to the range
+    // [0,1]
+    double rfraction = (r - minimumr) / dr;
+    double zfraction = (z - minimumz) / dz;
+
+    // Need addresses of these to pass to modf below.
+    // modf uses its second argument as an OUTPUT argument.
+    double rdindex, zdindex;
+
+    // Position of the point within the cuboid defined by the
+    // nearest surrounding tabulated points
+    double rlocal = ( modf(rfraction*(nr-1), &rdindex));
+    double zlocal = ( modf(zfraction*(nz-1), &zdindex));
+
+    // The indices of the nearest tabulated point whose coordinates
+    // are all less than those of the given point
+    int rindex = static_cast<int>(rdindex);
+    int zindex = static_cast<int>(zdindex);
+
+    //cks  The following check is necessary - even though rindex and zindex should never be out of range,
+    //     it may happen (due to some rounding error ?).  It is better to leave the check here.
+    if ((rindex<0)||(rindex>(nr-2))) {
+      std::cout<<"SERIOUS PROBLEM:  rindex out of range!  rindex="<<rindex<<"   r="<<r<<"  rfraction="<<rfraction<<std::endl;
+      if (rindex<0) rindex=0;
+      else rindex=nr-2;
+    }
+    if ((zindex<0)||(zindex>(nz-2))) {
+      std::cout<<"SERIOUS PROBLEM:  zindex out of range!  zindex="<<zindex<<"   z="<<z<<"  zfraction="<<zfraction<<std::endl;
+      if (zindex<0) zindex=0;
+      else zindex=nz-2;
+    }
+
+    //    G4cout<<"xField["<<xindex<<"]["<<zindex<<"]="<<xField[xindex  ][zindex  ]<<G4endl;
+    //    G4cout<<"zField["<<xindex<<"]["<<zindex<<"]="<<zField[xindex  ][zindex  ]<<G4endl;
+
+    // Interpolate between the neighbouring points
+    double EMfield_R =
+      rField[rindex  ][zindex  ] * (1-rlocal) * (1-zlocal) +
+      rField[rindex  ][zindex+1] * (1-rlocal) *    zlocal  +
+      rField[rindex+1][zindex  ] *    rlocal  * (1-zlocal) +
+      rField[rindex+1][zindex+1] *    rlocal  *    zlocal  ;
+    EMf[0] = (r>0) ? EMfield_R * (local.x() /r) : 0.;
+    EMf[1] = (r>0) ? EMfield_R * (local.y() /r) : 0.;
+    EMf[2] =
+      zField[rindex  ][zindex  ] * (1-rlocal) * (1-zlocal) +
+      zField[rindex  ][zindex+1] * (1-rlocal) *    zlocal  +
+      zField[rindex+1][zindex  ] *    rlocal  * (1-zlocal) +
+      zField[rindex+1][zindex+1] *    rlocal  *    zlocal  ;
+
+    EMf[0] *= ffieldValue; /// * z_sign; ///Modified by TS: Not need for FULL field map
+    EMf[1] *= ffieldValue; /// * z_sign; ///Modified by TS: Not need for FULL field map
+    EMf[2] *= ffieldValue;
+
+    ///G4cout << "The local coord. is: x_l=" << rlocal << ", z_l=" << zlocal << G4endl;
+    ///G4cout << "The coord. is: x_loc=" << local.x() << ", y_loc=" << local.y() << ", z_loc=" << local.z() << G4endl;
+
+    G4ThreeVector finalField(EMf[0],EMf[1],EMf[2]);
+    finalField = global2local.Inverse().TransformAxis(finalField);
+
+  if (fldType == 'B') {
+    field[0] += finalField.x();
+    field[1] += finalField.y();
+    field[2] += finalField.z();
+    }
+  else if (fldType == 'E') {
+    field[3] += finalField.x();
+    field[4] += finalField.y();
+    field[5] += finalField.z();
+    }
+
+  }
+  //  G4cout<<"Kamil: Field: ("<<field[0]/tesla<<","<<field[1]/tesla<<","<<field[2]/tesla<<")"<<G4endl;
+
+}
+
+
+
+G4double lem4TabulatedElementField2D::GetNominalFieldValue() {
+  return ffieldValue;
+}
+
+void lem4TabulatedElementField2D::SetNominalFieldValue(G4double newFieldValue) {
+  // Rescale the magnetic field for a new value of the magnetic field
+  ffieldValue=newFieldValue;
+
+  ///G4cout<<"lem4TabulatedElementField2D.cc:  ffieldValue changed to "<< ffieldValue << fUnit << G4endl;
+  G4cout<<"lem4TabulatedElementField2D.cc:  ffieldValue changed to "<< ffieldValue/fieUnit << fUnit << G4endl;
+  ///G4cout<<"lem4TabulatedElementField2D.cc:  ffieldValue changed to "<< ffieldValue/tesla << " T"<< G4endl;
+}
+
+void lem4TabulatedElementField2D::Invert(const char* indexToInvert) {
+  // This function inverts the indices of the field table for a given axis (r or z).
+  // It should be called in the case when the r or z coordinate in the initial
+  // field table is ordered in the decreasing order.
+  std::vector< std::vector< double > > rFieldTemp(rField);
+  std::vector< std::vector< double > > zFieldTemp(zField);
+  G4bool invertR=false;
+  G4bool invertZ=false;
+
+  G4cout<<"Check that the lem4TabulatedElementField2D::Invert() function works properly!"<<G4endl;
+  G4cout<<"It has not been tested yet!"<<G4endl;
+
+  if (strcmp(indexToInvert,"r")==0) {invertR=true; std::swap(maximumr,minimumr);}
+  if (strcmp(indexToInvert,"z")==0) {invertZ=true; std::swap(maximumz,minimumz);}
+
+  for (int ir=0; ir<nr; ir++) {
+    for (int iz=0; iz<nz; iz++) {
+      if (invertR) {
+	rField[ir][iz] = rFieldTemp[nr-1-ir][iz];
+	zField[ir][iz] = zFieldTemp[nr-1-ir][iz];
+      }
+      else if(invertZ) {
+	rField[ir][iz] = rFieldTemp[ir][nz-1-iz];
+	zField[ir][iz] = zFieldTemp[ir][nz-1-iz];
+      }
+    }
+  }
+
+
+}
+
+
+
+
+
+
+//#include "G4UIcmdWithADouble.hh"
+//#include "G4UIcmdWithADoubleAndUnit.hh"
+
+//#include <iostream>
+//using namespace std;
+
+  ///G4double G4UIcmdWithADouble::GetNewDoubleValue(const char* paramString)
+
+
+  ///**********************///
+  //char str[] ="- This, a sample string.";
+  ///char str[] ="kilovolt/mm";
+  ///char * pch;
+  ///printf ("Splitting string \"%s\" into tokens:\n",str);
+  //pch = strtok (str," ,.-");
+  ///pch = strtok (str,"*/");
+  ///while (pch != NULL)
+  ///{
+    ///printf ("%s\n",pch);
+    //pch = strtok (NULL, " ,.-");
+    ///pch = strtok (NULL,"*/");
+  ///}
+
+  ///**********************///
+
+  //char str[] ="kilovolt/mm";
+  //char * pch;
+  //printf ("Splitting string \"%s\" into tokens:\n",str);
+  //pch = strtok (str," ,.-");
+  //pch = strtok (str,"/");
+  //for (int i=0; i<2; x++) {
+  //while (pch != NULL)
+  //{
+//    printf ("%s\n",pch);
+  //  pch[]
+    //}
+    //pch = strtok (NULL,"*/");
+  //}
+
+   //int x;
+     //for(x=1; x <= 100; x++) {
+       //printf("%d ", x);
+       //}
+
+  ///**********************///
+  // Only if field is E!
+  ///char str[] = "This is a sample string kilovolt/mm";
+  ///char * pch;
+  ///printf ("Looking for the '/' character in \"%s\"...\n",str);
+  ///pch = strchr(str,'/');
+  ///while (pch!=NULL)
+  ///{
+    ///printf ("found at %d\n",pch-str+1);
+    ///pch=strchr(pch+1,'s');
+  ///}
+
+  ///**********************///
+

geant4/LEMuSR/src/lem4TabulatedElementField2Df.cc

@@ -0,0 +1,420 @@
+#include "lem4TabulatedElementField2Df.hh"
+//#include "lem4EventAction.hh"    // cks: just to get the event nr. if needed.
+#include "lem4Parameters.hh" /// Comment by TS - is this really needed?
+///#include "lem4ErrorMessage.hh" -> PUT SOME LIMIT DURING WRONG UNIT CONVERSIONS
+#include "G4UnitsTable.hh"
+#include <string>
+
+/// TS ATTENTION: Since B and E are respectively Axial and Polar vectors, their 
+///               transformation upon inversion of coordinates are DIFFERENT!!
+///               A Polar vector reverses sign when the coordinate axes are reversed.
+///               An Axial vector does not reverse sign when the coordinate axes are reversed.
+
+
+/// This version of the 2d axial field map contains an additional two-fold symmetry at z=0.
+/// Therefore the maps read by this file (ending in 1Dq) are 1/4 of the whole plane map.
+
+//lem4TabulatedElementField2D::lem4TabulatedElementField2D(const char* filename, G4double fieldValue, G4double lenUnit, G4double fieldNormalisation, G4LogicalVolume* logVolume, G4ThreeVector positionOfTheCenter) : F04ElementField(positionOfTheCenter, logVolume),
+//  ffieldValue(fieldValue)
+
+
+///G4double lenUnit, G4double fieldNormalisation,
+
+lem4TabulatedElementField2Df::lem4TabulatedElementField2Df(const char* filename, const char fieldType, G4double fieldValue, G4LogicalVolume* logVolume, G4ThreeVector positionOfTheCenter) : F04ElementField(positionOfTheCenter, logVolume),
+fldType(fieldType), ffieldValue(fieldValue)
+{
+  G4cout << "\n-----------------------------------------------------------";
+
+  // The DEFAULT user-defined field units for E and B (kilovolt/mm and tesla)
+  // NOTE: Should be the same as EMfieldUnit defined in DetectorConstruction.cc!
+  if      (fldType == 'E') {G4cout << ("\n      Electric field 2D - Folded (r, z > 0)"); fUnit = "kV/mm"; fieUnit= kilovolt/mm;}
+  else if (fldType == 'B') {G4cout << ("\n      Magnetic field 2D - Folded (r, z > 0)"); fUnit = "T";     fieUnit = tesla;}
+
+  G4cout << "\n-----------------------------------------------------------" << G4endl;
+  G4cout << "\n ---> Reading the "<< fldType <<"-field map from " << filename << " ... " << G4endl;
+
+  // Open the file for reading
+  std::ifstream file( filename );
+
+  ///char buffer[256]; //not needed with file peek
+  // Ignore first blank line
+  // file.getline(buffer,256);
+
+  // Read table dimensions
+  //G4String lUnit, fUnit;
+  //G4double cFact;
+  //fieldNormalisation = cFact;
+  //lenUnit = 1*cm,
+  //fieldNormalisation = 0.00001;
+  //  101           1        1001      cm    tesla   0.00001
+  //G4double fieldNorm, lenNorm;
+  //G4cout<< lUnit << " XXXX " << fUnit << G4endl;
+  //G4cout<< "Tesla in G4 is "<< tesla << ", while kV/mm is " << kilovolt/mm << G4endl;
+
+  ///file >> nr >> nDummy >> nz >> lUnit >> fUnit >> fieldNormalisation; // Note dodgy order
+  // Read the file header
+  file >> nr >> nz >> lUnit >> fieldNormalisation;
+  // Add manually the length unit and norm. factor in the field-map file if missing!
+  
+  G4cout << "      The grid consists of [" << nr << " x " << nz << "] r and z values" << G4endl;
+ 
+  // Get the field map LENGTH unit and its value in G4 native units.
+  lenUnit = G4UnitDefinition::GetValueOf(lUnit);
+  G4cout << "      Field length unit = " << lUnit << ", in G4 native units = " << lenUnit << G4endl;
+
+  /*
+  // Get the EM field AMPLITUDE unit and its value in G4 native units.
+  // Separate the E case from B, since E presents complex units (e.g. kV/mm)
+  if (fldType == 'E') {
+  G4double volNorm, lenNorm;
+    std::string::size_type pos = fUnit.find("/");
+    std::string v_unit = fUnit.substr(0, pos); // Voltage unit
+    std::string l_unit = fUnit.substr(pos+1);  // Length  unit
+
+    volNorm = G4UnitDefinition::GetValueOf(v_unit);
+    lenNorm = G4UnitDefinition::GetValueOf(l_unit);
+    ///G4cout<< v_unit << "  " << l_unit << G4endl;
+    ///G4cout<< volNorm << "  " << lenNorm << G4endl;
+
+    fNorm = volNorm/lenNorm; // Electric field unit = [Voltage]/[Length]
+    G4cout << "      Electric field unit = " << fUnit << ", in G4 native units = " << fNorm << G4endl;
+  }
+
+  else if (fldType == 'B') {
+    fNorm   = G4UnitDefinition::GetValueOf(fUnit);
+    G4cout << "      Magnetic field unit = " << fUnit << ", in G4 native units = " << fNorm << G4endl;
+  }
+  */
+  G4cout << "      Field map normalisation factor = " << fieldNormalisation << G4endl;
+
+
+  ///fieldValue = fieldValue*fNorm/tesla; // Convert
+
+  ///fieldValue = fieldValue/fNorm; // Convert
+  //double lenUnit  = meter;
+  //double fieldUnit= tesla;
+
+  //lenNorm   = G4UnitDefinition::GetValueOf(leng_unit);
+  //lenNorm   = G4UnitDefinition::GetValueOf(lUnit);
+  //fieldNorm = G4UnitDefinition::GetValueOf(fNorm);
+
+
+  //G4double GetNewDoubleValue(const char*)
+  //fieldNorm = G4UIcmdWithADouble::SetNewDoubleValue(fNorm);
+  //fieldNorm = G4UIcmdWithADoubleAndUnit::GetNewUnitValue(fNorm); //GetNewDoubleRawValue(fNorm);
+
+
+/*
+
+  G4cout << "    Length Unit = " << leng_unit << G4endl; //lUnit
+  G4cout << "    Field  Unit = " << leng_unit << G4endl; //lUnit
+
+  G4cout << "    Length Unit = " << leng_unit << G4endl; //lUnit
+  G4cout << "    Conv.  Unit = " << lenNorm << G4endl;
+  G4cout << "    Field  Unit = " << fNorm << G4endl;
+  G4cout << "    Conv.  Unit = " << fieldNorm << G4endl;
+  G4cout << "    Norm.  Fact = " << cFact << G4endl;
+
+  */
+  /// FIELD NORMALISATION FACTOR INSIDE FIELD MAPS IS SUCH THAT (MAX. FIELD VALUE)*FNORMFACT = 1!
+  /// CHANGE SIGN TO REVERT FIELD DIRECTION! THE FIELD MAP HAS NO UNITS.
+  
+  ///G4cout << " Field set to "<< fieldValue/fNorm << " " << fUnit << G4endl; ///????
+  ///G4cout << " Field set to "<< fieldValue*fNorm << " " << fUnit << G4endl;
+  ///G4cout << "      Field set to "<< fieldValue << " " << fUnit << G4endl;
+
+  // Set up storage space for the 2D table
+  rField.resize(nr);
+  zField.resize(nr);
+  int ir, iz;
+  for (ir=0; ir<nr; ir++) {
+    rField[ir].resize(nz);
+    zField[ir].resize(nz);
+  }
+
+  
+  // Ignore header information. All lines whose first character
+  // is '%' are considered to be part of the header.
+  do {
+     file.ignore(256, '\n');
+   } while (file.peek() == '%');
+  
+  /// ATTENTION: OLD VERSION WORKS ONLY ONCE, AT A STOP SIGNAL, E.G. !
+  //do {
+  //     file.getline(buffer, 256, '!');
+  //} while (buffer[0] != '!');
+  
+  // Read in the data: [r, z, EMr, EMz]
+  double rval,zval,fr,fz;
+  for (ir=0; ir<nr; ir++) {
+    for (iz=0; iz<nz; iz++) {
+      file >> rval >> zval >> fr >> fz;
+      if ( ir==0 && iz==0 ) {
+	minimumr = rval * lenUnit;
+	minimumz = zval * lenUnit;
+      }
+      rField[ir][iz] = fr*fieldNormalisation;
+      zField[ir][iz] = fz*fieldNormalisation;
+    }
+  }
+  file.close();
+
+  maximumr = rval * lenUnit;
+  maximumz = zval * lenUnit;
+
+  G4String volumeName = logVolume->GetName().substr(4);
+
+  G4cout << "      ... done reading " << G4endl;
+  G4cout << "\n ---> " << fldType << "-field in volume "<< volumeName 
+         << " set to: " << fieldValue/fieUnit << " " << fUnit << G4endl;
+  G4cout << "\n ---> Assumed order: r, z, "<< fldType <<"r, "<< fldType <<"z "
+	 << "\n      Min values r, z: "
+	 << minimumr/cm << " " << minimumz/cm << " cm "
+	 << "\n      Max values r, z: "
+	 << maximumr/cm << " " << maximumz/cm << " cm" << G4endl;
+
+
+  // Should really check that the limits are not the wrong way around.
+  if (maximumr < minimumr) {Invert("r");}
+  if (maximumz < minimumz) {Invert("z");}
+  
+  if ((maximumr < minimumr) || (maximumz < minimumz)) {
+  G4cout << "\n ---> After reordering:"
+	 << "\n      Min values r, z: "
+	 << minimumr/cm << " " << minimumz/cm << " cm "
+	 << "\n      Max values r, z: "
+	 << maximumr/cm << " " << maximumz/cm << " cm " << G4endl;
+  }
+  
+  dr = maximumr - minimumr;
+  dz = maximumz - minimumz;
+
+  G4cout << "      Range of values: "
+	 << dr/cm << " cm (in r) and " << dz/cm << " cm (in z)"
+	 << "\n-----------------------------------------------------------\n" << G4endl;
+
+}
+
+
+void lem4TabulatedElementField2Df::addFieldValue(const G4double point[4],
+				      G4double *field ) const
+{
+  G4double EMf[3];  // EM field value obtained from the field map
+  G4ThreeVector global(point[0],point[1],point[2]);
+  G4ThreeVector local;
+
+  local = global2local.TransformPoint(global);
+  
+  /// The folded 2D field map contains only positive r and z!
+  double r = sqrt(local.x()*local.x()+local.y()*local.y());
+  double z = fabs(local.z());
+  /// Store the z_sign and use it when extending map to negative z-values
+  double z_sign =(local.z()>0) ? 1.:-1.;
+  
+  ///double z = 0; /// An alternative approach
+  /// E is a Polar vectorn, while B is an axial one (pseudovector)! TS
+  ///if      (fldType == 'E') {z = local.z();}
+  ///else if (fldType == 'B') {z = fabs(local.z());}
+  ///G4cout<<"Global points= "<< z << G4endl; 
+ 
+//  G4cout<<"Global points= "<<point[0]<<", "<<point[1]<<", "<<point[2]<<",  Local point= "<<x<<", "<<y<<", "<<z<<G4endl;
+
+  // Check that the point is within the defined region
+  if ( r<maximumr && z<maximumz ) {
+    // if (evNr>evNrKriz) std::cout<<"bol som tu"<<std::endl;
+
+    // Position of given point within region, normalized to the range
+    // [0,1]
+    double rfraction = (r - minimumr) / dr;
+    double zfraction = (z - minimumz) / dz;
+
+    // Need addresses of these to pass to modf below.
+    // modf uses its second argument as an OUTPUT argument.
+    double rdindex, zdindex;
+
+    // Position of the point within the cuboid defined by the
+    // nearest surrounding tabulated points
+    double rlocal = ( modf(rfraction*(nr-1), &rdindex));
+    double zlocal = ( modf(zfraction*(nz-1), &zdindex));
+
+    // The indices of the nearest tabulated point whose coordinates
+    // are all less than those of the given point
+    int rindex = static_cast<int>(rdindex);
+    int zindex = static_cast<int>(zdindex);
+
+    //cks  The following check is necessary - even though rindex and zindex should never be out of range,
+    //     it may happen (due to some rounding error ?).  It is better to leave the check here.
+    if ((rindex<0)||(rindex>(nr-2))) {
+      std::cout<<"SERIOUS PROBLEM:  rindex out of range!  rindex="<<rindex<<"   r="<<r<<"  rfraction="<<rfraction<<std::endl;
+      if (rindex<0) rindex=0;
+      else rindex=nr-2;
+    }
+    if ((zindex<0)||(zindex>(nz-2))) {
+      std::cout<<"SERIOUS PROBLEM:  zindex out of range!  zindex="<<zindex<<"   z="<<z<<"  zfraction="<<zfraction<<std::endl;
+      if (zindex<0) zindex=0;
+      else zindex=nz-2;
+    }
+
+    //    G4cout<<"xField["<<xindex<<"]["<<zindex<<"]="<<xField[xindex  ][zindex  ]<<G4endl;
+    //    G4cout<<"zField["<<xindex<<"]["<<zindex<<"]="<<zField[xindex  ][zindex  ]<<G4endl;
+
+    // Interpolate between the neighbouring points
+    double EMfield_R =
+      rField[rindex  ][zindex  ] * (1-rlocal) * (1-zlocal) +
+      rField[rindex  ][zindex+1] * (1-rlocal) *    zlocal  +
+      rField[rindex+1][zindex  ] *    rlocal  * (1-zlocal) +
+      rField[rindex+1][zindex+1] *    rlocal  *    zlocal  ;
+    EMf[0] = (r>0) ? EMfield_R * (local.x() /r) : 0.;
+    EMf[1] = (r>0) ? EMfield_R * (local.y() /r) : 0.;
+    EMf[2] =
+      zField[rindex  ][zindex  ] * (1-rlocal) * (1-zlocal) +
+      zField[rindex  ][zindex+1] * (1-rlocal) *    zlocal  +
+      zField[rindex+1][zindex  ] *    rlocal  * (1-zlocal) +
+      zField[rindex+1][zindex+1] *    rlocal  *    zlocal  ;
+
+  /// E is a Polar vector, while B is an axial one (pseudovector)! TS
+  /// Hence, during an r-axis folding they transform as follows:
+  
+       if (fldType == 'B') { // Axial vector
+         EMf[0] *= ffieldValue * z_sign;
+         EMf[1] *= ffieldValue * z_sign;
+         EMf[2] *= ffieldValue;
+       }
+       else if (fldType == 'E') { // Polar vector
+         EMf[0] *= ffieldValue;
+         EMf[1] *= ffieldValue;
+         EMf[2] *= ffieldValue * z_sign;
+       }
+       
+    ///G4cout << "The local coord. is: x_l=" << rlocal << ", z_l=" << zlocal << G4endl;
+    ///G4cout << "The coord. is: x_loc=" << local.x() << ", y_loc=" << local.y() << ", z_loc=" << local.z() << G4endl;
+
+
+    G4ThreeVector finalField(EMf[0],EMf[1],EMf[2]);
+    finalField = global2local.Inverse().TransformAxis(finalField);
+
+  if (fldType == 'B') {
+    field[0] += finalField.x();
+    field[1] += finalField.y();
+    field[2] += finalField.z();
+    }
+  else if (fldType == 'E') {
+    field[3] += finalField.x();
+    field[4] += finalField.y();
+    field[5] += finalField.z();
+    }
+
+  }
+  //  G4cout<<"Kamil: Field: ("<<field[0]/tesla<<","<<field[1]/tesla<<","<<field[2]/tesla<<")"<<G4endl;
+
+}
+
+
+
+G4double lem4TabulatedElementField2Df::GetNominalFieldValue() {
+  return ffieldValue;
+}
+
+void lem4TabulatedElementField2Df::SetNominalFieldValue(G4double newFieldValue) {
+  // Rescale the magnetic field for a new value of the magnetic field
+  ffieldValue=newFieldValue;
+
+  ///G4cout<<"lem4TabulatedElementField2Df.cc:  ffieldValue changed to "<< ffieldValue << fUnit << G4endl;
+  G4cout<<"lem4TabulatedElementField2Df.cc:  ffieldValue changed to "<< ffieldValue/fieUnit << fUnit << G4endl;
+  ///G4cout<<"lem4TabulatedElementField2Df.cc:  ffieldValue changed to "<< ffieldValue/tesla << " T"<< G4endl;
+}
+
+void lem4TabulatedElementField2Df::Invert(const char* indexToInvert) {
+  // This function inverts the indices of the field table for a given axis (r or z).
+  // It should be called in the case when the r or z coordinate in the initial
+  // field table is ordered in the decreasing order.
+  std::vector< std::vector< double > > rFieldTemp(rField);
+  std::vector< std::vector< double > > zFieldTemp(zField);
+  G4bool invertR=false;
+  G4bool invertZ=false;
+
+  G4cout<<"Check that the lem4TabulatedElementField2Df::Invert() function works properly!"<<G4endl;
+  G4cout<<"It has not been tested yet!"<<G4endl;
+
+  if (strcmp(indexToInvert,"r")==0) {invertR=true; std::swap(maximumr,minimumr);}
+  if (strcmp(indexToInvert,"z")==0) {invertZ=true; std::swap(maximumz,minimumz);}
+
+  for (int ir=0; ir<nr; ir++) {
+    for (int iz=0; iz<nz; iz++) {
+      if (invertR) {
+	rField[ir][iz] = rFieldTemp[nr-1-ir][iz];
+	zField[ir][iz] = zFieldTemp[nr-1-ir][iz];
+      }
+      else if(invertZ) {
+	rField[ir][iz] = rFieldTemp[ir][nz-1-iz];
+	zField[ir][iz] = zFieldTemp[ir][nz-1-iz];
+      }
+    }
+  }
+
+
+}
+
+
+
+
+
+
+//#include "G4UIcmdWithADouble.hh"
+//#include "G4UIcmdWithADoubleAndUnit.hh"
+
+//#include <iostream>
+//using namespace std;
+
+  ///G4double G4UIcmdWithADouble::GetNewDoubleValue(const char* paramString)
+
+
+  ///**********************///
+  //char str[] ="- This, a sample string.";
+  ///char str[] ="kilovolt/mm";
+  ///char * pch;
+  ///printf ("Splitting string \"%s\" into tokens:\n",str);
+  //pch = strtok (str," ,.-");
+  ///pch = strtok (str,"*/");
+  ///while (pch != NULL)
+  ///{
+    ///printf ("%s\n",pch);
+    //pch = strtok (NULL, " ,.-");
+    ///pch = strtok (NULL,"*/");
+  ///}
+
+  ///**********************///
+
+  //char str[] ="kilovolt/mm";
+  //char * pch;
+  //printf ("Splitting string \"%s\" into tokens:\n",str);
+  //pch = strtok (str," ,.-");
+  //pch = strtok (str,"/");
+  //for (int i=0; i<2; x++) {
+  //while (pch != NULL)
+  //{
+//    printf ("%s\n",pch);
+  //  pch[]
+    //}
+    //pch = strtok (NULL,"*/");
+  //}
+
+   //int x;
+     //for(x=1; x <= 100; x++) {
+       //printf("%d ", x);
+       //}
+
+  ///**********************///
+  // Only if field is E!
+  ///char str[] = "This is a sample string kilovolt/mm";
+  ///char * pch;
+  ///printf ("Looking for the '/' character in \"%s\"...\n",str);
+  ///pch = strchr(str,'/');
+  ///while (pch!=NULL)
+  ///{
+    ///printf ("found at %d\n",pch-str+1);
+    ///pch=strchr(pch+1,'s');
+  ///}
+
+  ///**********************///
+

geant4/LEMuSR/src/lem4TabulatedElementField3D.cc

@@ -0,0 +1,327 @@
+#include "lem4TabulatedElementField3D.hh"
+#include "lem4Parameters.hh"
+
+#include "G4UnitsTable.hh"
+#include <string>
+
+lem4TabulatedElementField3D::lem4TabulatedElementField3D(const char* filename, const char fieldType, G4double fieldValue, G4LogicalVolume* logVolume, G4ThreeVector positionOfTheCenter) : F04ElementField(positionOfTheCenter, logVolume),
+fldType(fieldType), ffieldValue(fieldValue)
+{
+  G4cout << "\n-----------------------------------------------------------";
+
+  // The DEFAULT user-defined field units for E and B (kilovolt/mm and tesla)
+  // NOTE: Should be the same as EMfieldUnit defined in DetectorConstruction.cc!
+  if      (fldType == 'E') {G4cout << ("\n      Electric field 3D"); fUnit = "kV/mm"; fieUnit= kilovolt/mm;}
+  else if (fldType == 'B') {G4cout << ("\n      Magnetic field 3D"); fUnit = "T";     fieUnit = tesla;}
+
+  G4cout << "\n-----------------------------------------------------------" << G4endl;
+  G4cout << "\n ---> Reading the "<< fldType <<"-field map from " << filename << " ... " << G4endl;
+
+  // Open the file for reading
+  std::ifstream file( filename );
+  
+  // Read the first line of the file header (contains the metadata)
+  char buffer[256];
+  file.getline(buffer,256);
+  
+  //G4cout << "The first line of file "<< filename << " is:\n"<< buffer << G4endl;
+  // Read the file header
+  ///file >> nx >> ny >> nz >> lUnit >> fieldNormalisation; // OLD VERSION
+  
+  // Read the number of arguments and decide filetype - 3 or 6 columns
+  int n_arg = sscanf (buffer,"%d %d %d %s %lf %lf %lf %lf %lf %lf %lf",
+                      &nx, &ny, &nz, lUnit, &fieldNormalisation,
+                      &minimumx, &maximumx, &minimumy, &maximumy, &minimumz, &maximumz);
+  // Add manually the length unit and norm. factor in the field-map file if missing!
+
+  //printf ("The following data were read in: \n");
+  //printf ("nx = %d, ny = %d, nz = %d, Unit = %s, Norm = %f,\n minx = %f, maxx = %f, miny = %f, maxy = %f, minz = %f, maxz = %f\n",nx,ny,nz,lUnit,fieldNormalisation,minimumx, maximumx, minimumy, maximumy, minimumz, maximumz);
+  ///printf ("nx = %d, ny = %d, nz = %d, Unit = %s, Norm = %f,\n minx = %f\n",nx,ny,nz,lUnit,fieldNormalisation,minimumx);
+  //printf ("Number of args read: %d\n", n_arg);
+
+  G4cout << "      The grid consists of [" << nx << " x " << ny << " x " << nz << "] x, y, z values" << G4endl;
+ 
+  // Get the field map LENGTH unit and its value in G4 native units.
+  lenUnit = G4UnitDefinition::GetValueOf(lUnit);
+  G4cout << "      Field length unit = " << lUnit << ", in G4 native units = " << lenUnit << G4endl;
+  G4cout << "      Field map normalisation factor = " << fieldNormalisation << G4endl;
+
+  // Set up storage space for the 3D table: notice the order!
+  xField.resize(nx);
+  yField.resize(nx);
+  zField.resize(nx);
+  int ix, iy, iz;
+  for (ix=0; ix<nx; ix++) {
+    xField[ix].resize(ny);
+    yField[ix].resize(ny);
+    zField[ix].resize(ny);
+    for (iy=0; iy<ny; iy++) {
+      xField[ix][iy].resize(nz);
+      yField[ix][iy].resize(nz);
+      zField[ix][iy].resize(nz);
+    }
+  }
+
+  
+  // Ignore header information. All lines whose first character
+  // is '%' are considered to be part of the header.
+  do {
+     file.ignore(256, '\n');
+   } while (file.peek() == '%');
+  
+  /// NOTE: The old version works only ONCE, i.e. at a STOP signal, e.g. !
+  //do {
+  //     file.getline(buffer, 256, '!');
+  //} while (buffer[0] != '!');
+
+  
+  // Read in the data: [x, y, z, EMx, EMy, EMz] or [EMx, EMy, EMz]
+  double xval, yval, zval; // Coordinates
+  double fx,   fy,   fz;   // Field values
+  //std::ofstream fileout("three_columns.txt"); // Useful for rewriting files
+  
+  for (ix=0; ix<nx; ix++) { // notice the order!
+    for (iy=0; iy<ny; iy++) {
+      for (iz=0; iz<nz; iz++) {
+        
+	if (n_arg == 5) { // Read BOTH coordinates and field values
+	  file >> xval >> yval >> zval >> fx >> fy >> fz;
+	  //fileout << fx <<"  \t"<< fy << "  \t"<< fz << std::endl; // for rewriting files
+	  if ( ix==0 && iy==0 && iz==0 ) {
+            minimumx = xval * lenUnit;
+            minimumy = yval * lenUnit;
+            minimumz = zval * lenUnit;
+          }
+	}
+	else if (n_arg == 11) {
+	  file >> fx >> fy >> fz; // Read ONLY field values
+	}
+
+        xField[ix][iy][iz] = fx*fieldNormalisation;
+        yField[ix][iy][iz] = fy*fieldNormalisation;
+        zField[ix][iy][iz] = fz*fieldNormalisation;
+      }
+    }
+  }
+  //fileout.close(); // for rewriting files
+  file.close();
+
+  if (n_arg == 5) { 
+    maximumx = xval * lenUnit;
+    maximumy = yval * lenUnit;
+    maximumz = zval * lenUnit;
+  }
+  else if (n_arg == 11) { 
+    minimumx = minimumx * lenUnit;
+    minimumy = minimumy * lenUnit;
+    minimumz = minimumz * lenUnit;
+    maximumx = maximumx * lenUnit;
+    maximumy = maximumy * lenUnit;
+    maximumz = maximumz * lenUnit;
+  }
+
+    
+  G4String volumeName = logVolume->GetName().substr(4);
+  
+  G4cout << "      ... done reading " << G4endl;
+  G4cout << "\n ---> " << fldType << "-field in volume "<< volumeName 
+         << " set to: " << fieldValue/fieUnit << " " << fUnit << G4endl;
+         if (n_arg == 5) { G4cout << "\n ---> Assumed order (6 col.):  x, y, z, ";}
+   else if (n_arg == 11) { G4cout << "\n ---> Assumed order (3 col.):  ";}
+  G4cout << fldType <<"x, "<< fldType <<"y, "<< fldType <<"z "
+	 << "\n      Min values x, y, z: "
+	 << minimumx/cm << " " << minimumy/cm << " " << minimumz/cm << " cm "
+	 << "\n      Max values x, y, z: "
+	 << maximumx/cm << " " << maximumy/cm << " " << maximumz/cm << " cm" << G4endl;
+
+  // Should really check that the limits are not the wrong way around.
+  if (maximumx < minimumx) {Invert("x");}
+  if (maximumy < minimumy) {Invert("y");}
+  if (maximumz < minimumz) {Invert("z");}
+
+  if ((maximumx < minimumx) || (maximumy < minimumy)|| (maximumz < minimumz)) {
+    G4cout << "\n ---> After reordering:"
+	 << "\n      Min values x, y, z: "
+	 << minimumx/cm << " " << minimumy/cm << " " << minimumz/cm << " cm "
+	 << "\n      Max values x, y, z: "
+	 << maximumx/cm << " " << maximumy/cm << " " << maximumz/cm << " cm " << G4endl;
+  }
+
+  dx = maximumx - minimumx;
+  dy = maximumy - minimumy;
+  dz = maximumz - minimumz;
+
+  G4cout << "      Range of values: "
+  	 << dx/cm << " cm (in x), " << dy/cm << " cm (in y) and " << dz/cm << " cm (in z)."
+  	 << "\n-----------------------------------------------------------\n" << G4endl;
+
+}
+
+void lem4TabulatedElementField3D::addFieldValue(const G4double point[4],
+				      G4double *field ) const
+{
+  G4double EMf[3];  // EM field value obtained from the field map
+
+  G4ThreeVector global(point[0],point[1],point[2]);
+  G4ThreeVector local;
+
+  local = global2local.TransformPoint(global);
+
+  double x = local.x();
+  double y = local.y();
+  double z = local.z();
+
+  //  G4cout<<"Global points= "<<point[0]<<", "<<point[1]<<", "<<point[2]<<",  Local point= "<<x<<", "<<y<<", "<<z<<G4endl;
+
+
+  // Check that the point is within the defined region
+  if ( x>minimumx && x<maximumx &&
+       y>minimumy && y<maximumy &&
+       z>minimumz && z<maximumz ) {
+
+    // Position of given point within region, normalized to the range
+    // [0,1]
+    double xfraction = (x - minimumx) / dx;
+    double yfraction = (y - minimumy) / dy;
+    double zfraction = (z - minimumz) / dz;
+
+    // Need addresses of these to pass to modf below.
+    // modf uses its second argument as an OUTPUT argument.
+    double xdindex, ydindex, zdindex;
+
+    // Position of the point within the cuboid defined by the
+    // nearest surrounding tabulated points
+    double xlocal = ( modf(xfraction*(nx-1), &xdindex));
+    double ylocal = ( modf(yfraction*(ny-1), &ydindex));
+    double zlocal = ( modf(zfraction*(nz-1), &zdindex));
+
+    // The indices of the nearest tabulated point whose coordinates
+    // are all less than those of the given point
+    int xindex = static_cast<int>(xdindex);
+    int yindex = static_cast<int>(ydindex);
+    int zindex = static_cast<int>(zdindex);
+
+    //cks  The following check is necessary - even though xindex and zindex should never be out of range,
+    //     it may happen (due to some rounding error ?).  It is better to leave the check here.
+    if ((xindex<0)||(xindex>(nx-2))) {
+      std::cout<<"SERIOUS PROBLEM:  xindex out of range!  xindex="<<xindex<<"   x="<<x<<"  xfraction="<<xfraction<<std::endl;
+      if (xindex<0) xindex=0;
+      else xindex=nx-2;
+    }
+    if ((yindex<0)||(yindex>(ny-2))) {
+      std::cout<<"SERIOUS PROBLEM:  yindex out of range!  yindex="<<yindex<<"   y="<<y<<"  yfraction="<<yfraction<<std::endl;
+      if (yindex<0) yindex=0;
+      else yindex=ny-2;
+    }
+    if ((zindex<0)||(zindex>(nz-2))) {
+      std::cout<<"SERIOUS PROBLEM:  zindex out of range!  zindex="<<zindex<<"   z="<<z<<"  zfraction="<<zfraction<<std::endl;
+      if (zindex<0) zindex=0;
+      else zindex=nz-2;
+    }
+
+        // Full 3-dimensional version
+    EMf[0] =
+      xField[xindex  ][yindex  ][zindex  ] * (1-xlocal) * (1-ylocal) * (1-zlocal) +
+      xField[xindex  ][yindex  ][zindex+1] * (1-xlocal) * (1-ylocal) *    zlocal  +
+      xField[xindex  ][yindex+1][zindex  ] * (1-xlocal) *    ylocal  * (1-zlocal) +
+      xField[xindex  ][yindex+1][zindex+1] * (1-xlocal) *    ylocal  *    zlocal  +
+      xField[xindex+1][yindex  ][zindex  ] *    xlocal  * (1-ylocal) * (1-zlocal) +
+      xField[xindex+1][yindex  ][zindex+1] *    xlocal  * (1-ylocal) *    zlocal  +
+      xField[xindex+1][yindex+1][zindex  ] *    xlocal  *    ylocal  * (1-zlocal) +
+      xField[xindex+1][yindex+1][zindex+1] *    xlocal  *    ylocal  *    zlocal ;
+    EMf[1] =
+      yField[xindex  ][yindex  ][zindex  ] * (1-xlocal) * (1-ylocal) * (1-zlocal) +
+      yField[xindex  ][yindex  ][zindex+1] * (1-xlocal) * (1-ylocal) *    zlocal  +
+      yField[xindex  ][yindex+1][zindex  ] * (1-xlocal) *    ylocal  * (1-zlocal) +
+      yField[xindex  ][yindex+1][zindex+1] * (1-xlocal) *    ylocal  *    zlocal  +
+      yField[xindex+1][yindex  ][zindex  ] *    xlocal  * (1-ylocal) * (1-zlocal) +
+      yField[xindex+1][yindex  ][zindex+1] *    xlocal  * (1-ylocal) *    zlocal  +
+      yField[xindex+1][yindex+1][zindex  ] *    xlocal  *    ylocal  * (1-zlocal) +
+      yField[xindex+1][yindex+1][zindex+1] *    xlocal  *    ylocal  *    zlocal ;
+    EMf[2] =
+      zField[xindex  ][yindex  ][zindex  ] * (1-xlocal) * (1-ylocal) * (1-zlocal) +
+      zField[xindex  ][yindex  ][zindex+1] * (1-xlocal) * (1-ylocal) *    zlocal  +
+      zField[xindex  ][yindex+1][zindex  ] * (1-xlocal) *    ylocal  * (1-zlocal) +
+      zField[xindex  ][yindex+1][zindex+1] * (1-xlocal) *    ylocal  *    zlocal  +
+      zField[xindex+1][yindex  ][zindex  ] *    xlocal  * (1-ylocal) * (1-zlocal) +
+      zField[xindex+1][yindex  ][zindex+1] *    xlocal  * (1-ylocal) *    zlocal  +
+      zField[xindex+1][yindex+1][zindex  ] *    xlocal  *    ylocal  * (1-zlocal) +
+      zField[xindex+1][yindex+1][zindex+1] *    xlocal  *    ylocal  *    zlocal ;
+
+    EMf[0] *= ffieldValue;
+    EMf[1] *= ffieldValue;
+    EMf[2] *= ffieldValue;
+
+    G4ThreeVector finalField(EMf[0],EMf[1],EMf[2]);
+    finalField = global2local.Inverse().TransformAxis(finalField);
+
+  if (fldType == 'B') {
+    field[0] += finalField.x();
+    field[1] += finalField.y();
+    field[2] += finalField.z();
+    }
+  else if (fldType == 'E') {
+    field[3] += finalField.x();
+    field[4] += finalField.y();
+    field[5] += finalField.z();
+    }
+
+  }
+  //  G4cout<<"Kamil: Field: ("<<field[0]/tesla<<","<<field[1]/tesla<<","<<field[2]/tesla<<")"<<G4endl;
+
+}
+
+
+
+G4double lem4TabulatedElementField3D::GetNominalFieldValue() {
+  return ffieldValue;
+}
+
+void lem4TabulatedElementField3D::SetNominalFieldValue(G4double newFieldValue) {
+  //  // Rescale the magnetic field for a new value of the magnetic field
+  ffieldValue=newFieldValue;
+  G4cout<<"lem4TabulatedElementField3D.cc:  ffieldValue changed to="<< ffieldValue/fieUnit << fUnit << G4endl;
+}
+
+void lem4TabulatedElementField3D::Invert(const char* indexToInvert) {
+  // This function inverts the indices of the field table for a given axis (x or z).
+  // It should be called in the case when the x or z coordinate in the initial
+  // field table is ordered in the decreasing order.
+  std::vector< std::vector< std::vector< double > > > xFieldTemp(xField);
+  std::vector< std::vector< std::vector< double > > > yFieldTemp(yField);
+  std::vector< std::vector< std::vector< double > > > zFieldTemp(zField);
+  G4bool invertX=false;
+  G4bool invertY=false;
+  G4bool invertZ=false;
+
+  G4cout<<"Check that the lem4TabulatedElementField3D::Invert() function works properly!"<<G4endl;
+  G4cout<<"It has not been tested yet!"<<G4endl;
+
+  if (strcmp(indexToInvert,"x")==0) {invertX=true; std::swap(maximumx,minimumx);}
+  if (strcmp(indexToInvert,"y")==0) {invertY=true; std::swap(maximumx,minimumx);}
+  if (strcmp(indexToInvert,"z")==0) {invertZ=true; std::swap(maximumz,minimumz);}
+
+  for (int ix=0; ix<nx; ix++) {
+    for (int iy=0; iy<ny; iy++) {
+      for (int iz=0; iz<nz; iz++) {
+	if (invertX) {
+	  xField[ix][iy][iz] = xFieldTemp[nx-1-ix][iy][iz];
+	  yField[ix][iy][iz] = yFieldTemp[nx-1-ix][iy][iz];
+	  zField[ix][iy][iz] = zFieldTemp[nx-1-ix][iy][iz];
+	}
+	else if(invertY) {
+	  xField[ix][iy][iz] = xFieldTemp[ix][ny-1-iy][iz];
+	  yField[ix][iy][iz] = yFieldTemp[ix][ny-1-iy][iz];
+	  zField[ix][iy][iz] = zFieldTemp[ix][ny-1-iy][iz];
+	}
+	else if(invertZ) {
+	  xField[ix][iy][iz] = xFieldTemp[ix][iy][nz-1-iz];
+	  yField[ix][iy][iz] = yFieldTemp[ix][iy][nz-1-iz];
+	  zField[ix][iy][iz] = zFieldTemp[ix][iy][nz-1-iz];
+	}
+      }
+    }
+  }
+
+
+}

geant4/LEMuSR/src/lem4TabulatedField2D.cc

@@ -0,0 +1,229 @@
+#include "lem4TabulatedField2D.hh"
+//#include "lem4EventAction.hh"    // cks: just to get the event nr. if needed.
+#include "lem4Parameters.hh"
+
+
+lem4TabulatedField2D* lem4TabulatedField2D::pointerToTabulatedField2D=NULL;
+lem4TabulatedField2D* lem4TabulatedField2D::GetInstance() {
+  return pointerToTabulatedField2D;
+}
+
+lem4TabulatedField2D::lem4TabulatedField2D( const char* filename, double fieldValue, double lenUnit, double fieldNormalisation ) 
+  :ffieldValue(fieldValue),invertX(false),invertZ(false)
+{    
+  pointerToTabulatedField2D=this;
+  G4cout << "pointerToTabulatedField2D="<<pointerToTabulatedField2D<<G4endl;
+  //  double lenUnit= meter;
+  //  double fieldUnit= tesla; 
+  G4cout << "\n-----------------------------------------------------------"
+	 << "\n      Magnetic field"
+	 << "\n-----------------------------------------------------------"
+         << G4endl;
+  G4cout << "  tesla="<<tesla<<G4endl;
+  G4cout << " Field set to "<< fieldValue/tesla << " T"<< G4endl;  
+  G4cout << "\n ---> " "Reading the field grid from " << filename << " ... " << G4endl; 
+  positionOffset[0]=0;
+  positionOffset[1]=0;
+  positionOffset[2]=0;
+  positionOffset[3]=0;
+  std::ifstream file( filename ); // Open the file for reading.
+  
+  // Ignore first blank line
+  char buffer[256];
+  //  file.getline(buffer,256);
+  
+  // Read table dimensions 
+  int nDummy;
+  file >> nx >> nDummy >> nz; // Note dodgy order
+
+  G4cout << "  [ Number of values x,z: " 
+	 << nx << " " << nz << " ] "
+	 << G4endl;
+
+  // Set up storage space for table
+  xField.resize( nx );
+  zField.resize( nx );
+  int ix, iz;
+  for (ix=0; ix<nx; ix++) {
+    xField[ix].resize(nz);
+    zField[ix].resize(nz);
+  }
+  
+  // Ignore other header information    
+  // The first line whose second character is '0' is considered to
+  // be the last line of the header.
+  do {
+    file.getline(buffer,256);
+  } while ( buffer[1]!='0');
+  
+  // Read in the data
+  double xval,yval,zval,bx,bz;
+  double permeability; // Not used in this example.
+  for (ix=0; ix<nx; ix++) {
+    for (iz=0; iz<nz; iz++) {
+      file >> xval >> yval >> zval >> bx >> bz >> permeability;
+      if ( ix==0 && iz==0 ) {
+	minx = xval * lenUnit;
+	minz = zval * lenUnit;
+      }
+      //xField[ix][iy][iz] = bx * fieldUnit * fieldValue;
+      //zField[ix][iy][iz] = bz * fieldUnit * fieldValue;
+      //        xField[ix][iy][iz] = bx * fieldValue;
+      //        zField[ix][iy][iz] = bz * fieldValue;
+      xField[ix][iz] = bx*fieldNormalisation;
+      zField[ix][iz] = bz*fieldNormalisation;
+    }
+  }
+  file.close();
+
+  maxx = xval * lenUnit;
+  maxz = zval * lenUnit;
+
+  G4cout << "\n ---> ... done reading " << G4endl;
+
+  // G4cout << " Read values of field from file " << filename << G4endl; 
+  G4cout << " ---> assumed the order:  x, y, z, Bx, Bz "
+	 << "\n ---> Min values x,y,z: " 
+	 << minx/cm << " " << minz/cm << " cm "
+	 << "\n ---> Max values x,y,z: " 
+	 << maxx/cm << " " << maxz/cm << " cm " << G4endl;
+
+
+  // Should really check that the limits are not the wrong way around.
+  if (maxx < minx) {std::swap(maxx,minx); invertX = true;} 
+  if (maxz < minz) {std::swap(maxz,minz); invertZ = true;} 
+  G4cout << "\nAfter reordering if neccesary"  
+	 << "\n ---> Min values x,y,z: " 
+	 << minx/cm << " " << minz/cm << " cm "
+	 << " \n ---> Max values x,y,z: " 
+	 << maxx/cm << " " << maxz/cm << " cm ";
+
+  dx = maxx - minx;
+  dz = maxz - minz;
+  G4cout << "\n ---> Dif values x,z (range): " 
+	 << dx/cm << " " << dz/cm << " cm in z "
+	 << "\n-----------------------------------------------------------" << G4endl;
+}
+
+void lem4TabulatedField2D::GetFieldValue(const double point[4],
+				      double *Bfield ) const
+{
+  //  G4cout<<"Tabulated: Field requested at point ("<<point[0]<<","<<point[1]<<","<<point[2]<<")"<<G4endl;
+  //  lem4EventAction* myEventAction= lem4EventAction::GetInstance();
+  //  G4int evNr=myEventAction->GetLatestEventNr();
+  //  G4int evNrKriz=6795;  //457;  //14250
+  //  if (evNr==evNrKriz) {
+  //    std::cout<<"evNr="<<evNr<<std::endl;
+  //    printf ("for point= %f %f %f   B= %10.10f %10.10f %10.10f \n", 
+  //    	    point[0],point[1],point[2],Bfield[0]/tesla,Bfield[1]/tesla,Bfield[2]/tesla);
+  //  }
+  Bfield[0]=0.; Bfield[1]=0.; Bfield[2]=0.; 
+
+  double pppoint[4];
+  pppoint[0]=point[0]+positionOffset[0];
+  pppoint[1]=point[1]+positionOffset[1];
+  pppoint[2]=point[2]+positionOffset[2];
+  pppoint[3]=point[3]+positionOffset[3];
+  double x = sqrt(pppoint[0]*pppoint[0]+pppoint[1]*pppoint[1]);
+  double z = fabs(pppoint[2]);
+  double z_sign = (pppoint[2]>0) ? 1.:-1.;
+  //if (evNr==evNrKriz) std::cout<<"x ="<<x<<"   maxx="<<maxx<<std::endl;
+
+  // Check that the point is within the defined region 
+  if ( x<maxx && z<maxz ) {
+    // if (evNr>evNrKriz) std::cout<<"bol som tu"<<std::endl;
+    
+    // Position of given point within region, normalized to the range
+    // [0,1]
+    double xfraction = (x - minx) / dx;
+    double zfraction = (z - minz) / dz;
+
+    if (invertX) { xfraction = 1 - xfraction;}
+    if (invertZ) { zfraction = 1 - zfraction;}
+    // Need addresses of these to pass to modf below.
+    // modf uses its second argument as an OUTPUT argument.
+    double xdindex, zdindex;
+    
+    // Position of the point within the cuboid defined by the
+    // nearest surrounding tabulated points
+    double xlocal = ( modf(xfraction*(nx-1), &xdindex));
+    double zlocal = ( modf(zfraction*(nz-1), &zdindex));
+    
+    // The indices of the nearest tabulated point whose coordinates
+    // are all less than those of the given point
+    int xindex = static_cast<int>(xdindex);
+    int zindex = static_cast<int>(zdindex);
+
+    //cks  The following check is necessary - even though xindex and zindex should never be out of range,
+    //     it may happen (due to some rounding error ?).  It is better to leave the check here.
+    if ((xindex<0)||(xindex>(nx-2))) {
+      std::cout<<"SERIOUS PROBLEM:  xindex out of range!  xindex="<<xindex<<"   x="<<x<<"  xfraction="<<xfraction<<std::endl;
+      if (xindex<0) xindex=0;
+      else xindex=nx-2;
+    }
+    if ((zindex<0)||(zindex>(nz-2))) {
+      std::cout<<"SERIOUS PROBLEM:  zindex out of range!  zindex="<<zindex<<"   z="<<z<<"  zfraction="<<zfraction<<std::endl;
+      if (zindex<0) zindex=0;
+      else zindex=nz-2;
+    }
+
+    // Find out whether the muon is decaying.  If yes, calculate the field in
+    // more detail (more precisely).
+    //         The following commented piece of code was not reliable (was indicating the
+    //         proccess "DecayWithSpin" even if there was none).
+    //    G4String processName = G4RunManagerKernel::GetRunManagerKernel()->
+    //   //    G4String processName = G4EventManager::GetEventManager()->
+    //                      GetTrackingManager()->GetTrack()->GetStep()->
+    //                      GetPostStepPoint()->GetProcessDefinedStep()->
+    //                      GetProcessName();
+    //         The following seems to be OK:
+    //    if (lem4Parameters::field_DecayWithSpin) {
+    //      lem4Parameters::field_DecayWithSpin=false;
+    //
+    //    }
+    //    else {  // Muon is not decaying, use a fast method of interpolation.
+      // Interpolate between the neighbouring points
+      double Bfield_R =
+	xField[xindex  ][zindex  ] * (1-xlocal) * (1-zlocal) +
+	xField[xindex  ][zindex+1] * (1-xlocal) *    zlocal  +
+	xField[xindex+1][zindex  ] *    xlocal  * (1-zlocal) +
+	xField[xindex+1][zindex+1] *    xlocal  *    zlocal  ;
+      Bfield[0] = (x>0) ? Bfield_R * (pppoint[0]/x) : 0.;
+      Bfield[1] = (x>0) ? Bfield_R * (pppoint[1]/x) : 0.;
+      Bfield[2] =
+	zField[xindex  ][zindex  ] * (1-xlocal) * (1-zlocal) +
+	zField[xindex  ][zindex+1] * (1-xlocal) *    zlocal  +
+	zField[xindex+1][zindex  ] *    xlocal  * (1-zlocal) +
+	zField[xindex+1][zindex+1] *    xlocal  *    zlocal  ;
+      
+      Bfield[0] = Bfield[0] * ffieldValue * z_sign;
+      Bfield[1] = Bfield[1] * ffieldValue * z_sign;
+      Bfield[2] = Bfield[2] * ffieldValue;
+      //    } 
+  }
+  
+  // Set some small field if field is almost zero (to avoid internal problems of Geant).
+  if (sqrt(Bfield[0]*Bfield[0]+Bfield[1]*Bfield[1]+Bfield[2]*Bfield[2])<0.00001*tesla) {
+    //    if (evNr>evNrKriz) std::cout<<"bol som tuna"<<std::endl;
+    //    Bfield[0] = 0.0;
+    //    Bfield[1] = 0.0;
+    //    Bfield[2] = Bfield[2] + 0.00001*tesla;
+    Bfield[2] = 0.00001*tesla;
+  }
+  //  Print the field (for debugging)
+  //  if ((point[2]>-0.1*mm)&&(point[2]<0.1*mm)) {
+  //    printf ("for point= %f %f %f   B= %10.10f %10.10f %10.10f \n", 
+  //    	    point[0],point[1],point[2],Bfield[0]/tesla,Bfield[1]/tesla,Bfield[2]/tesla);
+  //  }
+  //  if (evNr>evNrKriz) std::cout<<"this is the end"<<std::endl;
+}
+
+G4double lem4TabulatedField2D::GetFieldSetValue() {
+  return ffieldValue;
+}
+
+void lem4TabulatedField2D::SetFieldValue(double newFieldValue) {
+  //  // Rescale the magnetic field for a new value of the magnetic field
+  ffieldValue=newFieldValue;
+  G4cout<<"lem4TabulatedField2D.cc:   ffieldValue changed to="<< ffieldValue/tesla<<"T "<<G4endl;
+}

geant4/LEMuSR/src/lem4TabulatedField3D.cc

@@ -0,0 +1,251 @@
+#include "lem4TabulatedField3D.hh"
+
+
+lem4TabulatedField3D* lem4TabulatedField3D::pointerToTabulatedField3D=NULL;
+lem4TabulatedField3D* lem4TabulatedField3D::GetInstance() {
+  return pointerToTabulatedField3D;
+}
+
+
+lem4TabulatedField3D::lem4TabulatedField3D( const char* filename, double fieldValue ) 
+  :ffieldValue(fieldValue),invertX(false),invertY(false),invertZ(false)
+{    
+  pointerToTabulatedField3D=this;
+  double lenUnit= meter;
+  //  double fieldUnit= tesla; 
+  G4cout << "\n-----------------------------------------------------------"
+	 << "\n      Magnetic field"
+	 << "\n-----------------------------------------------------------"
+         << endl;
+  G4cout << "  tesla="<<tesla<<G4endl;
+  G4cout << " Field set to "<< fieldValue/tesla << " T"<< G4endl;  
+  G4cout << "\n ---> " "Reading the field grid from " << filename << " ... " << G4endl; 
+  ifstream file( filename ); // Open the file for reading.
+  
+  // Ignore first blank line
+  char buffer[256];
+  file.getline(buffer,256);
+  
+  // Read table dimensions 
+  file >> nx >> ny >> nz; // Note dodgy order
+
+  G4cout << "  [ Number of values x,y,z: " 
+	 << nx << " " << ny << " " << nz << " ] "
+	 << endl;
+
+  // Set up storage space for table
+  xField.resize( nx );
+  yField.resize( nx );
+  zField.resize( nx );
+  int ix, iy, iz;
+  for (ix=0; ix<nx; ix++) {
+    xField[ix].resize(ny);
+    yField[ix].resize(ny);
+    zField[ix].resize(ny);
+    for (iy=0; iy<ny; iy++) {
+      xField[ix][iy].resize(nz);
+      yField[ix][iy].resize(nz);
+      zField[ix][iy].resize(nz);
+    }
+  }
+  
+  // Ignore other header information    
+  // The first line whose second character is '0' is considered to
+  // be the last line of the header.
+  do {
+    file.getline(buffer,256);
+  } while ( buffer[1]!='0');
+  
+  // Read in the data
+  double xval,yval,zval,bx,by,bz;
+  double permeability; // Not used in this example.
+  for (ix=0; ix<nx; ix++) {
+    for (iy=0; iy<ny; iy++) {
+      for (iz=0; iz<nz; iz++) {
+        file >> xval >> yval >> zval >> bx >> by >> bz >> permeability;
+        if ( ix==0 && iy==0 && iz==0 ) {
+          minx = xval * lenUnit;
+          miny = yval * lenUnit;
+          minz = zval * lenUnit;
+        }
+	//xField[ix][iy][iz] = bx * fieldUnit * fieldValue;
+        //yField[ix][iy][iz] = by * fieldUnit * fieldValue;
+        //zField[ix][iy][iz] = bz * fieldUnit * fieldValue;
+	//        xField[ix][iy][iz] = bx * fieldValue;
+	//        yField[ix][iy][iz] = by * fieldValue;
+	//        zField[ix][iy][iz] = bz * fieldValue;
+        xField[ix][iy][iz] = bx;
+        yField[ix][iy][iz] = by;
+        zField[ix][iy][iz] = bz;
+      }
+    }
+  }
+  file.close();
+
+  maxx = xval * lenUnit;
+  maxy = yval * lenUnit;
+  maxz = zval * lenUnit;
+
+  G4cout << "\n ---> ... done reading " << endl;
+
+  // G4cout << " Read values of field from file " << filename << endl; 
+  G4cout << " ---> assumed the order:  x, y, z, Bx, By, Bz "
+	 << "\n ---> Min values x,y,z: " 
+	 << minx/cm << " " << miny/cm << " " << minz/cm << " cm "
+	 << "\n ---> Max values x,y,z: " 
+	 << maxx/cm << " " << maxy/cm << " " << maxz/cm << " cm " << endl;
+
+
+  // Should really check that the limits are not the wrong way around.
+  if (maxx < minx) {swap(maxx,minx); invertX = true;} 
+  if (maxy < miny) {swap(maxy,miny); invertY = true;} 
+  if (maxz < minz) {swap(maxz,minz); invertZ = true;} 
+  G4cout << "\nAfter reordering if neccesary"  
+	 << "\n ---> Min values x,y,z: " 
+	 << minx/cm << " " << miny/cm << " " << minz/cm << " cm "
+	 << " \n ---> Max values x,y,z: " 
+	 << maxx/cm << " " << maxy/cm << " " << maxz/cm << " cm ";
+
+  dx = maxx - minx;
+  dy = maxy - miny;
+  dz = maxz - minz;
+  G4cout << "\n ---> Dif values x,y,z (range): " 
+	 << dx/cm << " " << dy/cm << " " << dz/cm << " cm in z "
+	 << "\n-----------------------------------------------------------" << endl;
+}
+
+void lem4TabulatedField3D::GetFieldValue(const double point[4],
+				      double *Bfield ) const
+{
+  Bfield[0]=0.; Bfield[1]=0.; Bfield[2]=0.; 
+
+  double x = point[0]+positionOffset[0];
+  double y = point[1]+positionOffset[1];
+  double z = point[2]+positionOffset[2];
+
+
+  // Check that the point is within the defined region 
+  if ( x>minx && x<maxx &&
+       y>miny && y<maxy && 
+       z>minz && z<maxz ) {
+    
+    // Position of given point within region, normalized to the range
+    // [0,1]
+    double xfraction = (x - minx) / dx;
+    double yfraction = (y - miny) / dy; 
+    double zfraction = (z - minz) / dz;
+
+    if (invertX) { xfraction = 1 - xfraction;}
+    if (invertY) { yfraction = 1 - yfraction;}
+    if (invertZ) { zfraction = 1 - zfraction;}
+
+    // Need addresses of these to pass to modf below.
+    // modf uses its second argument as an OUTPUT argument.
+    double xdindex, ydindex, zdindex;
+    
+    // Position of the point within the cuboid defined by the
+    // nearest surrounding tabulated points
+    double xlocal = ( modf(xfraction*(nx-1), &xdindex));
+    double ylocal = ( modf(yfraction*(ny-1), &ydindex));
+    double zlocal = ( modf(zfraction*(nz-1), &zdindex));
+    
+    // The indices of the nearest tabulated point whose coordinates
+    // are all less than those of the given point
+    int xindex = static_cast<int>(xdindex);
+    int yindex = static_cast<int>(ydindex);
+    int zindex = static_cast<int>(zdindex);
+    
+    //cks  The following check is necessary - even though xindex and zindex should never be out of range,
+    //     it may happen (due to some rounding error ?).  It is better to leave the check here.
+    if ((xindex<0)||(xindex>(nx-2))) {
+      std::cout<<"SERIOUS PROBLEM:  xindex out of range!  xindex="<<xindex<<"   x="<<x<<"  xfraction="<<xfraction<<std::endl;
+      if (xindex<0) xindex=0;
+      else xindex=nx-2;
+    }
+    if ((yindex<0)||(yindex>(ny-2))) {
+      std::cout<<"SERIOUS PROBLEM:  yindex out of range!  yindex="<<yindex<<"   y="<<y<<"  yfraction="<<yfraction<<std::endl;
+      if (yindex<0) yindex=0;
+      else yindex=ny-2;
+    }
+    if ((zindex<0)||(zindex>(nz-2))) {
+      std::cout<<"SERIOUS PROBLEM:  zindex out of range!  zindex="<<zindex<<"   z="<<z<<"  zfraction="<<zfraction<<std::endl;
+      if (zindex<0) zindex=0;
+      else zindex=nz-2;
+    }
+
+#ifdef DEBUG_INTERPOLATING_FIELD
+    G4cout << "Local x,y,z: " << xlocal << " " << ylocal << " " << zlocal << endl;
+    G4cout << "Index x,y,z: " << xindex << " " << yindex << " " << zindex << endl;
+    double valx0z0, mulx0z0, valx1z0, mulx1z0;
+    double valx0z1, mulx0z1, valx1z1, mulx1z1;
+    valx0z0= table[xindex  ][0][zindex];  mulx0z0=  (1-xlocal) * (1-zlocal);
+    valx1z0= table[xindex+1][0][zindex];  mulx1z0=   xlocal    * (1-zlocal);
+    valx0z1= table[xindex  ][0][zindex+1]; mulx0z1= (1-xlocal) * zlocal;
+    valx1z1= table[xindex+1][0][zindex+1]; mulx1z1=  xlocal    * zlocal;
+#endif
+
+        // Full 3-dimensional version
+    Bfield[0] =
+      xField[xindex  ][yindex  ][zindex  ] * (1-xlocal) * (1-ylocal) * (1-zlocal) +
+      xField[xindex  ][yindex  ][zindex+1] * (1-xlocal) * (1-ylocal) *    zlocal  +
+      xField[xindex  ][yindex+1][zindex  ] * (1-xlocal) *    ylocal  * (1-zlocal) +
+      xField[xindex  ][yindex+1][zindex+1] * (1-xlocal) *    ylocal  *    zlocal  +
+      xField[xindex+1][yindex  ][zindex  ] *    xlocal  * (1-ylocal) * (1-zlocal) +
+      xField[xindex+1][yindex  ][zindex+1] *    xlocal  * (1-ylocal) *    zlocal  +
+      xField[xindex+1][yindex+1][zindex  ] *    xlocal  *    ylocal  * (1-zlocal) +
+      xField[xindex+1][yindex+1][zindex+1] *    xlocal  *    ylocal  *    zlocal ;
+    Bfield[1] =
+      yField[xindex  ][yindex  ][zindex  ] * (1-xlocal) * (1-ylocal) * (1-zlocal) +
+      yField[xindex  ][yindex  ][zindex+1] * (1-xlocal) * (1-ylocal) *    zlocal  +
+      yField[xindex  ][yindex+1][zindex  ] * (1-xlocal) *    ylocal  * (1-zlocal) +
+      yField[xindex  ][yindex+1][zindex+1] * (1-xlocal) *    ylocal  *    zlocal  +
+      yField[xindex+1][yindex  ][zindex  ] *    xlocal  * (1-ylocal) * (1-zlocal) +
+      yField[xindex+1][yindex  ][zindex+1] *    xlocal  * (1-ylocal) *    zlocal  +
+      yField[xindex+1][yindex+1][zindex  ] *    xlocal  *    ylocal  * (1-zlocal) +
+      yField[xindex+1][yindex+1][zindex+1] *    xlocal  *    ylocal  *    zlocal ;
+    Bfield[2] =
+      zField[xindex  ][yindex  ][zindex  ] * (1-xlocal) * (1-ylocal) * (1-zlocal) +
+      zField[xindex  ][yindex  ][zindex+1] * (1-xlocal) * (1-ylocal) *    zlocal  +
+      zField[xindex  ][yindex+1][zindex  ] * (1-xlocal) *    ylocal  * (1-zlocal) +
+      zField[xindex  ][yindex+1][zindex+1] * (1-xlocal) *    ylocal  *    zlocal  +
+      zField[xindex+1][yindex  ][zindex  ] *    xlocal  * (1-ylocal) * (1-zlocal) +
+      zField[xindex+1][yindex  ][zindex+1] *    xlocal  * (1-ylocal) *    zlocal  +
+      zField[xindex+1][yindex+1][zindex  ] *    xlocal  *    ylocal  * (1-zlocal) +
+      zField[xindex+1][yindex+1][zindex+1] *    xlocal  *    ylocal  *    zlocal ;
+
+    Bfield[0] = Bfield[0] * ffieldValue;
+    Bfield[1] = Bfield[1] * ffieldValue;
+    Bfield[2] = Bfield[2] * ffieldValue;
+
+  }
+  
+  if (sqrt(Bfield[0]*Bfield[0]+Bfield[1]*Bfield[1]+Bfield[2]*Bfield[2])<0.00001*tesla) {
+    //    Bfield[0] = 0.0;
+    //    Bfield[1] = 0.0;
+    Bfield[2] = 0.00001*tesla;
+  }
+  //  if ((point[2]>-1*cm)&&(point[2]<1*cm)) {
+  //    G4cout<<"Field at point ("<<point[0]<<","<<point[1]<<","<<point[2]<<","<<point[3]<<" = "
+  //	  << Bfield[0]/tesla<<", "<<Bfield[1]/tesla<<", "<<Bfield[2]/tesla<<G4endl; 
+  //  }
+}
+
+G4double lem4TabulatedField3D::GetFieldSetValue() {
+  return ffieldValue;
+}
+
+void lem4TabulatedField3D::SetFieldValue(double newFieldValue) {
+  //  // Rescale the magnetic field for a new value of the magnetic field
+  //  G4double factor = newFieldValue/ffieldValue;
+  //  for (G4int ix=0; ix<nx; ix++) {
+  //    for (G4int iy=0; iy<ny; iy++) {
+  //      for (G4int iz=0; iz<nz; iz++) {
+  //        xField[ix][iy][iz] = xField[ix][iy][iz] * factor;
+  //        yField[ix][iy][iz] = yField[ix][iy][iz] * factor;
+  //        zField[ix][iy][iz] = zField[ix][iy][iz] * factor;
+  //      }
+  //    }
+  //  }
+  ffieldValue=newFieldValue;
+  G4cout<<"lem4TabulatedField3D.cc:   ffieldValue changed to="<< ffieldValue/tesla<<"T "<<G4endl;
+}

geant4/LEMuSR/src/lem4UniformField.cc

@@ -0,0 +1,101 @@
+#include "globals.hh"
+
+#include "G4GeometryManager.hh"
+
+//#include "F04GlobalField.hh"
+#include "lem4UniformField.hh"
+///#include "lem4Parameters.hh" ///Is this really needed. TS ???
+
+
+///lem4UniformField::lem4UniformField(G4ThreeVector (Bfieldx,Bfieldy,Bfieldz), G4LogicalVolume* lv, G4ThreeVector c)
+lem4UniformField::lem4UniformField(G4double EMF[6], G4LogicalVolume* lv, G4ThreeVector c)
+///lem4UniformField::lem4UniformField(G4double Bz, G4LogicalVolume* lv, G4ThreeVector c)
+                : F04ElementField(c,lv) ///, EMfield(EMF) /// ??? Why Bz is not enough??
+{
+  for (int i = 0; i < 6; i++){
+    EMfield[i] = EMF[i];
+  }
+  
+///  Bfield  = Bz; ///G4ThreeVector finalField(B[0],B[1],B[2]); G4ThreeVector B(0.0,0.0,Bfield);
+  ///G4ThreeVector BField(Bfieldx,Bfieldy,Bfieldz);
+  
+  fieldLength = 2.*((G4Box*)lvolume->GetSolid())->GetZHalfLength();
+  fieldWidth  = 2.*((G4Box*)lvolume->GetSolid())->GetXHalfLength();
+  fieldHeight = 2.*((G4Box*)lvolume->GetSolid())->GetYHalfLength();
+
+  G4cout << "\n-----------------------------------------------------------"
+         << "\n      Uniform electromagnetic field"
+         << "\n-----------------------------------------------------------"
+         << G4endl;
+   
+  G4String volName = lv->GetName().substr(4);
+  G4cout << "\n ---> EM field in volume " << volName << " set to:" << G4endl;
+  printf   ("      B = (%0.3g, %0.3g, %0.3g) T,  E = (%0.3g, %0.3g, %0.3g) kV/mm\n",
+  EMF[0]/tesla,         EMF[1]/tesla,         EMF[2]/tesla, 
+  EMF[3]/(kilovolt/mm), EMF[4]/(kilovolt/mm), EMF[5]/(kilovolt/mm));
+}
+
+
+
+void lem4UniformField::addFieldValue(const G4double point[4],
+                                           G4double field[6]) const
+{
+   G4ThreeVector global(point[0],point[1],point[2]);
+   G4ThreeVector local;
+   
+   local = global2local.TransformPoint(global);
+   
+   if (isOutside(local)) return;
+
+   G4ThreeVector B(EMfield[0],EMfield[1],EMfield[2]);
+   G4ThreeVector E(EMfield[3],EMfield[4],EMfield[5]);
+   
+   B = global2local.Inverse().TransformAxis(B);
+   E = global2local.Inverse().TransformAxis(E);
+
+   field[0] += B[0];
+   field[1] += B[1];
+   field[2] += B[2];
+   
+   field[3] += E[0];
+   field[4] += E[1];
+   field[5] += E[2];
+      
+   //printf ("   EM field components:  B = (%0.3g, %0.3g, %0.3g) T,  E = (%0.3g, %0.3g, %0.3g) kV/mm\n",
+   //field[0]/tesla,         field[1]/tesla,         field[2]/tesla,
+   //field[3]/(kilovolt/mm), field[4]/(kilovolt/mm), field[5]/(kilovolt/mm));
+}
+
+
+
+G4double lem4UniformField::GetNominalFieldValue() {
+  ///G4double EMfield[6] = {0,0,0,0,0,0};
+  ///for (int i = 0; i < 6; i++){
+    //return EMfield[i];
+    return 0;
+    ///G4double nomFieldValue = (*i)->GetNominalFieldValue();
+    ///EMfield[i] = Bfield[i];
+  //}
+   ///return Bfield; ///ffieldValue;
+}
+
+void lem4UniformField::SetNominalFieldValue(G4double newFieldValue){ ///[6]) {
+   ///Bfield = newFieldValue; ///ffieldValue=newFieldValue;
+  ///for (int i = 0; i < 6; i++){
+    ///EMfield[i] = newFieldValue[i];
+  ///}
+  G4cout<<"lem4UniformField.cc:  SetNominalFieldValue method is NOT defined in this case!\n Dummy field value "<< newFieldValue << G4endl;
+  //G4cout<<"lem4UnifromField.cc:   ffieldValue changed to="<< Bfield/tesla<<"T "<<G4endl;
+}
+
+
+
+G4bool lem4UniformField::isOutside(G4ThreeVector& local) const
+{
+  return (std::fabs(local.z()) > fieldLength/2.0 || std::fabs(local.x()) > fieldWidth/2.0 || std::fabs(local.y()) > fieldHeight/2.0);
+}
+
+G4bool lem4UniformField::isWithin(G4ThreeVector& local) const
+{
+  return (std::fabs(local.z()) < fieldLength/2.0 && std::fabs(local.x()) < fieldWidth/2.0 && std::fabs(local.y()) < fieldHeight/2.0);
+}

geant4/LEMuSR/src/lem4VisManager.cc

@@ -0,0 +1,115 @@
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+#ifdef G4VIS_USE
+
+#include "lem4VisManager.hh"
+
+// Supported drivers...
+
+// Not needing external packages or libraries...
+#include "G4ASCIITree.hh"
+#include "G4DAWNFILE.hh"
+//#include "G4GAGTree.hh" // Class removed from ver. 4.9
+#include "G4HepRepFile.hh"
+#include "G4HepRep.hh"
+#include "G4RayTracer.hh"
+#include "G4VRML1File.hh"
+#include "G4VRML2File.hh"
+
+// Needing external packages or libraries...
+
+#ifdef G4VIS_USE_DAWN
+#include "G4FukuiRenderer.hh"
+#endif
+
+#ifdef G4VIS_USE_OPENGLX
+#include "G4OpenGLImmediateX.hh"
+#include "G4OpenGLStoredX.hh"
+#endif
+
+#ifdef G4VIS_USE_OPENGLWIN32
+#include "G4OpenGLImmediateWin32.hh"
+#include "G4OpenGLStoredWin32.hh"
+#endif
+
+#ifdef G4VIS_USE_OPENGLXM
+#include "G4OpenGLImmediateXm.hh"
+#include "G4OpenGLStoredXm.hh"
+#endif
+
+#ifdef G4VIS_USE_OIX
+#include "G4OpenInventorX.hh"
+#endif
+
+#ifdef G4VIS_USE_OIWIN32
+#include "G4OpenInventorWin32.hh"
+#endif
+
+#ifdef G4VIS_USE_VRML
+#include "G4VRML1.hh"
+#include "G4VRML2.hh"
+#endif
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+lem4VisManager::lem4VisManager () {}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+void lem4VisManager::RegisterGraphicsSystems () {
+
+  // Graphics Systems not needing external packages or libraries...
+  RegisterGraphicsSystem (new G4ASCIITree);
+  RegisterGraphicsSystem (new G4DAWNFILE);
+//RegisterGraphicsSystem (new G4GAGTree); // Class removed from ver. 4.9
+  RegisterGraphicsSystem (new G4HepRepFile);
+  RegisterGraphicsSystem (new G4HepRep);
+  RegisterGraphicsSystem (new G4RayTracer);
+  RegisterGraphicsSystem (new G4VRML1File);
+  RegisterGraphicsSystem (new G4VRML2File);
+
+  // Graphics systems needing external packages or libraries...
+
+#ifdef G4VIS_USE_DAWN
+  RegisterGraphicsSystem (new G4FukuiRenderer);
+#endif
+
+#ifdef G4VIS_USE_OPENGLX
+  RegisterGraphicsSystem (new G4OpenGLImmediateX);
+  RegisterGraphicsSystem (new G4OpenGLStoredX);
+#endif
+
+#ifdef G4VIS_USE_OPENGLWIN32
+  RegisterGraphicsSystem (new G4OpenGLImmediateWin32);
+  RegisterGraphicsSystem (new G4OpenGLStoredWin32);
+#endif
+
+#ifdef G4VIS_USE_OPENGLXM
+  RegisterGraphicsSystem (new G4OpenGLImmediateXm);
+  RegisterGraphicsSystem (new G4OpenGLStoredXm);
+#endif
+
+#ifdef G4VIS_USE_OIX
+  RegisterGraphicsSystem (new G4OpenInventorX);
+#endif
+
+#ifdef G4VIS_USE_OIWIN32
+  RegisterGraphicsSystem (new G4OpenInventorWin32);
+#endif
+
+#ifdef G4VIS_USE_VRML
+  RegisterGraphicsSystem (new G4VRML1);
+  RegisterGraphicsSystem (new G4VRML2);
+#endif
+
+  if (fVerbose > 0) {
+    G4cout <<
+      "\nYou have successfully chosen to use the following graphics systems."
+	 << G4endl;
+    PrintAvailableGraphicsSystems ();
+  }
+}
+
+#endif
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

geant4/LEMuSR/src/musrEventAction.cc

@@ -0,0 +1,187 @@
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+#include "lem4EventAction.hh"
+#include "G4Event.hh"
+#include "G4EventManager.hh"
+#include "G4TrajectoryContainer.hh"
+#include "G4Trajectory.hh"
+#include "G4VVisManager.hh"
+#include "G4ios.hh"
+#include "G4TransportationManager.hh"
+#include "G4FieldManager.hh"
+#include "lem4MagneticField.hh"
+#include "lem4TabulatedField3D.hh"
+#include "lem4TabulatedField2D.hh"
+#include "lem4RootOutput.hh"
+#include "lem4ErrorMessage.hh"
+#include "lem4SteppingAction.hh"
+#include "F04GlobalField.hh"
+//#include "F04ElementField.hh"
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+G4bool lem4EventAction::setRandomNrSeedAccordingEventNr=0;
+G4bool lem4EventAction::setRandomNrSeedFromFile=0;
+G4int  lem4EventAction::nHowOftenToPrintEvent=10000;
+//vector<int> * lem4EventAction::RandomNrInitialisers=NULL;
+ 
+//long lem4EventAction::myEventNr=0;
+
+lem4EventAction::lem4EventAction() {
+  pointer=this;
+  fieldValueStart=0;
+  pointerToSeedVector = new vector<int>;
+  timeDependentField=false;
+  lastFieldValue=-10000*tesla;
+  pointerToMusrUniformField=NULL;
+  pointerToTabulatedField3D=NULL;
+  pointerToTabulatedField2D=NULL;
+  latestEventNr=-1;
+}
+lem4EventAction* lem4EventAction::pointer=0;
+lem4EventAction* lem4EventAction::GetInstance() {
+  return pointer;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+ 
+lem4EventAction::~lem4EventAction()
+{
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+void lem4EventAction::BeginOfEventAction(const G4Event* evt) {
+  // test error
+  //  lem4ErrorMessage::GetInstance()->lem4Error(SERIOUS,"test error",true);
+  //
+  //  G4cout<<"lem4EventAction::BeginOfEventAction:  KAMIL"<<G4endl;
+  lem4SteppingAction::GetInstance()->DoAtTheBeginningOfEvent();
+
+  long thisEventNr = (long) (evt->GetEventID());
+
+  if (F04GlobalField::Exists()) {
+    //   if (F04GlobalField::getObject() -> DoesAnyFieldValueNeedsToBeChanged(thisEventNr)) {
+      //      G4cout<<"We should check each Element Field Object whether its field needs to be changed:"<<G4endl;
+      // Loop over all Element Fields and tell them to change their nominal field value, if that was foreseen.
+      
+    //      F04ElementField
+    //    }
+    F04GlobalField::getObject() -> CheckWhetherAnyNominalFieldValueNeedsToBeChanged(thisEventNr);
+  }
+
+  latestEventNr = thisEventNr;
+  G4double actualFieldValue;
+  if (timeDependentField) {
+    //    actualFieldValue=fieldAtEnd-fieldAtBeginning
+    G4int i=int(double(thisEventNr)/double(maxEventNr)*fieldNrOfSteps);    // i ... nr of actual step in the field
+    actualFieldValue=fieldValueStart+fieldStep*i;
+    if (actualFieldValue!=lastFieldValue) {
+      lastFieldValue=actualFieldValue;
+      //      G4FieldManager* fieldMgr = G4TransportationManager::GetTransportationManager()->GetFieldManager();
+      //      //      fieldMgr->SetFieldValue(actualFieldValue);  //did not work
+      //      const G4Field* pointerToField = NULL;
+      //      pointerToField=fieldMgr->GetDetectorField();
+      //      pointerToField->GetFieldValue(0,0,0,0,
+      if (pointerToMusrUniformField) {
+	pointerToMusrUniformField->SetFieldValue(actualFieldValue);      
+        //      pointerToField->SetFieldValue(actualFieldValue); does not work
+	G4cout<<"Event "<<thisEventNr<<":  Uniform field value changed to ";
+	G4cout<<(actualFieldValue/tesla)<<"Tesla."<<G4endl;
+      }
+      else if (pointerToTabulatedField3D) {
+	pointerToTabulatedField3D->SetFieldValue(actualFieldValue);
+	G4cout<<"Event "<<thisEventNr<<":  Tabulated Field (3D) value changed to ";
+	G4cout<<(actualFieldValue/tesla)<<"Tesla."<<G4endl;
+      }
+      else if (pointerToTabulatedField2D) {
+	pointerToTabulatedField2D->SetFieldValue(actualFieldValue);
+	G4cout<<"Event "<<thisEventNr<<":  Tabulated Field (2D) value changed to ";
+	G4cout<<(actualFieldValue/tesla)<<"Tesla."<<G4endl;
+      }
+    }
+  }
+  else {actualFieldValue=fieldValueStart;}
+  lem4RootOutput* myRootOutput = lem4RootOutput::GetRootInstance();
+  myRootOutput->SetFieldValue(actualFieldValue);
+
+  //  if (lem4DetectorMessenger::setRandomNrSeedAccordingEventNr) {
+  if (setRandomNrSeedFromFile) {
+    //    G4cout<<"RandomNrInitialisers.size()="<<RandomNrInitialisers->size()<<G4endl;
+    if (thisEventNr < (long) pointerToSeedVector->size()) {
+      G4cout <<"lem4EventAction.cc: seed will be set to="<< pointerToSeedVector->at(thisEventNr)<<G4endl;
+      CLHEP::HepRandom::setTheSeed(pointerToSeedVector->at(thisEventNr));
+    }
+  }
+  else if (setRandomNrSeedAccordingEventNr) {
+    //    long seeds[2];
+    //    seeds[0] = (long) 234567890+thisEventNr*117;
+    //    seeds[1] = (long) 333222111+thisEventNr*173;
+    //
+    //    //    seeds[1] = (long) (evt->GetEventID());
+    //    //    seeds[0] = (long) 123456789;    // This leads to a gap in the decay time histogram fro N=100000 events
+    //    //    seeds[1] = (long) 333222111+thisEventNr;     // ----------------------------||------------------------------------
+    //    thisEventNr++;
+    //    CLHEP::HepRandom::setTheSeeds(seeds);
+    //    //    G4cout << "seed1: " << seeds[0] << "; seed2: " << seeds[1] << G4endl;
+    //
+    //    G4cout <<"      thisEventNr="<<thisEventNr;
+    CLHEP::HepRandom::setTheSeed(thisEventNr);
+    //    G4cout <<"     getTheSeed="<<CLHEP::HepRandom::getTheSeed()<< G4endl; 
+    CLHEP::RandGauss::setFlag(false);
+  }
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+ 
+void lem4EventAction::EndOfEventAction(const G4Event* evt)  {
+  //  cout << ":." << flush;
+  long thisEventNr = (long) evt->GetEventID();
+  
+  // get number of stored trajectories
+  //
+  G4TrajectoryContainer* trajectoryContainer = evt->GetTrajectoryContainer();
+  G4int n_trajectories = 0;
+  if (trajectoryContainer) n_trajectories = trajectoryContainer->entries();
+  
+  //  G4cout << ">>> Event " << evt->GetEventID() << G4endl;
+  
+  // periodic printing
+  //
+  //  if (thisEventNr != 0 and thisEventNr%10000 == 0) {
+  if (thisEventNr != 0 and thisEventNr%nHowOftenToPrintEvent == 0) {
+    time_t curr=time(0);
+    //char * ctime(const time_t * tp);
+    G4cout << ">>> Event " << evt->GetEventID() <<"   at "<< ctime(&curr);
+    G4cout.flush();
+    //    G4cout << "                   seed set to "<< CLHEP::HepRandom::getTheSeed();//<< G4endl; 
+  }
+    
+  // extract the trajectories and draw them
+  //
+  if (G4VVisManager::GetConcreteInstance())  {
+    for (G4int i=0; i<n_trajectories; i++) 
+      { G4Trajectory* trj = (G4Trajectory*)
+	  ((*(evt->GetTrajectoryContainer()))[i]);
+	trj->DrawTrajectory(1000);
+      }
+  }
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+vector<int> * lem4EventAction::pointerToSeedVector=NULL;
+vector<int> * lem4EventAction::GetPointerToSeedVector() {
+  return pointerToSeedVector;
+}
+
+
+void lem4EventAction::SetTimeDependentField(G4bool setFieldToBeTimeDependend, G4double initialField,
+					    G4double finalField, G4int nrOfSteps) {
+  timeDependentField = setFieldToBeTimeDependend;
+  fieldValueStart    =  initialField;
+  fieldValueEnd      =  finalField;
+  fieldNrOfSteps     =  nrOfSteps;
+  fieldStep          =  (finalField-initialField)/(nrOfSteps-1);
+  G4cout<<"---&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&---"<<G4endl;
+}

geant4/LEMuSR/src/yields.cc

@@ -0,0 +1,102 @@
+//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
+//  Muonium yields as a function of initial mu+ energies.
+//          The method GetYields is used by MuFormation.
+//  Id    : yields.cc, v 1.1
+//  Author: Taofiq PARAISO, T. Shiroka
+//  Date  : 2007-12
+//  Notes : First implemented in Fortran by A. Hofer
+//          C++ conversion by T.K. Paraiso 04-2005
+//          Slight modifications by T. Shiroka
+//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
+
+#include "yields.h"
+
+#include <iomanip>
+#include <fstream>
+#include <iostream>
+#include <stdlib.h>
+
+/*  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ The Muonium Yield function as well as the parameters are taken from:
+ M. Gonin, R. Kallenbach, P. Bochsler: "Charge exchange of hydrogen atoms
+ in carbon foils at 0.4 - 120 keV", Rev.Sci.Instrum. 65 (3), March 1994
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+Yields:: Yields(){;}
+Yields::~Yields(){;}
+
+void Yields::GetYields(
+       double E,          // kinetic energy in keV
+       double mass,       // mass in keV/c**2
+       double yvector[3]) // pointer to the yields table
+
+{
+  // Parameter NAMES  for the muonium yield function
+  double a_zero, a_minus;
+  double k_Fermi, k_zero, k_minus;
+  double two_k_Fermi;
+  double k_Fermi_Quad, k_zero_Quad, k_minus_Quad;
+  double vc_minus, vc_plus, v_Bohr, v_rel;
+
+  // Parameter VALUES for the muonium yield function
+  a_zero   = 0.953;
+  a_minus  = 0.029;
+  k_Fermi  = 1.178;                 // [v_Bohr]
+  k_Fermi_Quad = k_Fermi * k_Fermi;
+  two_k_Fermi  = 2. * k_Fermi;
+  k_zero       = 0.991*k_Fermi;     // [v_Bohr]
+  k_zero_Quad  = k_zero * k_zero;
+  k_minus      = 0.989*k_Fermi;     // [v_Bohr]
+  k_minus_Quad = k_minus * k_minus;
+  vc_minus = 0.284;
+  vc_plus  = 0.193;                 // [v_Bohr]
+  v_Bohr   = 7.2974E-3;             // [c]
+
+
+  // std::cout<<"E = "<< E <<std::endl;
+
+  // Abort in case of negative energies ---------------------------
+  if (E < 0)
+    {
+      std::cout<< "Error in method ''Yields'':" <<std::endl;
+      std::cout<< "E = "<< E <<" < 0!" <<std::endl;
+      std::cout<< "-> ABORTED!" <<std::endl;
+      return;
+    }
+  //---------------------------------------------------------------
+
+
+
+  // Definition of variables (aux_n are some auxiliary variables)
+  // Calculate energy in (classical) terms of speed (in units of v_Bohr):
+
+  v_rel = sqrt(2.*E/mass)/ v_Bohr;
+
+  aux1 = v_rel*v_rel;
+  aux2 = two_k_Fermi*v_rel;
+  Q_zero  = 1. + (k_zero_Quad  - k_Fermi_Quad - aux1) / aux2;
+  Q_minus = 1. + (k_minus_Quad - k_Fermi_Quad - aux1) / aux2;
+
+  aux1 = a_zero * Q_zero;
+  aux2 = a_minus * Q_minus;
+  aux3 = (1.-Q_zero)*(1.-Q_minus);
+  D = aux1*(aux2 + (1.-Q_minus)) + aux3;
+
+  Yield_minus = aux1*aux2 / D;
+  Yield_plus  = aux3 / D;
+
+  Yield_minus = Yield_minus* exp(-vc_minus/v_rel);
+  Yield_plus  = Yield_plus * exp(-vc_plus /v_rel);
+
+  if(Yield_minus > exp(-vc_minus/v_rel)) Yield_minus=exp(-vc_minus/v_rel);
+  if(Yield_plus  > exp(-vc_plus/v_rel))  Yield_plus=exp(-vc_plus/v_rel);
+
+  Yield_zero  = 1. - (Yield_minus + Yield_plus);
+
+  yvector[0]=Yield_plus;
+  yvector[1]=Yield_zero;
+  yvector[2]=Yield_minus;
+
+  // std::cout<<"Y+ : "<< Yield_plus << std::endl;
+  // std::cout<<"Y0 : "<< Yield_zero << std::endl;
+}