BLCMDmovie Class Reference

Inheritance diagram for BLCMDmovie:

List of all members.

---

Detailed Description

class BLCMDmovie - output NTuple-s suitable for a movie

Public Member Functions
	BLCMDmovie ()
G4String	commandName ()
int	command (BLArgumentVector &argv, BLArgumentMap &namedArgs)
void	defineNamedArgs ()
void	interpolate (double t, double &Zref, double &Ptot)
void	dumpGeometry (G4VPhysicalVolume *phys, G4ThreeVector &parent_offset, G4RotationMatrix &parent_rot)
void	dumpGeometry (G4VPhysicalVolume *phys)
void	callback (int type)
	callback() from BLCallback.
void	UserSteppingAction (const G4Step *step)
	UserSteppingAction() from BLManager::SteppingAction.
virtual void	PreUserTrackingAction (const G4Track *track)
	from BLManager::TrackingAction
virtual void	PostUserTrackingAction (const G4Track *track)
void	referenceStep (const G4Track *track)
void	beamStep (const G4Track *track)
void	generateFakeReference ()
Private Attributes
G4String	coordinates
BLCoordinateType	coordinateType
BLNTuple *	outline
BLNTuple *	reference
BLNTuple *	trace
BLNTuple *	elements
BLManager *	manager
std::vector< double >	timeV
std::vector< double >	ZrefV
std::vector< double >	PtotV

---

Constructor & Destructor Documentation

BLCMDmovie::BLCMDmovie

(

)

References BLCMDTYPE_OTHER, coordinates, elements, manager, outline, reference, BLCommand::registerCommand(), BLCommand::setDescription(), BLCommand::setSynopsis(), and trace.

                       : BLCallback(), BLManager::SteppingAction(),
                                                timeV(), ZrefV(), PtotV()
{
        registerCommand(BLCMDTYPE_OTHER);
        setSynopsis("Generate movie NTuple.");
        setDescription("This command outputs a set of NTuples suitable for "
                "generating a movie.");

        // initialize class variables here
        coordinates = "Reference";
        outline = 0;
        reference = 0;
        trace = 0;
        elements = 0;
        manager = 0;
}

---

Member Function Documentation

G4String BLCMDmovie::commandName

(

)

[inline, virtual]

Implements BLCommand.

{ return "movie"; }

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

Implements BLCommand.

References BLCOORD_REFERENCE, coordinates, coordinateType, BLNTuple::create(), ElementFields, elements, generateFakeReference(), BLCoordinates::getCoordinateType(), BLManager::getObject(), BLCommand::handleNamedArgs(), manager, BLCommand::print(), reference, ReferenceFields, BLManager::registerBeamStep(), BLManager::registerCallback(), BLManager::registerReferenceParticleStep(), BLManager::registerTrackingAction(), trace, TrackFields, and BLCoordinates::useReferenceCoordinates().

{
        manager = BLManager::getObject();

        handleNamedArgs(namedArgs);

        print("");

        coordinateType = BLCoordinates::getCoordinateType(coordinates);

        // register reference coords before registering ourselves
        if(coordinateType == BLCOORD_REFERENCE)
                BLCoordinates::useReferenceCoordinates();

        manager->registerTrackingAction(this);
        manager->registerReferenceParticleStep(0,this);
        manager->registerBeamStep(0,this);
        manager->registerCallback(this,0);
        manager->registerCallback(this,1);
        manager->registerCallback(this,4);

        //outline = BLNTuple::create("root", "Movie", "Outline",
        //                                              OutlineFields, "");
        reference = BLNTuple::create("root", "Movie", "Reference", 
                                                        ReferenceFields, "");
        trace = BLNTuple::create("root", "Movie", "Tracks", 
                                                        TrackFields, "");
        elements = BLNTuple::create("root","Movie","Elements",ElementFields,"");

        if(coordinateType != BLCOORD_REFERENCE)
                generateFakeReference();

        print("");

        return 0;
}

void BLCMDmovie::defineNamedArgs

(

)

[virtual]

Reimplemented from BLCommand.

References BLCommand::argString(), and coordinates.

{
        argString(coordinates,"coordinates","Coordinates: global, centerline, or reference (default=r).");
}       

void BLCMDmovie::interpolate	(	double	t,
		double &	Zref,
		double &	Ptot
	)

References BLAssert, PtotV, timeV, and ZrefV.

Referenced by beamStep().

{
        if(timeV.size() < 2) {
                Zref = 0.0;
                Ptot = 0.0;
                return;
        }

        // simple linear search
        unsigned i;
        for(i=1; i<timeV.size(); ++i) {
                if(t < timeV[i]) break;
        }
        if(i >= timeV.size()) i = timeV.size() - 1;
        // now i points to the second entry to use for linear interpolation
        // (extrapolates the first or last pair if t is too small or too big).
        BLAssert(i > 0 && i < timeV.size());
        double f = (t - timeV[i-1])/(timeV[i] - timeV[i-1]);
        Zref = (1.0-f)*ZrefV[i-1] + f*ZrefV[i];
        Ptot = (1.0-f)*PtotV[i-1] + f*PtotV[i];
}

void BLCMDmovie::dumpGeometry	(	G4VPhysicalVolume *	phys,
		G4ThreeVector &	parent_offset,
		G4RotationMatrix &	parent_rot
	)

References BLNTuple::appendRow(), BLAssert, coordinateType, elements, BLCoordinates::getCoords(), N_POINTS_ON_SURFACE, NElementFields, and BLCoordinates::setGlobal().

Referenced by callback().

{
        static BLCoordinates coord;
        static int number=0;

        G4ThreeVector my_offset = parent_offset + 
                                parent_rot * phys->GetObjectTranslation();
        G4RotationMatrix my_rot = 
                        parent_rot * phys->GetObjectRotationValue();
        G4LogicalVolume *log = phys->GetLogicalVolume();
        const G4VisAttributes *va = log->GetVisAttributes();
        if(va->IsVisible()) {
                G4VSolid *solid = log->GetSolid();
                double Xmin=DBL_MAX, Xmax=-DBL_MAX, Ymin=DBL_MAX, Ymax=-DBL_MAX;
                double Zmin=DBL_MAX, Zmax=-DBL_MAX;
                // find the element's extent in the desired coordinates by
                // generating points on its surface -- simple but slow.
                for(int i=0; i<N_POINTS_ON_SURFACE; ++i) {
                        G4ThreeVector p = solid->GetPointOnSurface();
                        p = my_rot * p + my_offset;
#ifdef DISPLAY_VISIBLE_MARKERS
display_dot(&p);
#endif
                        coord.setGlobal(p,0.0);
                        coord.getCoords(coordinateType,p);
                        if(Xmin > p[0]) Xmin = p[0];
                        if(Xmax < p[0]) Xmax = p[0];
                        if(Ymin > p[1]) Ymin = p[1];
                        if(Ymax < p[1]) Ymax = p[1];
                        if(Zmin > p[2]) Zmin = p[2];
                        if(Zmax < p[2]) Zmax = p[2];
                }
                BLAssert(NElementFields == 10);
                double data[NElementFields];
                data[0] = ++number;
                data[1] = Xmin;
                data[2] = Xmax;
                data[3] = Ymin;
                data[4] = Ymax;
                data[5] = Zmin;
                data[6] = Zmax;
                data[7] = va->GetColor().GetRed();
                data[8] = va->GetColor().GetGreen();
                data[9] = va->GetColor().GetBlue();
                elements->appendRow(data,NElementFields);
        }
        int n = log->GetNoDaughters();
        for(int i=0; i<n; ++i) {
                G4VPhysicalVolume *p = log->GetDaughter(i);
                if(!p) continue;
                dumpGeometry(p,my_offset,my_rot);
        }
}

void BLCMDmovie::dumpGeometry

(

G4VPhysicalVolume *

phys

)

void BLCMDmovie::callback

(

int

type

)

[virtual]

callback() from BLCallback.

Reimplemented from BLCallback.

References dumpGeometry(), BLManager::getWorldPhysicalVolume(), and manager.

{
        if(type == 0)  {        // pre-tune callback
        } else if(type == 1) {  // post-reference callback
                G4ThreeVector offset;
                G4RotationMatrix rot;
                printf("Generating Movie/Elements NTuple... "); fflush(stdout);
                dumpGeometry(manager->getWorldPhysicalVolume(),offset,rot);
                printf("Done.\n"); fflush(stdout);
        } else if(type == 4) {  // visualization
#ifdef DISPLAY_VISIBLE_MARKERS
                G4ThreeVector offset;
                G4RotationMatrix rot;
                printf("Generating Movie/Elements NTuple... "); fflush(stdout);
                dumpGeometry(manager->getWorldPhysicalVolume(),offset,rot);
                printf("Done.\n"); fflush(stdout);
                display_dot(0);
#endif
        }
}

void BLCMDmovie::UserSteppingAction

(

const G4Step *

step

)

[virtual]

UserSteppingAction() from BLManager::SteppingAction.

Implements BLManager::SteppingAction.

References BEAM, beamStep(), BLCOORD_REFERENCE, coordinateType, BLManager::getState(), IDLE, manager, REFERENCE, referenceStep(), SPECIAL, TUNE, and VISUAL.

{
        switch(manager->getState()) {
        case IDLE:
                break;
        case VISUAL:
                break;
        case TUNE:
                break;
        case REFERENCE:
                if(coordinateType == BLCOORD_REFERENCE)
                        referenceStep(step->GetTrack());
                break;
        case BEAM:
                beamStep(step->GetTrack());
                break;
        case SPECIAL:
                break;
        }
}

void BLCMDmovie::PreUserTrackingAction

(

const G4Track *

track

)

[virtual]

from BLManager::TrackingAction

Implements BLManager::TrackingAction.

References BLCOORD_REFERENCE, coordinateType, BLManager::getState(), manager, REFERENCE, and referenceStep().

{
        if(manager->getState() == REFERENCE && 
           coordinateType == BLCOORD_REFERENCE)
                referenceStep(track);
        //@ if(manager->getState() == BEAM) beamStep(track);
}

void BLCMDmovie::PostUserTrackingAction

(

const G4Track *

track

)

[virtual]

Implements BLManager::TrackingAction.

References BEAM, beamStep(), BLCOORD_REFERENCE, coordinateType, BLManager::getState(), manager, REFERENCE, and referenceStep().

{
        if(manager->getState() == REFERENCE && 
           coordinateType == BLCOORD_REFERENCE)
                referenceStep(track);
        if(manager->getState() == BEAM) beamStep(track);
}

void BLCMDmovie::referenceStep

(

const G4Track *

track

)

References BLNTuple::appendRow(), BLAssert, BLCOORD_CENTERLINE, BLCoordinates::getCoords(), BLCoordinates::getMostRecentReferenceZ(), BLCoordinates::isValid(), NReferenceFields, PtotV, reference, timeV, and ZrefV.

Referenced by PostUserTrackingAction(), PreUserTrackingAction(), and UserSteppingAction().

{
        G4ThreeVector posGlobal = track->GetPosition();
        G4ThreeVector posCL = posGlobal;
        G4double Zref = BLCoordinates::getMostRecentReferenceZ();
        G4double time = track->GetGlobalTime();
        G4ThreeVector momentum = track->GetMomentum();

        // transform to centerline coordinates
        BLCoordinates *c = (BLCoordinates *)track->GetUserInformation();
        if(c && c->isValid()) {
                c->getCoords(BLCOORD_CENTERLINE,posCL);
        }

        // enter this step into interpolation vectors.
        if(timeV.size() == 0 || time-timeV.back() > 1.0*picosecond) {
                timeV.push_back(time);
                ZrefV.push_back(Zref);
                PtotV.push_back(momentum.mag());
        }

        BLAssert(NReferenceFields == 9);
        double data[NReferenceFields];
        data[0] = time/ns;
        data[1] = Zref/mm;
        data[2] = posCL[0]/mm;
        data[3] = posCL[1]/mm;
        data[4] = posCL[2]/mm;
        data[5] = posGlobal[0]/mm;
        data[6] = posGlobal[1]/mm;
        data[7] = posGlobal[2]/mm;
        data[8] = momentum.mag()/MeV;

        reference->appendRow(data,NReferenceFields);
}

void BLCMDmovie::beamStep

(

const G4Track *

track

)

References BLNTuple::appendRow(), BLAssert, BLCOORD_REFERENCE, coordinateType, BLCoordinates::getCoords(), BLManager::getExternalParentID(), BLManager::getExternalTrackID(), BLManager::getObject(), BLCoordinates::getRotation(), interpolate(), BLCoordinates::isValid(), NTrackFields, and trace.

Referenced by PostUserTrackingAction(), and UserSteppingAction().

{
        G4RunManager* runmgr = G4RunManager::GetRunManager();
        const G4Event* event = runmgr->GetCurrentEvent();
        int evNum = event->GetEventID();
        G4ThreeVector position = track->GetPosition();
        G4double time = track->GetGlobalTime();
        G4ThreeVector momentum = track->GetMomentum();

        // transform to desired coordinates
        BLCoordinates *c = (BLCoordinates *)track->GetUserInformation();
        if(c && c->isValid()) {
                c->getCoords(coordinateType,position);
                momentum = c->getRotation() * momentum;
        }

        // subtract interpolated Zref and Pref for reference coords
        if(coordinateType == BLCOORD_REFERENCE) {
                double Zref, Pref;
                interpolate(time,Zref,Pref);
                position[2] -= Zref;
                momentum[2] -= Pref;
        }

        BLAssert(NTrackFields == 12);
        double data[NTrackFields];
        data[0] = position[0]/mm;               // x (mm)
        data[1] = position[1]/mm;               // y (mm)
        data[2] = position[2]/mm;               // z (mm)
        data[3] = momentum[0]/MeV;              // Px (MeV/c)
        data[4] = momentum[1]/MeV;              // Py (MeV/c)
        data[5] = momentum[2]/MeV;              // Pz (MeV/c)
        data[6] = time/ns;                      // t (ns)
        data[7] = track->GetDefinition()->GetPDGEncoding();
        data[8] = evNum;                                // Event ID
        data[9] = 
            BLManager::getObject()->getExternalTrackID(track);
        data[10] = 
            BLManager::getObject()->getExternalParentID(track);
        data[11] = track->GetWeight();          // Weight

        trace->appendRow(data,NTrackFields);
}

void BLCMDmovie::generateFakeReference

(

)

References BLNTuple::appendRow(), BLAssert, NReferenceFields, and reference.

Referenced by command().

{
        BLAssert(NReferenceFields == 9);
        double data[NReferenceFields];
        data[0] = -(DBL_MAX/4.0);
        data[1] = -(DBL_MAX/4.0);
        data[2] = 0.0;
        data[3] = 0.0;
        data[4] = 0.0;
        data[5] = 0.0;
        data[6] = 0.0;
        data[7] = 0.0;
        data[8] = 0.0;
        reference->appendRow(data,NReferenceFields);

        data[0] = (DBL_MAX/4.0);
        data[1] = (DBL_MAX/4.0);
        reference->appendRow(data,NReferenceFields);
}

---

Member Data Documentation

G4String BLCMDmovie::coordinates [private]

Referenced by BLCMDmovie(), command(), and defineNamedArgs().

BLCoordinateType BLCMDmovie::coordinateType [private]

Referenced by beamStep(), command(), dumpGeometry(), PostUserTrackingAction(), PreUserTrackingAction(), and UserSteppingAction().

BLNTuple* BLCMDmovie::outline [private]

Referenced by BLCMDmovie().

BLNTuple* BLCMDmovie::reference [private]

Referenced by BLCMDmovie(), command(), generateFakeReference(), and referenceStep().

BLNTuple* BLCMDmovie::trace [private]

Referenced by beamStep(), BLCMDmovie(), and command().

BLNTuple* BLCMDmovie::elements [private]

Referenced by BLCMDmovie(), command(), and dumpGeometry().

BLManager* BLCMDmovie::manager [private]

Referenced by BLCMDmovie(), callback(), command(), PostUserTrackingAction(), PreUserTrackingAction(), and UserSteppingAction().

std::vector<double> BLCMDmovie::timeV [private]

Referenced by interpolate(), and referenceStep().

std::vector<double> BLCMDmovie::ZrefV [private]

Referenced by interpolate(), and referenceStep().

std::vector<double> BLCMDmovie::PtotV [private]

Referenced by interpolate(), and referenceStep().

---

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

• BLCMDmovie.cc