g4beamline.cc File Reference

#include <unistd.h>
#include <vector>
#include "G4NistManager.hh"
#include "G4GeometryManager.hh"
#include "BLMPI.hh"
#include "BLNTuple.hh"
#include "BLParam.hh"
#include "BLCommand.hh"
#include "BLGroup.hh"
#include "BLManager.hh"
#include "BLTime.hh"

Functions
void	startupPrint (bool continuing)
void	g4bl_exit (int value)
int	main (int argc, char *argv[])
Variables
BLSetParam	maxStep ("maxStep","100.0","Maximum physics step size (mm)")
BLSetParam	worldMaterial ("worldMaterial","Vacuum","Material of the World volume")

---

Function Documentation

void startupPrint

(

bool

continuing

)

Referenced by BLCMDoutput::command(), and main().

{
        printf("*************************************************************\n");
        printf(" g4beamline version: %s                    (%s)\n",G4BLVERSION,G4BLDATE);
        printf("                      Copyright : Tom Roberts, Muons, Inc.\n");
        printf("                        License : Gnu Public License\n");
        printf("                            WWW : http://g4beamline.muonsinc.com");
        if(!continuing)
                printf("\n*************************************************************\n\n");
        fflush(stdout); // for checking the program started up
}

void g4bl_exit

(

int

value

)

Referenced by BLCMDprobefield::callback(), BLCMDprintfield::callback(), BLCMDfieldntuple::callback(), BLCMDfieldlines::callback(), BLCMDrfdevice::command(), BLCMDpillbox::command(), BLCMDlist::command(), BLCMDhelp::command(), BLCMDprintfield::do_points(), SetDecayInstance::fatalError(), BLManager::handleCallbacks(), main(), BLManager::Notify(), and BLSignal::sighandler().

{
        // Instead of deleting things, just open the geometry to avoid 
        // warnings when exit() is called.
        G4GeometryManager::GetInstance()->OpenGeometry();

        fflush(stdout);
        exit(value);
}

int main	(	int	argc,
		char *	argv[]
	)

References BLElement::allOK(), BLNTuple::closeAll(), BLManager::delayedConstruction(), BLNTuple::disableOutputFiles(), BLManager::displayVisual(), BLCommand::doCommand(), BLGroup::end(), g4bl_exit(), BLCommand::getErrorCount(), BLManager::getObject(), BLParam::getString(), BLGroup::getWorld(), BLManager::handleCallbacks(), BLMPI::init(), BLManager::initialize(), BLMPI::isMPI(), BLCommand::isValidCommand(), BLMPI::main(), BLManager::nReference(), Param, BLParam::printParam(), BLCommand::readFile(), BLGroup::setMaterial(), BLParam::setParam(), startupPrint(), BLNTuple::summary(), BLTime::timems(), BLManager::trackBeam(), and BLManager::trackTuneAndReferenceParticles().

{
#ifdef WIN32
        int crtflg = _CrtSetDbgFlag( _CRTDBG_REPORT_FLAG ) |
                        _CRTDBG_ALLOC_MEM_DF |
                        _CRTDBG_DELAY_FREE_MEM_DF |
                        _CRTDBG_CHECK_ALWAYS_DF;
        _CrtSetDbgFlag(crtflg); 
#endif

        // initialize and set up MPI, if appropriate.
        // Sets stderr and stdout to /dev/null except for rank 0 or non-MPI.
        BLMPI::init(&argc,&argv);

        // print our process ID (for g4blgui to properly terminate me)
#ifdef WIN32
        printf("G4beamline Process ID %d\n\n",_getpid());
#else
        printf("G4beamline Process ID %d\n\n",getpid());
#endif

        startupPrint(true);

        if(argc < 2) {
            printf("USAGE: g4beamline inputfile [viewer=TYPE] [param=value...]\n");
            printf("     viewer=best  (any valid viewer) Display detector and events visually\n");
            printf("     viewer=none    (default) Track beam.\n");
            printf("\n");
            printf("     Commands used by each viewer are in the file viewer.def\n");
            ::exit(1);
        }

        // set PRNG seed from the clock. Note the seed is probably re-set
        // at the start of each event, according to the randomseed command
        // (event number if no such command).
        CLHEP::HepRandom::setTheSeed(BLTime::timems() & 0x7FFFFFFFL);

        // Ensure the BLManager has been created, and do its delayed constuction
        BLManager *mgr = BLManager::getObject();
        mgr->delayedConstruction();

        // Handle arguments 2 thru argc-1 as arguments to the param command
        // They should be of the form name=value or name="a value with spaces"
        // Arguments that consist of a valid command will be kept until all
        // parameters are defined, and then will be executed in order.
        // Remember the shell will eat " and '
        G4String cmd("param");
        std::vector<G4String> argCommands;
        for(int i=2; i<argc; ++i) {
                cmd += " ";
                G4String s(argv[i]);
                G4String::size_type p = s.find("=");
                if(p == s.npos || s.find(" ") < p) {
                        p = s.find(" ");
                        G4String c = s.substr(0,p);
                        if(BLCommand::isValidCommand(c))
                            argCommands.push_back(s);
                        else
                            printf("*** g4beamline: invalid arg '%s' ignored\n",
                                        s.c_str());
                        continue;
                }
                cmd += s.substr(0,p+1);
                if(s.find("'") == s.npos) {
                        cmd += "'";
                        cmd += s.substr(p+1);
                        cmd += "'";
                } else if(s.find('"') == s.npos) {
                        cmd += '"';
                        cmd += s.substr(p+1);
                        cmd += '"';
                } else {
                        cmd += s;
                }
        }
        if(cmd.find("=") != cmd.npos)
                BLCommand::doCommand(cmd);
        for(unsigned i=0; i<argCommands.size(); ++i)
                BLCommand::doCommand(argCommands[i]);

        // arrange to perform a geometry test
        cmd = "geometry";
        BLCommand::doCommand(cmd);

        // don't write output files in visual mode
        G4String viewer = Param.getString("viewer");
        if(viewer != "none") {
                BLNTuple::disableOutputFiles();
                if(BLMPI::isMPI()) {
                        G4Exception("main","Viewer and MPI",FatalException,
                                "Visualization cannot be used in MPI mode.");
                }
        }

        // read input file and end the World volume
        if(BLCommand::readFile(argv[1]) != 0) {
                char tmp[64];
                sprintf(tmp,"There were %d errors in the input",
                                BLCommand::getErrorCount());
                G4Exception("main","Input Errors",FatalException,tmp);
        }
        BLGroup::getWorld()->end();

        // quit if world is empty
        if(BLGroup::getWorld()->getNChildren() == 0) {
                G4Exception("main","Empty World",FatalException,
                        "No elements have been placed into the World");
        }

        // verify that viewer did not change from command-line
        if(viewer != Param.getString("viewer"))
                G4Exception("main","Viewer changed",FatalException,
                  "The viewer parameter may only be set on the command-line.");

        Param.printParam();

        // use the worldMaterial.
        BLGroup::getWorld()->setMaterial(Param.getString("worldMaterial"));

        // initialize BLManager (construct the geometry, etc.)
        mgr->initialize();

        // handle pre-reference callbacks
        mgr->handleCallbacks(0);

        // Track reference particle(s), if present
        if(mgr->nReference() > 0)
                mgr->trackTuneAndReferenceParticles();

        // handle post-reference callbacks
        mgr->handleCallbacks(1);

        // handle MPI (never returns if in MPI mode).
        BLMPI::main();

        // handle replace main loop callbacks
        mgr->handleCallbacks(3);

        if(viewer != "none") {
#ifdef WIN32
                if(viewer == "best") Param.setParam("viewer","OIWin32");
#else
                if(viewer == "best") Param.setParam("viewer","OIX");
#endif
                if(!BLElement::allOK())
                        G4Exception("main","Element Error",JustWarning,
                            "Not all BLElement-s are OK -- continuing anyway");
                mgr->displayVisual();
        } else {
                if(!BLElement::allOK()) {
                        G4Exception("main","Element Error",FatalException,
                                "Not all BLElement-s are OK");
                }
                mgr->trackBeam();
                BLNTuple::summary();
                BLNTuple::closeAll();
        }

        // handle post-tracking callbacks
        mgr->handleCallbacks(2);

        G4cout << "g4beamline: simulation complete -- exiting" << G4endl;
        delete mgr;

        g4bl_exit(0);
}

---

Variable Documentation

BLSetParam maxStep("maxStep","100.0","Maximum physics step size (mm)")

BLSetParam worldMaterial("worldMaterial","Vacuum","Material of the World volume")