5.6.2012 Kamil Sedlak

Added two files:   FindROOT.cmake  and   CMakeLists.txt ,
which are needed for the compilation of musrSim by using cmake

CMakeLists.txt

@@ -0,0 +1,88 @@
+#----------------------------------------------------------------------------
+# Setup the project
+cmake_minimum_required(VERSION 2.6 FATAL_ERROR)
+project(musrSim)
+
+#----------------------------------------------------------------------------
+# KAMIL CHANGES:
+#include_directories ("/home/download/Root_5.24_source/root/include")
+# Load some basic macros which are needed later on
+include(FindROOT.cmake)
+
+set(INCLUDE_DIRECTORIES ${ROOT_INCLUDE_DIR})
+include_directories( ${INCLUDE_DIRECTORIES})
+
+set(LINK_DIRECTORIES${ROOT_LIBRARY_DIR})
+link_directories( ${LINK_DIRECTORIES})
+
+#----------------------------------------------------------------------------
+# Find Geant4 package, activating all available UI and Vis drivers by default
+# You can set WITH_GEANT4_UIVIS to OFF via the command line or ccmake/cmake-gui
+# to build a batch mode only executable
+#
+option(WITH_GEANT4_UIVIS "Build example with Geant4 UI and Vis drivers" ON)
+if(WITH_GEANT4_UIVIS)
+  find_package(Geant4 REQUIRED ui_all vis_all)
+else()
+  find_package(Geant4 REQUIRED)
+endif()
+
+#----------------------------------------------------------------------------
+# Setup Geant4 include directories and compile definitions
+# Setup include directory for this project
+#
+include(${Geant4_USE_FILE})
+include_directories(${PROJECT_SOURCE_DIR}/include)
+
+
+#----------------------------------------------------------------------------
+# Locate sources and headers for this project
+# NB: headers are included so they will show up in IDEs
+#
+file(GLOB sources ${PROJECT_SOURCE_DIR}/src/*.cc)
+file(GLOB headers ${PROJECT_SOURCE_DIR}/include/*.hh)
+
+#----------------------------------------------------------------------------
+# Add the executable, and link it to the Geant4 libraries
+#
+add_executable(musrSim musrSim.cc ${sources} ${headers})
+##FIND_PACKAGE( ROOT )
+#SET(ROOT_CONFIG_EXECUTABLE /home/download/Root_5.24_source/root/bin/root-config)
+## ask root-config for the library varaibles
+#EXEC_PROGRAM( ${ROOT_CONFIG_EXECUTABLE}
+# ARGS "--noldflags --noauxlibs --libs"
+# OUTPUT_VARIABLE root_flags )
+##SET(ROOT_LIBRARIES ${root_flags})
+#EchoString("Kamil ${root_flags}  Kamil")
+#target_link_libraries(musrSim ${Geant4_LIBRARIES} ${root_flags})
+target_link_libraries(musrSim ${Geant4_LIBRARIES} ${ROOT_LIBRARIES})
+#----------------------------------------------------------------------------
+# Copy all scripts to the build directory, i.e. the directory in which we
+# build B1. This is so that we can run the executable directly because it
+# relies on these scripts being in the current working directory.
+#
+set(EXAMPLEB1_SCRIPTS
+  run/1.mac
+  run/1.rndm
+  )
+
+foreach(_script ${EXAMPLEB1_SCRIPTS})
+  configure_file(
+    ${PROJECT_SOURCE_DIR}/${_script}
+    ${PROJECT_BINARY_DIR}/${_script}
+    COPYONLY
+    )
+endforeach()
+
+#----------------------------------------------------------------------------
+# For internal Geant4 use - but has no effect if you build this
+# example standalone
+#
+#add_custom_target(musrSim DEPENDS musrSim)
+
+#----------------------------------------------------------------------------
+# Install the executable to 'bin' directory under CMAKE_INSTALL_PREFIX
+#
+install(TARGETS musrSim DESTINATION bin)
+
+

FindROOT.cmake

@@ -0,0 +1,269 @@
+# - Find ROOT instalation
+# This module tries to find the ROOT installation on your system.
+# It tries to find the root-config script which gives you all the needed information.
+# If the system variable ROOTSYS is set this is straight forward.
+# If not the module uses the pathes given in ROOT_CONFIG_SEARCHPATH.
+# If you need an other path you should add this path to this varaible.  
+# The root-config script is then used to detect basically everything else.
+# This module defines a number of key variables and macros.
+
+# F.Uhlig@gsi.de (fairroot.gsi.de)
+
+
+MESSAGE(STATUS "Looking for Root...")
+
+SET(ROOT_CONFIG_SEARCHPATH
+  ${SIMPATH}/tools/root/bin
+  $ENV{ROOTSYS}/bin
+)
+
+SET(ROOT_DEFINITIONS "")
+
+SET(ROOT_INSTALLED_VERSION_TOO_OLD FALSE)
+
+SET(ROOT_CONFIG_EXECUTABLE ROOT_CONFIG_EXECUTABLE-NOTFOUND)
+
+FIND_PROGRAM(ROOT_CONFIG_EXECUTABLE NAMES root-config PATHS
+   ${ROOT_CONFIG_SEARCHPATH}
+   NO_DEFAULT_PATH)
+    
+IF (${ROOT_CONFIG_EXECUTABLE} MATCHES "ROOT_CONFIG_EXECUTABLE-NOTFOUND")
+  MESSAGE( FATAL_ERROR "ROOT not installed in the searchpath and ROOTSYS is not set. Please
+ set ROOTSYS or add the path to your ROOT installation in the Macro FindROOT.cmake in the
+ subdirectory cmake/modules.")
+ELSE (${ROOT_CONFIG_EXECUTABLE} MATCHES "ROOT_CONFIG_EXECUTABLE-NOTFOUND")
+  STRING(REGEX REPLACE "(^.*)/bin/root-config" "\\1" test ${ROOT_CONFIG_EXECUTABLE}) 
+  SET( ENV{ROOTSYS} ${test})
+  set( ROOTSYS ${test})
+ENDIF (${ROOT_CONFIG_EXECUTABLE} MATCHES "ROOT_CONFIG_EXECUTABLE-NOTFOUND")  
+
+ 
+IF (ROOT_CONFIG_EXECUTABLE)
+   
+  SET(ROOT_FOUND FALSE)
+
+  EXEC_PROGRAM(${ROOT_CONFIG_EXECUTABLE} ARGS "--version" OUTPUT_VARIABLE ROOTVERSION)
+
+  MESSAGE(STATUS "Looking for Root... - found $ENV{ROOTSYS}/bin/root")
+  MESSAGE(STATUS "Looking for Root... - version ${ROOTVERSION} ")   
+
+  # we need at least version 5.00/00
+  IF (NOT ROOT_MIN_VERSION)
+    SET(ROOT_MIN_VERSION "5.00/00")
+  ENDIF (NOT ROOT_MIN_VERSION)
+   
+  # now parse the parts of the user given version string into variables
+  STRING(REGEX REPLACE "^([0-9]+)\\.[0-9][0-9]+\\/[0-9][0-9]+" "\\1" req_root_major_vers "${ROOT_MIN_VERSION}")
+  STRING(REGEX REPLACE "^[0-9]+\\.([0-9][0-9])+\\/[0-9][0-9]+.*" "\\1" req_root_minor_vers "${ROOT_MIN_VERSION}")
+  STRING(REGEX REPLACE "^[0-9]+\\.[0-9][0-9]+\\/([0-9][0-9]+)" "\\1" req_root_patch_vers "${ROOT_MIN_VERSION}")
+   
+  # and now the version string given by qmake
+  STRING(REGEX REPLACE "^([0-9]+)\\.[0-9][0-9]+\\/[0-9][0-9]+.*" "\\1" found_root_major_vers "${ROOTVERSION}")
+  STRING(REGEX REPLACE "^[0-9]+\\.([0-9][0-9])+\\/[0-9][0-9]+.*" "\\1" found_root_minor_vers "${ROOTVERSION}")
+  STRING(REGEX REPLACE "^[0-9]+\\.[0-9][0-9]+\\/([0-9][0-9]+).*" "\\1" found_root_patch_vers "${ROOTVERSION}")
+
+  IF (found_root_major_vers LESS 5)
+    MESSAGE( FATAL_ERROR "Invalid ROOT version \"${ROOTERSION}\", at least major version 4 is required, e.g. \"5.00/00\"")
+  ENDIF (found_root_major_vers LESS 5)
+
+  # compute an overall version number which can be compared at once
+  MATH(EXPR req_vers "${req_root_major_vers}*10000 + ${req_root_minor_vers}*100 + ${req_root_patch_vers}")
+  MATH(EXPR found_vers "${found_root_major_vers}*10000 + ${found_root_minor_vers}*100 + ${found_root_patch_vers}")
+   
+  IF (found_vers LESS req_vers)
+    SET(ROOT_FOUND FALSE)
+    SET(ROOT_INSTALLED_VERSION_TOO_OLD TRUE)
+  ELSE (found_vers LESS req_vers)
+    SET(ROOT_FOUND TRUE)
+  ENDIF (found_vers LESS req_vers)
+
+ENDIF (ROOT_CONFIG_EXECUTABLE)
+
+
+IF (ROOT_FOUND)
+
+  # ask root-config for the library dir
+  # Set ROOT_LIBRARY_DIR
+
+  EXEC_PROGRAM( ${ROOT_CONFIG_EXECUTABLE}
+    ARGS "--libdir"
+    OUTPUT_VARIABLE ROOT_LIBRARY_DIR_TMP )
+
+  IF(EXISTS "${ROOT_LIBRARY_DIR_TMP}")
+    SET(ROOT_LIBRARY_DIR ${ROOT_LIBRARY_DIR_TMP} )
+  ELSE(EXISTS "${ROOT_LIBRARY_DIR_TMP}")
+    MESSAGE("Warning: ROOT_CONFIG_EXECUTABLE reported ${ROOT_LIBRARY_DIR_TMP} as library path,")
+    MESSAGE("Warning: but ${ROOT_LIBRARY_DIR_TMP} does NOT exist, ROOT must NOT be installed correctly.")
+  ENDIF(EXISTS "${ROOT_LIBRARY_DIR_TMP}")
+    
+  # ask root-config for the binary dir
+  EXEC_PROGRAM(${ROOT_CONFIG_EXECUTABLE}
+    ARGS "--bindir"
+    OUTPUT_VARIABLE root_bins )
+  SET(ROOT_BINARY_DIR ${root_bins})
+
+  # ask root-config for the include dir
+  EXEC_PROGRAM( ${ROOT_CONFIG_EXECUTABLE}
+    ARGS "--incdir" 
+    OUTPUT_VARIABLE root_headers )
+  SET(ROOT_INCLUDE_DIR ${root_headers})
+      # CACHE INTERNAL "")
+
+  # ask root-config for the library varaibles
+  EXEC_PROGRAM( ${ROOT_CONFIG_EXECUTABLE}
+#    ARGS "--noldflags --noauxlibs --libs" 
+    ARGS "--glibs" 
+    OUTPUT_VARIABLE root_flags )
+
+#  STRING(REGEX MATCHALL "([^ ])+"  root_libs_all ${root_flags})
+#  STRING(REGEX MATCHALL "-L([^ ])+"  root_library ${root_flags})
+#  REMOVE_FROM_LIST(root_flags "${root_libs_all}" "${root_library}")
+
+  SET(ROOT_LIBRARIES ${root_flags})
+
+  # Make variables changeble to the advanced user
+  MARK_AS_ADVANCED( ROOT_LIBRARY_DIR ROOT_INCLUDE_DIR ROOT_DEFINITIONS)
+
+  # Set ROOT_INCLUDES
+  SET( ROOT_INCLUDES ${ROOT_INCLUDE_DIR})
+
+  SET(LD_LIBRARY_PATH ${LD_LIBRARY_PATH} ${ROOT_LIBRARY_DIR})
+
+  #######################################
+  #
+  #       Check the executables of ROOT 
+  #          ( rootcint ) 
+  #
+  #######################################
+
+  FIND_PROGRAM(ROOT_CINT_EXECUTABLE
+    NAMES rootcint
+    PATHS ${ROOT_BINARY_DIR}
+    NO_DEFAULT_PATH
+    )
+
+ENDIF (ROOT_FOUND)
+
+
+
+  ###########################################
+  #
+  #       Macros for building ROOT dictionary
+  #
+  ###########################################
+
+MACRO (ROOT_GENERATE_DICTIONARY_OLD )
+ 
+   set(INFILES "")    
+
+   foreach (_current_FILE ${ARGN})
+
+     IF (${_current_FILE} MATCHES "^.*\\.h$")
+       IF (${_current_FILE} MATCHES "^.*Link.*$")
+         set(LINKDEF_FILE ${_current_FILE})
+       ELSE (${_current_FILE} MATCHES "^.*Link.*$")
+         set(INFILES ${INFILES} ${_current_FILE})
+       ENDIF (${_current_FILE} MATCHES "^.*Link.*$")
+     ELSE (${_current_FILE} MATCHES "^.*\\.h$")
+       IF (${_current_FILE} MATCHES "^.*\\.cxx$")
+         set(OUTFILE ${_current_FILE})
+       ELSE (${_current_FILE} MATCHES "^.*\\.cxx$")
+         set(INCLUDE_DIRS ${INCLUDE_DIRS} -I${_current_FILE})   
+       ENDIF (${_current_FILE} MATCHES "^.*\\.cxx$")
+     ENDIF (${_current_FILE} MATCHES "^.*\\.h$")
+     
+   endforeach (_current_FILE ${ARGN})
+   
+#  MESSAGE("INFILES: ${INFILES}")
+#  MESSAGE("OutFILE: ${OUTFILE}")
+#  MESSAGE("LINKDEF_FILE: ${LINKDEF_FILE}")
+#  MESSAGE("INCLUDE_DIRS: ${INCLUDE_DIRS}")
+
+   STRING(REGEX REPLACE "(^.*).cxx" "\\1.h" bla "${OUTFILE}")
+#   MESSAGE("BLA: ${bla}")
+   SET (OUTFILES ${OUTFILE} ${bla})
+
+   ADD_CUSTOM_COMMAND(OUTPUT ${OUTFILES}
+      COMMAND ${ROOT_CINT_EXECUTABLE}
+      ARGS -f ${OUTFILE} -c -DHAVE_CONFIG_H ${INCLUDE_DIRS} ${INFILES} ${LINKDEF_FILE} DEPENDS ${INFILES})
+
+#   MESSAGE("ROOT_CINT_EXECUTABLE has created the dictionary ${OUTFILE}")
+
+ENDMACRO (ROOT_GENERATE_DICTIONARY_OLD)
+
+  ###########################################
+  #
+  #       Macros for building ROOT dictionary
+  #
+  ###########################################
+
+MACRO (ROOT_GENERATE_DICTIONARY INFILES LINKDEF_FILE OUTFILE INCLUDE_DIRS_IN)
+ 
+  set(INCLUDE_DIRS)
+
+  foreach (_current_FILE ${INCLUDE_DIRS_IN})
+    set(INCLUDE_DIRS ${INCLUDE_DIRS} -I${_current_FILE})   
+  endforeach (_current_FILE ${INCLUDE_DIRS_IN})
+ 
+
+#  MESSAGE("INFILES: ${INFILES}")
+#  MESSAGE("OutFILE: ${OUTFILE}")
+#  MESSAGE("LINKDEF_FILE: ${LINKDEF_FILE}")
+#  MESSAGE("INCLUDE_DIRS: ${INCLUDE_DIRS}")
+
+  STRING(REGEX REPLACE "^(.*)\\.(.*)$" "\\1.h" bla "${OUTFILE}")
+#  MESSAGE("BLA: ${bla}")
+  SET (OUTFILES ${OUTFILE} ${bla})
+
+
+  if (CMAKE_SYSTEM_NAME MATCHES Linux)
+    ADD_CUSTOM_COMMAND(OUTPUT ${OUTFILES}
+       COMMAND LD_LIBRARY_PATH=${ROOT_LIBRARY_DIR} ROOTSYS=${ROOTSYS} ${ROOT_CINT_EXECUTABLE}
+       ARGS -f ${OUTFILE} -c -DHAVE_CONFIG_H ${INCLUDE_DIRS} ${INFILES} ${LINKDEF_FILE} DEPENDS ${INFILES} ${LINKDEF_FILE})
+  else (CMAKE_SYSTEM_NAME MATCHES Linux)
+    if (CMAKE_SYSTEM_NAME MATCHES Darwin)
+      ADD_CUSTOM_COMMAND(OUTPUT ${OUTFILES}
+       COMMAND DYLD_LIBRARY_PATH=${ROOT_LIBRARY_DIR} ROOTSYS=${ROOTSYS} ${ROOT_CINT_EXECUTABLE}
+       ARGS -f ${OUTFILE} -c -DHAVE_CONFIG_H ${INCLUDE_DIRS} ${INFILES} ${LINKDEF_FILE} DEPENDS ${INFILES} ${LINKDEF_FILE})
+    endif (CMAKE_SYSTEM_NAME MATCHES Darwin)
+  endif (CMAKE_SYSTEM_NAME MATCHES Linux)
+
+ENDMACRO (ROOT_GENERATE_DICTIONARY)
+
+MACRO (GENERATE_ROOT_TEST_SCRIPT SCRIPT_FULL_NAME)
+
+  get_filename_component(path_name ${SCRIPT_FULL_NAME} PATH)
+  get_filename_component(file_extension ${SCRIPT_FULL_NAME} EXT)
+  get_filename_component(file_name ${SCRIPT_FULL_NAME} NAME_WE)
+  set(shell_script_name "${file_name}.sh")
+
+  #MESSAGE("PATH: ${path_name}")
+  #MESSAGE("Ext: ${file_extension}")
+  #MESSAGE("Name: ${file_name}")
+  #MESSAGE("Shell Name: ${shell_script_name}")
+
+  string(REPLACE ${PROJECT_SOURCE_DIR} 
+         ${PROJECT_BINARY_DIR} new_path ${path_name}
+        )
+
+  #MESSAGE("New PATH: ${new_path}")
+
+  file(MAKE_DIRECTORY ${new_path}/data)
+
+  CONVERT_LIST_TO_STRING(${LD_LIBRARY_PATH})
+  set(MY_LD_LIBRARY_PATH ${output})
+  set(my_script_name ${SCRIPT_FULL_NAME})
+
+  if(CMAKE_SYSTEM MATCHES Darwin)
+    configure_file(${PROJECT_SOURCE_DIR}/cmake/scripts/root_macro_macos.sh.in
+                   ${new_path}/${shell_script_name}
+                  )
+  else(CMAKE_SYSTEM MATCHES Darwin)
+    configure_file(${PROJECT_SOURCE_DIR}/cmake/scripts/root_macro.sh.in
+                   ${new_path}/${shell_script_name}
+                  )
+  endif(CMAKE_SYSTEM MATCHES Darwin)
+
+  EXEC_PROGRAM(/bin/chmod ARGS "u+x  ${new_path}/${shell_script_name}")
+
+ENDMACRO (GENERATE_ROOT_TEST_SCRIPT)

src/musrRootOutput.cc

@@ -436,7 +436,7 @@ void musrRootOutput::BeginOfRunAction() {
   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.);
+  htest7 = new TH1F("htest7","The debugging histogram 7",100000,0.,100.);
   htest8 = new TH1F("htest8","The debugging histogram 8",50,0.,3.142);
 
   G4cout << "musrRootOutput::BeginOfRunAction()  The Root tree and branches were defined."<<G4endl;
@@ -455,6 +455,8 @@ void musrRootOutput::EndOfRunAction() {
   htest5->Write();
   htest6->Write();
   htest7->Write();
+  //  Needed for iterative musrSim runs (e.g. when searching for a quadrupole triplet focus using a python script)
+  //  std::cout<<"DEBUG: FOCUS TEST: sigma="<<(htest7->GetMean())/(htest7->GetEntries())<<std::endl;
   htest8->Write();
   // Variables exported from Geant simulation to the Root output
   //  static const Int_t nGeantParamD=10;

src/musrSteppingAction.cc

@@ -241,6 +241,13 @@ void musrSteppingAction::UserSteppingAction(const G4Step* aStep)  {
 	  G4double poly_save=preStepPoint->GetPolarization().y();
 	  G4double polz_save=preStepPoint->GetPolarization().z();
 	  myRootOutput->SetSaveDetectorInfo(tmpVolumeID,particle_id_save,ke_save,x_save,y_save,z_save,time_save,px_save,py_save,pz_save,polx_save,poly_save,polz_save);
+	  //
+	  //	  myRootOutput->htest7->Fill(sqrt(x_save*x_save+y_save*y_save));
+	  //
+	  // cks:  Useful for iterative musrSim runs finding the beam focus (all driven by a python script)
+	  //	  if (sqrt(x_save*x_save+y_save*y_save)<100.)
+	  //	    musrErrorMessage::GetInstance()->musrError(INFO,"musrSteppingAction KAMILTEST:  Beam focused",true);
+
 	}
       }
     }