PamVMC_update/macro/PamG4Libs.C

// $Id: g4libs.C 496 2010-05-19 15:55:27Z ivana $

//------------------------------------------------
// The Virtual Monte Carlo examples
// Copyright (C) 2007, Ivana Hrivnacova
// All rights reserved.
//
// For the licensing terms see geant4_vmc/LICENSE.
// Contact: vmc@pcroot.cern.ch
//-------------------------------------------------

/// \file g4libs.C
/// \brief Macro for loading Geant4 and Geant4 VMC libraries
/// 
/// A new macro for loading Geant4 and Geant4 VMC libraries
/// with using liblist utility provided in Geant4
///
/// \author Christian Holm Christensen, NBI;
///         Dmitry Naumov, JINR
//
// Macro for loading Geant4 and Geant4 VMC libraries

#if !defined(__CINT__) || defined(__MAKECINT__)

#include <vector>
#include <string>
#include <sstream>
#include <iostream>
#include <iomanip>

#include <TSystem.h>
#include <Riostream.h>
#include <TCint.h>
#include <TError.h>
#include <TMath.h>
#include <TApplication.h>
#include <TROOT.h>

#endif

void loadg4libs();

void PamG4Libs()
{
/// Function for loading all libraries for running VMC with Geant4
  loadg4libs();

  gSystem->SetFPEMask(0); 
}   

string NoSpaces(string s)
{
/// ???

  std::stringstream str(s);
  std::string token;
  std::getline(str, token, '\n');
  return token;
}

Bool_t isLibrary(const char* libName)
{
/// Helper function which testes the existence of the given library
/// \param libName  The library name

  if (TString(gSystem->DynamicPathName(libName, kTRUE)) != TString(""))
    return kTRUE;
  else  
    return kFALSE;
}    

Bool_t isBatch()
{
/// Helper function which testes if Root was started in batch mode

  for ( Int_t i=0; i<gApplication->Argc(); ++i ) 
    if ( TString(gROOT->GetApplication()->Argv(i)) == "-b" ) return true;
  
  return false;
}    

Bool_t isSet(const char* variable)
{
/// Helper function which checks if the specified environment variable 
/// is set.
/// \param variable  The environment variable name

  TString value = gSystem->Getenv(variable);
  if ( value != "") return true;
  
  return false;
}  

void vgmlibs()
{ 
/// Function for loading VGM libraries.

  if ( isSet("USE_VGM") ) { 
    cout << "Loading VGM libraries ... " << endl;
    gSystem->Load("libClhepVGM");
    gSystem->Load("libBaseVGM");
    gSystem->Load("libGeant4GM");
    gSystem->Load("libRootGM");
    gSystem->Load("libXmlVGM");
  }  
}

void GetLinkLine(string& all_lines) 
{
/// Build the string with the list of libraries using liblist

  // Geant4 lib directory
  TString g4lib  = gSystem->Getenv("G4LIB");
  if ( g4lib.Length() == 0 ) 
    g4lib  = gSystem->Getenv("G4INSTALL") + TString("/lib");
  g4lib += "/"+TString(gSystem->Getenv("G4SYSTEM"));
  
  // Build the string with the list of libraries using liblist
  TString command 
    //    = "echo -L"+g4lib+" `" + g4lib+"/liblist -m "+g4lib +" <  " + g4lib+"/libname.map`";
    = "echo -L"+g4lib+" `cd " +g4lib+"; for file in \\`ls -L *.so | sed s/ib// | sed s/.so//\\`; do echo -$file; done`";

  std::cout << "Executing: " << command << std::endl;

  FILE* pipe = gSystem->OpenPipe(command, "r");
  char line[100];
  while ( fgets(line, sizeof(line), pipe ) != NULL ) {
    all_lines += line;
  }

  std::cout << all_lines << std::endl;

}  

void HandleLinkLine(const char* str, const char* what)
{
/// Tokenize the input string and load/unload the libraries
/// from the list.
/// \param str  The string output from Geant4 liblist
/// \param what The option specifying whether we want to load ('l') or 
///             unload ('u') libraries

  // Fill the libs names in the vector
  std::vector<std::string> libs;
  std::stringstream sstream(str);
  unsigned int w = 0;
  while ( ! sstream.eof() ) {
    // Read one string
    std::string token;
    std::getline(sstream, token, ' ');

    // Check stream status 
    if ( sstream.bad() ) break;

    // Check that we got a meaningful tokenonent
    if ( token.empty() || std::isspace(token[0]) ) continue;
    
    if ( token[0] != '-' ) {
      Warning("LoadLibraryList", "Unknown element %s", token.c_str());
      continue;
    }
       
    std::string dir_or_file = token.substr(2,token.size()-2);
    if ( token[1] == 'L' ) { 
      std::stringstream path;
      path << gSystem->GetDynamicPath() << ":" 
           << dir_or_file;
      gSystem->SetDynamicPath(path.str().c_str());
    }
    else if ( token[1] == 'l' ) {
      std::stringstream ln;
      ln << "lib" << NoSpaces(dir_or_file) << '.' << gSystem->GetSoExt();
      std::string lib(ln.str());
      libs.push_back(lib);
      if ( lib.length() > w ) w = lib.length();
    }
    else {
      Warning("LoadLibraryList", "Unknown option %s in", 
              token.c_str(), str);
      continue;
     }
  }
  
  // Process the vector with libs names and load libraries
  size_t n = libs.size();
  TString sWhat(what);
  Bool_t load = sWhat.Contains("l");
  if (!load && !sWhat.Contains("u")) {
     std::cerr << "  Unknown load action " << what << std::endl;
     return;
  }

  for ( size_t i = 0; i < n; ++i ) {
    size_t idx = n - i - 1;
    
    // Uncomment to debug
    // size_t m = TMath::Log10(n)+1;
    // string say="   Loading ";
    // if ( TString(what).Contains("u") ) say = "   Unloading ";
    // std::cout << say         << std::setw(m) << (i+1) 
    //        << "/"            << std::setw(m) << n 
    //        << ": "           << std::setw(w) << libs[idx] // << std::endl; 
    //        << std::flush;
   
    int result = 0; 
    if ( libs[idx].c_str() ) {
       if  (load) 
          result = gSystem->Load(libs[idx].c_str());
       else
          gSystem->Unload(libs[idx].c_str());
    } 
    // Uncomment to debug
    // if ( TString(what).Contains("l")  )
    //   std::cout << ( result < 0 ? " failed" : " ok" ) << "\r";
  }
  // std::cout << "\n   Done" << std::endl;
}

void loadg4libs() 
{
/// The function to unload Geant4 libraries

  // CLHEP
  gSystem->Load("libCLHEP");
  
  // xerces-c library if GDML is activated
  if ( isSet("G4LIB_BUILD_GDML") ) {
    gSystem->Load("libxerces-c");
  }  

  // Get the string with the list of libraries
  string all_lines;
  GetLinkLine(all_lines);
  
  // Load Geant4 libraries
  cout << "Loading Geant4 libraries ..." << endl;
  HandleLinkLine(all_lines.c_str(),"l");

  // VGM librares
  vgmlibs();
  
  // G4Root library (if available)
  if ( isLibrary("libg4root") ) {
    cout << "Loading g4root library ..." << endl;
    gSystem->Load("libg4root");
  }
    
  // Geant4 VMC library
  cout << "Loading geant4vmc library ..." << endl;
  gSystem->Load("libgeant4vmc");

  // Geant4 VMC GUI library 
  // (if available and Root is not running in batch mode)
  if ( isLibrary("libgeant4vmc_gui") && ! isBatch() ) {
    cout << "Loading geant4vmc_gui library ... " << endl;
    gSystem->Load("libgeant4vmc_gui");
  }  
}

void unloadg4libs() 
{
/// The function to unload Geant4 libraries

  // Get the string with the list of libraries
  string all_lines;
  GetLinkLine(all_lines);
  
  // Load Geant4 libraries
  cout << "Unloading Geant4 libraries ..." << endl;
  HandleLinkLine(all_lines.c_str(),"u");
}

1	formato	1.1	// $Id: g4libs.C 496 2010-05-19 15:55:27Z ivana $
2
3			//------------------------------------------------
4			// The Virtual Monte Carlo examples
5			// Copyright (C) 2007, Ivana Hrivnacova
6			// All rights reserved.
7			//
8			// For the licensing terms see geant4_vmc/LICENSE.
9			// Contact: vmc@pcroot.cern.ch
10			//-------------------------------------------------
11
12			/// \file g4libs.C
13			/// \brief Macro for loading Geant4 and Geant4 VMC libraries
14			///
15			/// A new macro for loading Geant4 and Geant4 VMC libraries
16			/// with using liblist utility provided in Geant4
17			///
18			/// \author Christian Holm Christensen, NBI;
19			/// Dmitry Naumov, JINR
20			//
21			// Macro for loading Geant4 and Geant4 VMC libraries
22
23			#if !defined(__CINT__) \|\| defined(__MAKECINT__)
24
25			#include <vector>
26			#include <string>
27			#include <sstream>
28			#include <iostream>
29			#include <iomanip>
30
31			#include <TSystem.h>
32			#include <Riostream.h>
33			#include <TCint.h>
34			#include <TError.h>
35			#include <TMath.h>
36			#include <TApplication.h>
37			#include <TROOT.h>
38
39			#endif
40
41			void loadg4libs();
42
43			void PamG4Libs()
44			{
45			/// Function for loading all libraries for running VMC with Geant4
46			loadg4libs();
47
48			gSystem->SetFPEMask(0);
49			}
50
51			string NoSpaces(string s)
52			{
53			/// ???
54
55			std::stringstream str(s);
56			std::string token;
57			std::getline(str, token, '\n');
58			return token;
59			}
60
61			Bool_t isLibrary(const char* libName)
62			{
63			/// Helper function which testes the existence of the given library
64			/// \param libName The library name
65
66			if (TString(gSystem->DynamicPathName(libName, kTRUE)) != TString(""))
67			return kTRUE;
68			else
69			return kFALSE;
70			}
71
72			Bool_t isBatch()
73			{
74			/// Helper function which testes if Root was started in batch mode
75
76			for ( Int_t i=0; i<gApplication->Argc(); ++i )
77			if ( TString(gROOT->GetApplication()->Argv(i)) == "-b" ) return true;
78
79			return false;
80			}
81
82			Bool_t isSet(const char* variable)
83			{
84			/// Helper function which checks if the specified environment variable
85			/// is set.
86			/// \param variable The environment variable name
87
88			TString value = gSystem->Getenv(variable);
89			if ( value != "") return true;
90
91			return false;
92			}
93
94			void vgmlibs()
95			{
96			/// Function for loading VGM libraries.
97
98			if ( isSet("USE_VGM") ) {
99			cout << "Loading VGM libraries ... " << endl;
100			gSystem->Load("libClhepVGM");
101			gSystem->Load("libBaseVGM");
102			gSystem->Load("libGeant4GM");
103			gSystem->Load("libRootGM");
104			gSystem->Load("libXmlVGM");
105			}
106			}
107
108			void GetLinkLine(string& all_lines)
109			{
110			/// Build the string with the list of libraries using liblist
111
112			// Geant4 lib directory
113			TString g4lib = gSystem->Getenv("G4LIB");
114			if ( g4lib.Length() == 0 )
115			g4lib = gSystem->Getenv("G4INSTALL") + TString("/lib");
116			g4lib += "/"+TString(gSystem->Getenv("G4SYSTEM"));
117
118			// Build the string with the list of libraries using liblist
119			TString command
120			// = "echo -L"+g4lib+" `" + g4lib+"/liblist -m "+g4lib +" < " + g4lib+"/libname.map`";
121			= "echo -L"+g4lib+" `cd " +g4lib+"; for file in \\`ls -L *.so \| sed s/ib// \| sed s/.so//\\`; do echo -$file; done`";
122
123			std::cout << "Executing: " << command << std::endl;
124
125			FILE* pipe = gSystem->OpenPipe(command, "r");
126			char line[100];
127			while ( fgets(line, sizeof(line), pipe ) != NULL ) {
128			all_lines += line;
129			}
130
131			std::cout << all_lines << std::endl;
132
133			}
134
135			void HandleLinkLine(const char* str, const char* what)
136			{
137			/// Tokenize the input string and load/unload the libraries
138			/// from the list.
139			/// \param str The string output from Geant4 liblist
140			/// \param what The option specifying whether we want to load ('l') or
141			/// unload ('u') libraries
142
143			// Fill the libs names in the vector
144			std::vector<std::string> libs;
145			std::stringstream sstream(str);
146			unsigned int w = 0;
147			while ( ! sstream.eof() ) {
148			// Read one string
149			std::string token;
150			std::getline(sstream, token, ' ');
151
152			// Check stream status
153			if ( sstream.bad() ) break;
154
155			// Check that we got a meaningful tokenonent
156			if ( token.empty() \|\| std::isspace(token[0]) ) continue;
157
158			if ( token[0] != '-' ) {
159			Warning("LoadLibraryList", "Unknown element %s", token.c_str());
160			continue;
161			}
162
163			std::string dir_or_file = token.substr(2,token.size()-2);
164			if ( token[1] == 'L' ) {
165			std::stringstream path;
166			path << gSystem->GetDynamicPath() << ":"
167			<< dir_or_file;
168			gSystem->SetDynamicPath(path.str().c_str());
169			}
170			else if ( token[1] == 'l' ) {
171			std::stringstream ln;
172			ln << "lib" << NoSpaces(dir_or_file) << '.' << gSystem->GetSoExt();
173			std::string lib(ln.str());
174			libs.push_back(lib);
175			if ( lib.length() > w ) w = lib.length();
176			}
177			else {
178			Warning("LoadLibraryList", "Unknown option %s in",
179			token.c_str(), str);
180			continue;
181			}
182			}
183
184			// Process the vector with libs names and load libraries
185			size_t n = libs.size();
186			TString sWhat(what);
187			Bool_t load = sWhat.Contains("l");
188			if (!load && !sWhat.Contains("u")) {
189			std::cerr << " Unknown load action " << what << std::endl;
190			return;
191			}
192
193			for ( size_t i = 0; i < n; ++i ) {
194			size_t idx = n - i - 1;
195
196			// Uncomment to debug
197			// size_t m = TMath::Log10(n)+1;
198			// string say=" Loading ";
199			// if ( TString(what).Contains("u") ) say = " Unloading ";
200			// std::cout << say << std::setw(m) << (i+1)
201			// << "/" << std::setw(m) << n
202			// << ": " << std::setw(w) << libs[idx] // << std::endl;
203			// << std::flush;
204
205			int result = 0;
206			if ( libs[idx].c_str() ) {
207			if (load)
208			result = gSystem->Load(libs[idx].c_str());
209			else
210			gSystem->Unload(libs[idx].c_str());
211			}
212			// Uncomment to debug
213			// if ( TString(what).Contains("l") )
214			// std::cout << ( result < 0 ? " failed" : " ok" ) << "\r";
215			}
216			// std::cout << "\n Done" << std::endl;
217			}
218
219			void loadg4libs()
220			{
221			/// The function to unload Geant4 libraries
222
223			// CLHEP
224			gSystem->Load("libCLHEP");
225
226			// xerces-c library if GDML is activated
227			if ( isSet("G4LIB_BUILD_GDML") ) {
228			gSystem->Load("libxerces-c");
229			}
230
231			// Get the string with the list of libraries
232			string all_lines;
233			GetLinkLine(all_lines);
234
235			// Load Geant4 libraries
236			cout << "Loading Geant4 libraries ..." << endl;
237			HandleLinkLine(all_lines.c_str(),"l");
238
239			// VGM librares
240			vgmlibs();
241
242			// G4Root library (if available)
243			if ( isLibrary("libg4root") ) {
244			cout << "Loading g4root library ..." << endl;
245			gSystem->Load("libg4root");
246			}
247
248			// Geant4 VMC library
249			cout << "Loading geant4vmc library ..." << endl;
250			gSystem->Load("libgeant4vmc");
251
252			// Geant4 VMC GUI library
253			// (if available and Root is not running in batch mode)
254			if ( isLibrary("libgeant4vmc_gui") && ! isBatch() ) {
255			cout << "Loading geant4vmc_gui library ... " << endl;
256			gSystem->Load("libgeant4vmc_gui");
257			}
258			}
259
260			void unloadg4libs()
261			{
262			/// The function to unload Geant4 libraries
263
264			// Get the string with the list of libraries
265			string all_lines;
266			GetLinkLine(all_lines);
267
268			// Load Geant4 libraries
269			cout << "Unloading Geant4 libraries ..." << endl;
270			HandleLinkLine(all_lines.c_str(),"u");
271			}
272