chem4.cc File Reference

Chem4 example. More...

#include "DetectorConstruction.hh"
#include "PhysicsList.hh"
#include "ActionInitialization.hh"
#include "G4RunManager.hh"
#include "G4DNAChemistryManager.hh"
#include "G4UImanager.hh"
#include "G4UIExecutive.hh"
#include "G4VisExecutive.hh"
#include "CommandLineParser.hh"

Go to the source code of this file.

Functions
CommandLineParser *	parser (0)
unsigned int	noise ()
void	SetSeed ()
void	Parse (int &argc, char **argv)
int	main (int argc, char **argv)
bool	IsBracket (char c)

Variables
long	seed = 0

Detailed Description

Chem4 example.

Definition in file chem4.cc.

Function Documentation

bool IsBracket

(

char

c

)

Definition at line 198 of file chem4.cc.

Referenced by SetSeed().

{
  switch(c)
  {
    case '[':
    case ']':
      return true;
    default:
      return false;
  }
}

int main	(	int	argc,
		char **	argv
	)

Definition at line 77 of file chem4.cc.

References Parse(), parser(), and SetSeed().

{
  // Parse options given in commandLine
  Parse(argc, argv);
  Command* commandLine(0);
  SetSeed();
  
  // Construct the run manager according to whether MT is activated or not
  //
#ifdef G4MULTITHREADED
  G4MTRunManager* runManager= new G4MTRunManager();
  
  if((commandLine = parser->GetCommandIfActive("-mt")))
  {
    int nThreads = 2;
    if(commandLine->GetOption() == "NMAX")
    {
      nThreads = G4Threading::G4GetNumberOfCores();
    }
    else
    {
      nThreads = G4UIcommand::ConvertToInt(commandLine->GetOption());
    }
    
    runManager->SetNumberOfThreads(nThreads);
  }
  
  G4cout << "**************************************************************"
         << "******\n===== Chem4 is started with "
         << runManager->GetNumberOfThreads() << " of "
         << G4Threading::G4GetNumberOfCores()
         << " available threads =====\n\n*************************************"
         <<"*******************************" 
         << G4endl;
#else
  G4RunManager* runManager = new G4RunManager();
#endif
  
  // Set mandatory initialization classes
  runManager->SetUserInitialization(new PhysicsList());
  runManager->SetUserInitialization(new DetectorConstruction());
  runManager->SetUserInitialization(new ActionInitialization());
  
  // Initialize G4 kernel
  runManager->Initialize();
  
  // Initialize visualization
  G4VisManager* visManager = new G4VisExecutive();
  // G4VisExecutive can take a verbosity argument - see /vis/verbose guidance.
  // G4VisManager* visManager = new G4VisExecutive("Quiet");
  visManager->Initialize();

  // Get the pointer to the User Interface manager
  G4UImanager* UImanager = G4UImanager::GetUIpointer();
  G4UIExecutive* ui(0);
  
  // interactive mode : define UI session
  if((commandLine = parser->GetCommandIfActive("-gui")))
  {
    ui = new G4UIExecutive(argc, argv, commandLine->GetOption());
    
    if (ui->IsGUI()) UImanager->ApplyCommand("/control/execute gui.mac");
    
    if (parser->GetCommandIfActive("-novis") == 0)
    {
      // visualization is used by default
      if ((commandLine = parser->GetCommandIfActive("-vis")))
      {
        // select a visualization driver if needed (e.g. HepFile)
        UImanager->ApplyCommand
        (G4String("/vis/open ") + commandLine->GetOption());
      }
      else
      {
        // by default OGL is used
        UImanager->ApplyCommand("/vis/open OGL 800x600-0+0");
      }
      UImanager->ApplyCommand("/control/execute vis.mac");
    }
  }
  else
  {
    // to be use visualization file (= store the visualization into
    // an external file:
    // ASCIITree ;  DAWNFILE ; HepRepFile ; VRML(1,2)FILE ; gMocrenFile ...
    if((commandLine = parser->GetCommandIfActive("-vis")))
    {
      UImanager->ApplyCommand(G4String("/vis/open ")
                              + commandLine->GetOption());
      UImanager->ApplyCommand("/control/execute vis.mac");
    }
  }
  
  if((commandLine = parser->GetCommandIfActive("-mac")))
  {
    G4String command = "/control/execute ";
    UImanager->ApplyCommand(command + commandLine->GetOption());
  }
  else
  {
    UImanager->ApplyCommand("/control/execute beam.in");
  }
  
  if((commandLine = parser->GetCommandIfActive("-gui")))
  {
    ui->SessionStart();
    delete ui;
  }
  
  // Job termination
  // Free the store: user actions, physics_list and detector_description are
  // owned and deleted by the run manager, so they should not be deleted
  // in the main() program !
  delete visManager;
  delete runManager;
  CommandLineParser::DeleteInstance();
  return 0;
}

unsigned int noise

(

)

Definition at line 265 of file chem4.cc.

References file.

Referenced by img::DataProviderAlg::addCoherentNoise(), img::DataProviderAlg::addWhiteNoise(), noisefilteralg::WireCellNoiseFilter::DoNoiseFilter(), genf::RKTrackRep::Extrap(), cluster::DBScanAlg::run_dbscan_cluster(), cluster::DBScanAlg::run_FN_cluster(), cluster::DBScanAlg::run_FN_naive_cluster(), cluster::fuzzyClusterAlg::run_fuzzy_cluster(), genf::GFMaterialEffects::setNoiseBrems(), SetSeed(), and genf::GFMaterialEffects::stepper().

{
#if defined(WIN32)|| defined(_WIN32)|| defined(__WIN32)&&!defined(__CYGWIN__)
  // TODO: MS Win
  return std::time(0);
#else
  unsigned int random_seed, random_seed_a, random_seed_b;
  std::ifstream file ("/dev/urandom", std::ios::binary);
  if (file.is_open())
  {
    char * memblock;
    int size = sizeof(int);
    memblock = new char [size];
    file.read (memblock, size);
    file.close();
    random_seed_a = *reinterpret_cast<int*>(memblock);
    delete[] memblock;
  }// end if
  else
  {
    random_seed_a = 0;
  }
  random_seed_b = std::time(0);
  random_seed = random_seed_a xor random_seed_b;
  return random_seed;
#endif
}

void Parse	(	int &	argc,
		char **	argv
	)

Definition at line 295 of file chem4.cc.

References parser().

Referenced by main().

{
  // Parse options given in commandLine
  //
  parser = CommandLineParser::GetParser();
  
  parser->AddCommand("-gui", Command::OptionNotCompulsory,
                     "Select geant4 UI or just launch a geant4 terminal"
                     "session",
                     "qt");
                     
  parser->AddCommand("-mac", Command::WithOption, "Give a mac file to execute",
                     "macFile.mac");

  parser->AddCommand("-seed",
                     Command::WithOption,
                     "Give a seed value in argument to be tested", "seed");
  
#ifdef G4MULTITHREADED
  parser->AddCommand("-mt",Command::WithOption,
                     "Launch in MT mode (events computed in parallel,"
                     " NOT RECOMMANDED WITH CHEMISTRY)", "2");
#endif
  
  parser->AddCommand("-chemOFF", Command::WithoutOption,
                     "Deactivate chemistry");
                     
  parser->AddCommand("-vis", Command::WithOption,
                     "Select a visualization driver", "OGL 600x600-0+0");
                     
  parser->AddCommand("-novis", Command::WithoutOption,
                     "Deactivate visualization when using GUI");
  
  parser->AddCommand("-cluster", Command::WithoutOption,
                     "Launch the code on a cluster, avoid dupplicated seeds");
  
  // If -h or --help is given in option : print help and exit
  //
  if (parser->Parse(argc, argv) != 0) // help is being printed
  {
    // if you are using ROOT, create a TApplication in this condition in order
    // to print the help from ROOT as well
    CommandLineParser::DeleteInstance();
    std::exit(0);
  }
  
  // Kill application if wrong argument in command line
  //
  if(parser->CheckIfNotHandledOptionsExists(argc, argv))
  {
    // if you are using ROOT, you should initialise your TApplication
    // before this condition
    std::exit(0);
  }
}

CommandLineParser* parser

(

0

)

Referenced by main(), Parse(), and SetSeed().

void SetSeed

(

)

Definition at line 212 of file chem4.cc.

References IsBracket(), noise(), parser(), and seed.

Referenced by main().

{  
  Command* commandLine(0);
  
  if((commandLine = parser->GetCommandIfActive("-seed")))
  {
    seed = atoi(commandLine->GetOption().c_str());
  }
  
  if(seed == 0) // If no seed given in argument, setup the seed
  {
    long jobID_int = 0;
    long noice = 0;
    
    //____________________________________
    // In case on cluster
    if((commandLine = parser->GetCommandIfActive("-cluster")))
    {
      noice = labs((long) noise());
      
      const char * env = getenv("PBS_JOBID");

      if(env)
      {
        G4String buffer(env);
        G4String jobID_string = buffer.substr(0,  buffer.find("."));
        jobID_string.erase(std::remove_if(jobID_string.begin(),
                                          jobID_string.end(),
                                          &IsBracket),
                                          jobID_string.end());
        jobID_int = atoi(jobID_string.c_str());
      }
      else
      {
        env = getenv("SGE_TASK_ID");
        if(env) jobID_int = atoi(env);
      }
    } // end cluster
    
    //____________________________________
    seed = ((long) time(NULL)) + jobID_int + noice;
  }
  
  G4cout << "Seed used : " << seed << G4endl;
  G4Random::setTheEngine(new CLHEP::MixMaxRng());
  G4Random::setTheSeed(seed);

  // Choose the Random engine
  // CLHEP::HepRandom::setTheEngine(new CLHEP::RanecuEngine);
}

Variable Documentation

long seed = 0

Definition at line 68 of file chem4.cc.

Referenced by evgen::ActiveVolumeVertexSampler::ActiveVolumeVertexSampler(), trkf::SeedAna::analyze(), lar_pandora::LArPandoraHelper::CollectSeeds(), rndm::details::RangeCheckHelper< SEED >::configure(), rndm::NuRandomService::createEngine(), rndm::details::PerEventPolicy< SEED >::createEventSeed(), rndm::NuRandomService::defineEngineID(), rndm::details::PerEventPolicy< SEED >::EventTimestamp_v1(), rndm::NuRandomService::findSeed(), rndm::SeedMaster< SEED >::freezeSeed(), evgen::GENIEGen::GENIEGen(), rndm::SeedMaster< seed_t >::getCurrentSeed(), rndm::SeedMaster< SEED >::getEventSeed(), rndm::details::CheckedRangePolicy< SEED >::getSeed(), rndm::SeedMaster< SEED >::getSeed(), cmtool::CMatchManager::IterationProcess(), main(), evgen::MARLEYHelper::MARLEYHelper(), rndm::details::RandomPolicy< SEED >::RandomImpl::master_seed(), evgen::NeutronOsc::NeutronOsc(), evgen::NucleonDecay::NucleonDecay(), std::hash< std::tuple< TT... > >::operator()(), rndm::details::RangeCheckHelper< seed_t >::operator()(), rndm::NuRandomService::print(), TrackProducerFromPFParticle::produce(), trkf::CCTrackMaker::produce(), rndm::NuRandomService::registerEngine(), rndm::SeedMaster< SEED >::reseed(), rndm::SeedMaster< SEED >::reseedEvent(), rndm::NuRandomService::reseedInstance(), SetSeed(), and evgen::SingleGen::SingleGen().