BLCMDtotalenergy Class Reference

Inheritance diagram for BLCMDtotalenergy:

List of all members.

---

Detailed Description

class BLCMDtotalenergy prints the total energy deposited into each selected volume, at the end of the run.

Public Member Functions
	BLCMDtotalenergy ()
	Constructor.
virtual G4String	commandName ()
	commandName() returns "totalenergy".
virtual int	command (BLArgumentVector &argv, BLArgumentMap &namedArgs)
	command() implements the totalenergy command.
virtual void	defineNamedArgs ()
	defineNamedArgs() defines the named arguments for this command.
void	callback (int type)
	callback() from BLCallback.
void	walkPVTree (G4VPhysicalVolume *pv, G4String indent="")
	walk the tree of physical volumes
bool	isMatch (G4VPhysicalVolume *pv)
	isMatch() returns true if the name of this PV matches some pattern
void	sum (const G4TouchableHandle &th, double energy)
	sum() will sum the energy into the relevant volumes.
void	UserSteppingAction (const G4Step *step)
	UserSteppingAction() from BLManager::SteppingAction.
void	PreUserTrackingAction (const G4Track *track)
	PreUserTrackingAction() from BLManager::TrackingAction.
void	PostUserTrackingAction (const G4Track *track)
	PostUserTrackingAction() from BLManager::TrackingAction.
Private Attributes
G4String	volumes
G4int	ancestors
G4String	filename
bool	alreadyRegistered
std::map< G4VPhysicalVolume *, Totalizer >	total
std::vector< G4VPhysicalVolume * >	printOrder
std::vector< G4String >	patterns
G4VPhysicalVolume *	world
Classes
struct	Totalizer

---

Constructor & Destructor Documentation

BLCMDtotalenergy::BLCMDtotalenergy

(

)

Constructor.

References alreadyRegistered, ancestors, BLCMDTYPE_DATA, filename, BLCommand::registerCommand(), BLCommand::setDescription(), BLCommand::setSynopsis(), and world.

                                   : volumes("*"), total(), printOrder(), 
                                                        patterns()
{
        registerCommand(BLCMDTYPE_DATA);
        setSynopsis("Print total energy deposited in selected volumes.");
        setDescription("At end of run, prints the total energy deposited in "
                "the selected volumes.\n\n"
                "Volume-name patterns are like UNIX filename patterns: "
                "e.g. '*[AB]*' matches any name containing an A or a B.\n\n"
                "Tracks that are killed have their kinetic energy summed into "
                "the volume where they were killed, unless they are killed "
                "because they leave the World.\n\n"
                "With ancestors=1, energy deposited in matching volumes is "
                "added into their ancestors; energy deposited directly into "
                "those ancestors is not summed into them unless their names "
                "also match. "
                "That is, if A is a child of B, but only A matches the list "
                "of volume-names, energy "
                "deposited into A will be reported in both A and B, but energy "
                "deposited directly into B is ignored.");

        ancestors = 0;
        filename = "";
        alreadyRegistered = false;
        world = 0; // initialized in callback()
}

---

Member Function Documentation

virtual G4String BLCMDtotalenergy::commandName

(

)

[inline, virtual]

commandName() returns "totalenergy".

Implements BLCommand.

{ return "totalenergy"; }

int BLCMDtotalenergy::command	(	BLArgumentVector &	argv,
		BLArgumentMap &	namedArgs
	)			[virtual]

command() implements the totalenergy command.

Implements BLCommand.

References alreadyRegistered, BLManager::getObject(), BLCommand::handleNamedArgs(), patterns, BLCommand::print(), BLCommand::printError(), BLManager::registerBeamStep(), BLManager::registerCallback(), BLManager::registerTrackingAction(), BLCommand::splitString(), and volumes.

{
        int retval = handleNamedArgs(namedArgs);

        if(alreadyRegistered) {
                printError("Duplicate totalenergy command");
                return -1;
        }

        BLManager::getObject()->registerCallback(this,0);
        BLManager::getObject()->registerCallback(this,2);
        BLManager::getObject()->registerBeamStep(0,this);
        BLManager::getObject()->registerTrackingAction(this);
        alreadyRegistered = true;

        print("");

        patterns = splitString(volumes, ",", true);

        return retval;
}

void BLCMDtotalenergy::defineNamedArgs

(

)

[virtual]

defineNamedArgs() defines the named arguments for this command.

Reimplemented from BLCommand.

References ancestors, BLCommand::argInt(), BLCommand::argString(), filename, and volumes.

{
        argString(volumes,"volumes","Comma-separated list of Volume-Name patterns (*)");
        argInt(ancestors,"ancestors","Set nonzero to sum energy into all ancestor (enclosing) volumess (0).");
        argInt(ancestors,"enclosing","Synonym for ancestors.");
        argString(filename,"filename","Filename to write summary (stdout).");
        argString(filename,"file","Synonym for filename.");
}

void BLCMDtotalenergy::callback

(

int

type

)

[virtual]

callback() from BLCallback.

Reimplemented from BLCallback.

References BLAsciiFile::fclose(), filename, BLAsciiFile::fopen(), BLManager::getObject(), BLManager::getWorldPhysicalVolume(), BLCommand::printError(), printOrder, total, walkPVTree(), and world.

{
        if(type == 0) { 
                // Walk the tree of physical volumes
                printf("\nPhysical volumes for totalenergy (* = totaled):\n");
                world = BLManager::getObject()->getWorldPhysicalVolume();
                walkPVTree(world);
        } else if(type == 2) {
                FILE *out=stdout;
                if(filename.size() > 0) {
                        out = BLAsciiFile::fopen(filename);
                        if(!out) {
                                printError("Cannot write to '%s' - stdout used\n",
                                        filename.c_str());
                                out = stdout;
                        }
                }
                fprintf(out,"# Total energy deposited in selected volumes (MeV):\n");
                for(unsigned i=0; i<printOrder.size(); ++i) {
                        G4VPhysicalVolume *pv = printOrder[i];
                        double t=total[pv].total/MeV;
                        if(t < 10.0)
                            fprintf(out,"%s\t%.6f\n",pv->GetName().c_str(),t);
                        else if(t < 10000.0)
                            fprintf(out,"%s\t%.3f\n",pv->GetName().c_str(),t);
                        else if(t < 100000.0)
                            fprintf(out,"%s\t%.1f\n",pv->GetName().c_str(),t);
                        else
                            fprintf(out,"%s\t%.4g\n",pv->GetName().c_str(),t);
                }
                if(out != stdout) BLAsciiFile::fclose(out);
        }
}

void BLCMDtotalenergy::walkPVTree	(	G4VPhysicalVolume *	pv,
		G4String	indent = ""
	)

walk the tree of physical volumes

References isMatch(), printOrder, and total.

Referenced by callback().

{
        printf("%s%s",indent.c_str(),pv->GetName().c_str());
        if(isMatch(pv)) {
                printf(" *");
                if(total.count(pv) != 0)
                        G4Exception("totalenergy command",
                                "Duplicate PhysicalVolume cut",JustWarning, "");
                total[pv] = Totalizer();
                printOrder.push_back(pv);
        }
        printf("\n");

        G4LogicalVolume *lv = pv->GetLogicalVolume();
        int n=lv->GetNoDaughters();
        for(int i=0; i<n; ++i)
                walkPVTree(lv->GetDaughter(i),indent+"    ");
}

bool BLCMDtotalenergy::isMatch

(

G4VPhysicalVolume *

pv

)

isMatch() returns true if the name of this PV matches some pattern

References fnmatch(), and patterns.

Referenced by walkPVTree().

{
        const char *name = pv->GetName().c_str();
        for(unsigned i=0; i<patterns.size(); ++i) {
                if(patterns[i].size() == 0) continue;
                if(fnmatch(patterns[i].c_str(),name,0) == 0)
                        return true;
        }
        return false;
}

void BLCMDtotalenergy::sum	(	const G4TouchableHandle &	th,
		double	energy
	)

sum() will sum the energy into the relevant volumes.

References ancestors, total, and world.

Referenced by PostUserTrackingAction(), and UserSteppingAction().

{
        if(!th) return;

        for(int depth=0; depth<=th->GetHistoryDepth(); ++depth) {
                G4VPhysicalVolume *pv = th->GetVolume(depth);
                if(!pv) break;
                if(depth == 0 && total.count(pv) == 0) break;
                total[pv].total += energy; // create if needed
                if(pv == world) break;
                if(!ancestors) break;
        }
}

void BLCMDtotalenergy::UserSteppingAction

(

const G4Step *

step

)

[virtual]

UserSteppingAction() from BLManager::SteppingAction.

Implements BLManager::SteppingAction.

References sum().

{
        G4StepPoint *prePoint = step->GetPreStepPoint();
        if(!prePoint) return;
        G4double energy = step->GetTotalEnergyDeposit();
        sum(prePoint->GetTouchableHandle(),energy);
}

void BLCMDtotalenergy::PreUserTrackingAction

(

const G4Track *

track

)

[virtual]

PreUserTrackingAction() from BLManager::TrackingAction.

Implements BLManager::TrackingAction.

{
}

void BLCMDtotalenergy::PostUserTrackingAction

(

const G4Track *

track

)

[virtual]

PostUserTrackingAction() from BLManager::TrackingAction.

Implements BLManager::TrackingAction.

References sum().

{
        if(track->GetTrackStatus() == fSuspend) return;
        if(track->GetNextVolume() == 0) return; // don't sum if leaving World
        sum(track->GetTouchableHandle(),track->GetKineticEnergy());
}

---

Member Data Documentation

G4String BLCMDtotalenergy::volumes [private]

Referenced by command(), and defineNamedArgs().

G4int BLCMDtotalenergy::ancestors [private]

Referenced by BLCMDtotalenergy(), defineNamedArgs(), and sum().

G4String BLCMDtotalenergy::filename [private]

Referenced by BLCMDtotalenergy(), callback(), and defineNamedArgs().

bool BLCMDtotalenergy::alreadyRegistered [private]

Referenced by BLCMDtotalenergy(), and command().

std::map<G4VPhysicalVolume*,Totalizer> BLCMDtotalenergy::total [private]

Referenced by callback(), sum(), and walkPVTree().

std::vector<G4VPhysicalVolume*> BLCMDtotalenergy::printOrder [private]

Referenced by callback(), and walkPVTree().

std::vector<G4String> BLCMDtotalenergy::patterns [private]

Referenced by command(), and isMatch().

G4VPhysicalVolume* BLCMDtotalenergy::world [private]

Referenced by BLCMDtotalenergy(), callback(), and sum().

---

The documentation for this class was generated from the following file:

• BLCMDtotalenergy.cc