BLCoordinates Class Reference

#include <BLCoordinates.hh>

Inheritance diagram for BLCoordinates:

List of all members.

---

Detailed Description

class BLCoordinates manages the centerline coordinates.

Whenever an element is placed into the world group, the current centerline coordinates are normally used, rather than global coordinates (the local coordinates of the world volume/group).

Centerline coordinates are X,Y,Z, with Z along the nominal beam direction, X is beam left, and Y is beam up. The centerline itself is always X=0,Y=0, and consists of a sequence of segmentCLs each of which is straight, and the centerline is continuous at each corner (bend in the centerline). Except within bending magnets the reference particle is supposed to travel directly down the centerline. Z is continuous along the centerline, including at corners; the first segmentCL extends to Z=-infinity, and the last segmentCL extends to Z=+infinity.

Note that the coordinate transform global->centerline is NOT unique -- near corners both segmentCLs may refer to a given point. The transform centerline->global is unique for a given segmentCL. The centerline itself is continuous at corners, but tracks will in general have a discontinuity in their centerline coordinates when transitioning from one segmentCL to the next. A track will transition from one segmentCL to the next when either its Z coordinate exceeds that of the initial segmentCL's end (corner), or when its radius exceeds the radiusCut for the initial segmentCL.

Initially the centerline coordinates are identical to global coordinates. The start() function will change the starting location and orientation of the first segmentCL, and the corner() function ends the current segmentCL and begins a new one. start() must not be called after any element has been placed in the first segmentCL, or after corner() has been called.

Instances of this class represent the current centerline coordinates of a track, and are linked into the track via G4Track::SetUserInformation() (an instance is registered with BLManager to manage the instance linked into the track, and they can also be used for individual points, if necessary). Static members and functions are used to access and create the centerline segmentCLs.

Because of the need to transition tracks from one segmentCL to the next, corners with acute angles are prohibited.

NOTE: BLManager expects G4Track::GetUserInformation() to return a pointer to a BLCoordinates object, or to an object of a class derived from it. This means that any G4VUserTrackInformation class used in a simulation using BLManager should be derived from this class, and not directly from G4VUserTrackInformation (but verify is used to detect if it is not a BLCoordinates object).

Note the BLManager::UserSteppingAction() manages the updates to the current track's BLCoordinates before doing anything else.

NOTE: "CL" in a vairable means it is for centerline coordinates; "RC" means it is for reference coordinates.

Public Member Functions
	BLCoordinates ()
	Default constructor -- for UserSteppingAction or without point.
	BLCoordinates (const G4double _global[4])
	Constructor -- finds the earliest segmentCL containing the point (global coordinates).
virtual	~BLCoordinates ()
	Destructor.
void *	operator new (size_t)
	operator new - using G4Allocator. NOTE: any derived class MUST re-implement this.
void	operator delete (void *p)
	operator delete - using G4Allocator. NOTE: any derived class MUST re-implement this.
G4bool	isValid () const
	isValid() verifies that this is a valid BLCoordinates instance. NOTE: this is not virtual, and cannot be made virtual!
G4bool	setGlobal (const G4double _global[4])
	setGlobal() updates the centerline coordinates for the new point[] of the track; uses the current segmentCL #, and will update it if the track crosses into a new segmentCL. returns false if the track fails radiusCut in its current and next segmentCL (or all segmentCL if ring is true). Also updates reference coordinates, if validRC is true and the centerline radiusCut succeeded.
G4bool	setGlobal (const G4ThreeVector &pos, G4double time)
void	getCenterlineCoords (G4double local[4]) const
	getCenterlineCoords() returns the centerline coordinates. DEPRECATED: use getCoords() instead.
void	getCenterlineCoords (G4ThreeVector &local) const
void	getCoords (BLCoordinateType type, G4double local[4])
	getCoords() returns the appropriate coordinate values.
void	getCoords (BLCoordinateType type, G4ThreeVector &local)
G4double	getCLZ ()
	getCLZ() returns the centerline z coordinate.
G4RotationMatrix &	getRotation ()
	getRotation() returns the appropriate coordinate rotation for the previous call to getCoords(). Given a G4ThreeVector B in global coordinates, this transforms it to centerline components: coord->getCoords(BLCOORD_CENTERLINE,local); B = coord->getRotation() * B;
G4RotationMatrix &	getRotation (BLCoordinateType type)
	getRotation() returns the rotation for the specified coordinates. Given a G4ThreeVector B in global coordinates, this transforms it to centerline components: B = coord->getRotation(BLCOORD_CENTERLINE) * B;
G4RotationMatrix	getCenterlineRotation ()
	getCenterlineRotation() returns the rotation matrix used for the last setGlobal() of this instance. This is the rotation of the centerline wrt global coordinate axes. DEPRECATED -- use getRotation().
G4RotationMatrix	getTransformRotation ()
	getTransformRotation() returns the rotation matrix of the global -> centerline coordinate transformation; it is the inverse of getCenterlineRotation(). Given a G4ThreeVector B in global coordinates, this transforms it to centerline components: B = getTransformRotation() * B; DEPRECATED -- use getRotation().
int	getSegmentCL ()
	getSegmentCL() re turns the CL segment # (for debugging).
virtual void	Print () const
	Print from G4VUserTrackInformation.
Static Public Member Functions
static double	getCurrentRadiusCut ()
	getCurrentRadiusCut() returns the radiusCut for the current CL segment.
static void	update (G4Track *track)
	update() This function ensures that a UserTrackInformation object is linked into the track; if none is, it creates a new BLCoordinates instance and links it in. It also calls setGlobal() for the BLCoordinates linked into the track.
static void	start (const G4double point[4], G4double z, G4RotationMatrix *rotation=0, G4double radiusCut=0.0, G4bool _ring=false)
	start() sets the starting point and direction for the first segmentCL. Must not be called after corner() is called, or after any element has been placed using centerline coordinates. point[] is in global coordinates, z is the starting value of z in CENTERLINE coordinates, _ring indicates whether a ring is present (so jumps in segmentCL # are permitted), and rotation should be the rotation of the first segmentCL's centerline wrt the global coordinate axes (i.e. it is an active rotation of the centerline as an object wrt the global coordinate axes).
static void	corner (G4double z, G4RotationMatrix *rotation, G4double radiusCut)
	corner() creates a corner in the centerline by ending the current segmentCL and beginning a new one. z is the position in CENTERLINE coordinates of the current segmentCL, and rotation is relative to the current CENTERLINE coordinates (i.e. as an active rotation of the centerline as an object wrt the CENTERLINE coordinate axes of the current segmentCL). z must be greater than the centerline z of the previous corner or start. rotation can be an identity matrix (e.g. to merely set a new radiusCut).
static BLCoordinateTransform &	getCurrentTransform ()
	getCurrentTransform() returns the current BLCoordinateTransform for the centerline coordinates (i.e. the coordinate transform global->centerline of the current segmentCL).
static G4RotationMatrix *	getCurrentRotation ()
	getCurrentRotation() returns the current G4RotationMatrix for the centerline coordinates (i.e. the active rotation of the current segmentCL, as an object rotated wrt global coordinate axes). Given a G4ThreeVector B in global coordinates, this transforms it to centerline components: B = *getCurrentRotation() * B;
static void	getCurrentGlobal (const G4double local[4], G4double _global[4])
	getCurrentGlobal() returns global coordinates from centerline coordinates, using the current segmentCL.
static void	getCurrentGlobal (const G4ThreeVector &local, G4ThreeVector &_global)
	getCurrentGlobal() returns global coordinates from centerline coordinates, using the current segmentCL.
static void	getGlobalAnywhere (const G4ThreeVector &local, G4ThreeVector &_global)
	getGlobalAnywhere() returns global coordinates from centerline coordinates, using the lowest segmentCL containing local.
static G4RotationMatrix *	getGlobalRotation (const G4ThreeVector &local)
	getGlobalRotation() returns the local->global rotation matrix coordinates, using the lowest segmentCL containing local.
static G4double	getRadiusCut (const G4ThreeVector &local)
	getRadiusCut() returns the radius cut for the lowest segmentCL containing local.
static BLCoordinateType	getCoordinateType (G4String s)
	getCoordinateType() converts a G4String name to a BLCoordinateType. Names are: global, centerline, reference; only the first letter is used, case insensitive. Also enables the generation of REference Coordinates, if they are selected by s.
static void	useReferenceCoordinates ()
	useReferenceCoordinates() will arrange to fill segmentRCVector[] with reference coordinate segments as the reference particle is tracked. Must be called before the reference particle is tracked. Unless this is called, reference coordinates will not be available. Multiple calls are the same as one.
static void	setMostRecentReferenceZ (G4double z)
	setMostRecentReferenceZ() sets the most recent z value of the reference coords. VALID ONLY WHILE TRACKING REFERENCE PARTICLE!
static G4double	getMostRecentReferenceZ ()
	getMostRecentReferenceZ() returns the most recent z value of the reference coords. VALID ONLY WHILE TRACKING REFERENCE PARTICLE!
Private Types
enum	{ VERIFY = 0x13579246 }
enum	State { UNUSED, CONSTRUCTING, TRACKING }
Private Member Functions
G4bool	findCLSegment (const G4double _global[4])
void	updateReferenceCoordinates ()
	updateReferenceCoordinates() will update the reference coordinates, given the centerline coordintes are already updated and valid. Called by setGlobal().
Static Private Member Functions
static void	init ()
Private Attributes
int	verify
unsigned int	segmentCL
unsigned int	segmentRC
BLCoordinateType	prevType
G4double	global [4]
G4double	centerline [4]
G4double	reference [4]
int	segmentCLRadiusFailure
int	referenceCLsegment
BLCoordinateTransform *	referenceTransformUsed
Static Private Attributes
static G4Allocator< BLCoordinates >	allocator
static std::vector< CLSegment >	segmentCLVector
static unsigned	currentCL = 0
static G4bool	ring = false
static State	state = UNUSED
static G4bool	steppingVerbose = false
static G4bool	useRC = false
static G4bool	validRC = false
static std::vector< RCSegment >	segmentRCVector
static int	currentRC
static G4double	tolerance = 1.0e-4
static G4double	mostRecentReferenceZ = 0
Classes
struct	CLSegment
struct	RCSegment
class	ReferenceCoordinates

---

Member Enumeration Documentation

anonymous enum [private]

Enumerator:

VERIFY

{ VERIFY=0x13579246 };

enum BLCoordinates::State [private]

Enumerator:

UNUSED
CONSTRUCTING
TRACKING

{ UNUSED, CONSTRUCTING, TRACKING };

---

Constructor & Destructor Documentation

BLCoordinates::BLCoordinates

(

)

Default constructor -- for UserSteppingAction or without point.

References centerline, global, reference, referenceCLsegment, referenceTransformUsed, segmentCL, segmentCLRadiusFailure, segmentRC, VERIFY, and verify.

Referenced by update().

                             : G4VUserTrackInformation()
{
        // no state change, yet
        verify=VERIFY; 
        segmentCL=99999999; 
        segmentRC=99999999; 
        referenceCLsegment = -1;
        referenceTransformUsed = 0;
        global[0]=global[1]=global[2]=global[3]=0.0; 
        centerline[0]=centerline[1]=centerline[2]=centerline[3]=0.0; 
        reference[0]=reference[1]=reference[2]=reference[3]=0.0; 
        segmentCLRadiusFailure = -1;
}

BLCoordinates::BLCoordinates

(

const G4double

_global[4]

)

Constructor -- finds the earliest segmentCL containing the point (global coordinates).

References findCLSegment(), state, TRACKING, VERIFY, and verify.

                                                      : 
                        G4VUserTrackInformation()
{
        state = TRACKING;
        verify = VERIFY;
        findCLSegment(_global);
}

virtual BLCoordinates::~BLCoordinates

(

)

[inline, virtual]

Destructor.

{ }

---

Member Function Documentation

G4bool BLCoordinates::findCLSegment

(

const G4double

_global[4]

)

[private]

References centerline, segmentCL, segmentCLRadiusFailure, and segmentCLVector.

Referenced by BLCoordinates(), and setGlobal().

{
        for(segmentCL=0; segmentCL<segmentCLVector.size(); ++segmentCL) {
                segmentCLVector[segmentCL].transform.getLocal(centerline,_global);
//if(steppingVerbose) printf("FindCLSegment: seg=%d minZ=%.3f maxZ=%.3f Zcl=%.3f Rcl=%.3f rCut=%.3f\n",segmentCL,segmentCLVector[segmentCL].minZ,segmentCLVector[segmentCL].maxZ,centerline[2],sqrt(centerline[0]*centerline[0]+centerline[1]*centerline[1]),segmentCLVector[segmentCL].radiusCut);
                // note no check against minZ -- segmentCLs are ordered
                if(centerline[2] <= segmentCLVector[segmentCL].maxZ &&
                   (segmentCLVector[segmentCL].radiusCut <= 0.0 ||
                    (int)segmentCL == segmentCLRadiusFailure ||
                    sqrt(centerline[0]*centerline[0]+centerline[1]*centerline[1]) <=
                                        segmentCLVector[segmentCL].radiusCut)) {
                        return true;
                }
        }
        --segmentCL;
        return false;
}

void* BLCoordinates::operator new

(

size_t

)

[inline]

operator new - using G4Allocator. NOTE: any derived class MUST re-implement this.

Reimplemented in BLTrackInfo.

References allocator.

                                   {
                return (void *)allocator.MallocSingle();
        }

void BLCoordinates::operator delete

(

void *

p

)

[inline]

operator delete - using G4Allocator. NOTE: any derived class MUST re-implement this.

Reimplemented in BLTrackInfo.

References allocator.

                                      {
                allocator.FreeSingle((BLCoordinates *)p);
        }

G4bool BLCoordinates::isValid

(

)

const

isValid() verifies that this is a valid BLCoordinates instance. NOTE: this is not virtual, and cannot be made virtual!

References VERIFY, and verify.

Referenced by BLTrackNTuple::appendTrack(), BLCMDmovie::beamStep(), BLManager::getExternalParentID(), BLManager::getExternalTrackID(), BLManager::PreUserTrackingAction(), BLCoordinates::ReferenceCoordinates::PreUserTrackingAction(), BLCMDmovie::referenceStep(), BLManager::setExternalTrackID(), BLEvaluator::setTrackVariables(), BLManager::steppingVerbosePrint(), update(), BLManager::UserSteppingAction(), TrackerPlaneInstance::UserSteppingAction(), BLCMDtracker::UserZSteppingAction(), and BLCMDprofile::Entry::UserZSteppingAction().

{
        return this != 0 && verify == VERIFY; 
}

G4bool BLCoordinates::setGlobal

(

const G4double

_global[4]

)

setGlobal() updates the centerline coordinates for the new point[] of the track; uses the current segmentCL #, and will update it if the track crosses into a new segmentCL. returns false if the track fails radiusCut in its current and next segmentCL (or all segmentCL if ring is true). Also updates reference coordinates, if validRC is true and the centerline radiusCut succeeded.

References centerline, findCLSegment(), global, ring, segmentCL, segmentCLRadiusFailure, segmentCLVector, updateReferenceCoordinates(), and validRC.

Referenced by BLCMDmovie::dumpGeometry(), BLManager::PreUserTrackingAction(), setGlobal(), and update().

{
        global[0] = _global[0];
        global[1] = _global[1];
        global[2] = _global[2];
        global[3] = _global[3];

        if(segmentCL >= segmentCLVector.size()) {
//printf("setGlobal-0: calling findCLSegment\n");
                G4bool ret = findCLSegment(_global);
                if(ret && validRC) updateReferenceCoordinates();
//if(!ret) printf("setGlobal-0: findCLSegment FAILED\n");
                return ret;
        }

        segmentCLVector[segmentCL].transform.getLocal(centerline,_global);
//printf("setGlobal-1A: global=%.1f,%.1f,%.1f  cl=%.1f,%.1f,%.1f\n",_global[0],_global[1],_global[2],centerline[0],centerline[1],centerline[2]);
//printf("setGlobal-1: seg=%d minZ=%.3f maxZ=%.3f Zcl=%.3f Rcl=%.3f rCut=%.3f\n",segmentCL,segmentCLVector[segmentCL].minZ,segmentCLVector[segmentCL].maxZ,centerline[2],sqrt(centerline[0]*centerline[0]+centerline[1]*centerline[1]),segmentCLVector[segmentCL].radiusCut);
        while(centerline[2] > segmentCLVector[segmentCL].maxZ ||
           (segmentCLVector[segmentCL].radiusCut > 0.0 &&
            (int)segmentCL != segmentCLRadiusFailure &&
            sqrt(centerline[0]*centerline[0]+centerline[1]*centerline[1]) >
                                        segmentCLVector[segmentCL].radiusCut)) {
                if(++segmentCL >= segmentCLVector.size()) {
                        if(ring && findCLSegment(_global)) {
                                segmentCLVector[segmentCL].transform.getLocal(centerline,
                                                                        _global);
                                if(validRC) updateReferenceCoordinates();
                                return true;
                        }
                        --segmentCL;
//printf("setGlobal-1a: FAILED\n");
                        return false;
                }
                segmentCLVector[segmentCL].transform.getLocal(centerline,_global);
//printf("setGlobal-2: seg=%d minZ=%.3f maxZ=%.3f Zcl=%.3f Rcl=%.3f rCut=%.3f\n",segmentCL,segmentCLVector[segmentCL].minZ,segmentCLVector[segmentCL].maxZ,centerline[2],sqrt(centerline[0]*centerline[0]+centerline[1]*centerline[1]),segmentCLVector[segmentCL].radiusCut);
/***
                // note no check against minZ -- segmentCLs are ordered
                if(centerline[2] > segmentCLVector[segmentCL].maxZ ||
                   (segmentCLVector[segmentCL].radiusCut > 0.0 &&
                    segmentCL != segmentCLRadiusFailure &&
                    sqrt(centerline[0]*centerline[0]+centerline[1]*centerline[1]) >
                                        segmentCLVector[segmentCL].radiusCut)) {
                        if(ring && findCLSegment(_global)) {
                                segmentCLVector[segmentCL].transform.getLocal(centerline,
                                                                        _global);
                                if(validRC) updateReferenceCoordinates();
                                return true;
                        }
//printf("setGlobal-2a: FAILED\n");
                        return false;
                }
***/
        }

        if(validRC) updateReferenceCoordinates();
        return true;
}

G4bool BLCoordinates::setGlobal	(	const G4ThreeVector &	pos,
		G4double	time
	)

References global, and setGlobal().

{
        global[0]=pos[0],global[1]=pos[1],global[2]=pos[2];
        global[3]=time;
        return setGlobal(global);
}

void BLCoordinates::getCenterlineCoords

(

G4double

local[4]

)

const [inline]

getCenterlineCoords() returns the centerline coordinates. DEPRECATED: use getCoords() instead.

References centerline.

                { local[0]=centerline[0]; local[1]=centerline[1];
                  local[2]=centerline[2]; local[3]=centerline[3]; }

void BLCoordinates::getCenterlineCoords

(

G4ThreeVector &

local

)

const [inline]

References centerline.

                { local[0]=centerline[0]; local[1]=centerline[1];
                  local[2]=centerline[2]; }

void BLCoordinates::getCoords	(	BLCoordinateType	type,
		G4double	local[4]
	)

getCoords() returns the appropriate coordinate values.

References BLAssert, BLCOORD_CENTERLINE, BLCOORD_GLOBAL, BLCOORD_REFERENCE, centerline, BLCoordinateTransform::getLocal(), BLCoordinateTransform::getRotation(), global, prevType, reference, referenceTransformUsed, segmentCL, segmentCLVector, segmentRC, segmentRCVector, and validRC.

Referenced by BLTrackNTuple::appendTrack(), BLCMDmovie::beamStep(), BLCMDmovie::dumpGeometry(), getCoords(), BLCoordinates::ReferenceCoordinates::PreUserTrackingAction(), BLCMDmovie::referenceStep(), BLEvaluator::setTrackVariables(), BLManager::steppingVerbosePrint(), TrackerPlaneInstance::UserSteppingAction(), BLCMDtune::UserZSteppingAction(), BLCMDtracker::UserZSteppingAction(), and BLCMDprofile::Entry::UserZSteppingAction().

{
        prevType = type;

        switch(type) {
        case BLCOORD_GLOBAL:
                local[0] = global[0]; local[1] = global[1];
                local[2] = global[2]; local[3] = global[3];
//printf("getCoords(GLOBAL): %.1f,%.1f,%.1f\n",local[0],local[1],local[2]);
                return;
        case BLCOORD_CENTERLINE:
                BLAssert(segmentCL < segmentCLVector.size());
                local[0] = centerline[0]; local[1] = centerline[1];
                local[2] = centerline[2]; local[3] = centerline[3];
//printf("getCoords(CL): %.1f,%.1f,%.1f\n",local[0],local[1],local[2]);
                return;
        case BLCOORD_REFERENCE:
                BLAssert(validRC);
                // interpolate
                if(reference[2] < segmentRCVector[segmentRC].interpolatePrev &&
                                                           segmentRC > 0) {
                        referenceTransformUsed = 
                                &segmentRCVector[segmentRC-1].interpolate;
                        referenceTransformUsed->getLocal(reference,global);
                } else if(reference[2] > 
                                segmentRCVector[segmentRC].interpolateThis) {
                        referenceTransformUsed = 
                                &segmentRCVector[segmentRC].interpolate;
                        referenceTransformUsed->getLocal(reference,global);
                }
G4ThreeVector axis = referenceTransformUsed->getRotation().getAxis();
G4double angle = referenceTransformUsed->getRotation().getDelta();
//printf("segmentRC=%d minZ=%.4g maxZ=%.4g global=%.1f,%.1f,%.1f ref=%.1f,%.1f,%.1f axis=%.1f,%.1f,%.1f angle(deg)=%.1f\n",segmentRC,segmentRCVector[segmentRC].minZ,segmentRCVector[segmentRC].maxZ,global[0],global[1],global[2],reference[0],reference[1],reference[2],axis[0],axis[1],axis[2],angle/deg);
                local[0] = reference[0]; local[1] = reference[1];
                local[2] = reference[2]; local[3] = reference[3];
//printf("getCoords(REF): %.1f,%.1f,%.1f\n",local[0],local[1],local[2]);
                return;
        }
        G4Exception("BLCoordinates","Invalid Coordinate Type",FatalException,
                                                                        "");
}

void BLCoordinates::getCoords	(	BLCoordinateType	type,
		G4ThreeVector &	local
	)

References getCoords().

{
        G4double tmp[4];
        getCoords(type,tmp);
        local[0] = tmp[0];
        local[1] = tmp[1];
        local[2] = tmp[2];
//printf("getCoords(): %.1f,%.1f,%.1f\n",local[0],local[1],local[2]);
}

G4double BLCoordinates::getCLZ

(

)

[inline]

getCLZ() returns the centerline z coordinate.

References centerline.

Referenced by BLManager::PreUserTrackingAction(), and BLManager::UserSteppingAction().

{ return centerline[2]; }

G4RotationMatrix& BLCoordinates::getRotation

(

)

[inline]

getRotation() returns the appropriate coordinate rotation for the previous call to getCoords(). Given a G4ThreeVector B in global coordinates, this transforms it to centerline components: coord->getCoords(BLCOORD_CENTERLINE,local); B = coord->getRotation() * B;

References prevType.

Referenced by BLTrackNTuple::appendTrack(), BLCMDmovie::beamStep(), BLEvaluator::setTrackVariables(), BLManager::steppingVerbosePrint(), TrackerPlaneInstance::UserSteppingAction(), BLCMDtracker::UserZSteppingAction(), and BLCMDprofile::Entry::UserZSteppingAction().

{ return getRotation(prevType); }

G4RotationMatrix & BLCoordinates::getRotation

(

BLCoordinateType

type

)

getRotation() returns the rotation for the specified coordinates. Given a G4ThreeVector B in global coordinates, this transforms it to centerline components: B = coord->getRotation(BLCOORD_CENTERLINE) * B;

References BLAssert, BLCOORD_CENTERLINE, BLCOORD_GLOBAL, BLCOORD_REFERENCE, BLCoordinateTransform::getRotation(), IdentityMatrix, referenceTransformUsed, segmentCL, segmentCLVector, and validRC.

{
        switch(type) {
        case BLCOORD_GLOBAL:
                return IdentityMatrix;
        case BLCOORD_CENTERLINE:
                BLAssert(segmentCL < segmentCLVector.size());
                return segmentCLVector[segmentCL].transform.getRotation();
        case BLCOORD_REFERENCE:
                BLAssert(validRC && referenceTransformUsed != 0);
                return referenceTransformUsed->getRotation();
        }
        G4Exception("BLCoordinates","Invalid Coordinate Type",FatalException,
                                                                        "");
        return IdentityMatrix;
}

G4RotationMatrix BLCoordinates::getCenterlineRotation

(

)

[inline]

getCenterlineRotation() returns the rotation matrix used for the last setGlobal() of this instance. This is the rotation of the centerline wrt global coordinate axes. DEPRECATED -- use getRotation().

References segmentCL, and segmentCLVector.

                                                 {
                if(segmentCL >= segmentCLVector.size())
                        return G4RotationMatrix();
                return segmentCLVector[segmentCL].transform.getRotationInverse();
        }

static double BLCoordinates::getCurrentRadiusCut

(

)

[inline, static]

getCurrentRadiusCut() returns the radiusCut for the current CL segment.

References currentCL, and segmentCLVector.

Referenced by BLCMDcorner::command().

                                            {
                if(currentCL >= segmentCLVector.size())
                        return DBL_MAX;
                else
                        return segmentCLVector[currentCL].radiusCut;
        }

G4RotationMatrix BLCoordinates::getTransformRotation

(

)

[inline]

getTransformRotation() returns the rotation matrix of the global -> centerline coordinate transformation; it is the inverse of getCenterlineRotation(). Given a G4ThreeVector B in global coordinates, this transforms it to centerline components: B = getTransformRotation() * B; DEPRECATED -- use getRotation().

References segmentCL, and segmentCLVector.

                                                {
                if(segmentCL >= segmentCLVector.size())
                        return G4RotationMatrix();
                return segmentCLVector[segmentCL].transform.getRotation();
        }

int BLCoordinates::getSegmentCL

(

)

[inline]

getSegmentCL() re turns the CL segment # (for debugging).

References segmentCL.

Referenced by BLManager::steppingVerbosePrint().

{ return segmentCL; }

void BLCoordinates::update

(

G4Track *

track

)

[static]

update() This function ensures that a UserTrackInformation object is linked into the track; if none is, it creates a new BLCoordinates instance and links it in. It also calls setGlobal() for the BLCoordinates linked into the track.

References BLCoordinates(), isValid(), segmentCL, segmentCLRadiusFailure, setGlobal(), and steppingVerbose.

Referenced by BLManager::UserSteppingAction().

{
        // ensure there is a BLCoordiantes linked into the track
        BLCoordinates *c = (BLCoordinates *)track->GetUserInformation();
        if(!c || !c->isValid()) {
                c = new BLCoordinates();
                track->SetUserInformation(c);
        }

        // now update the object and apply radiusCut
        if(!c->setGlobal(track->GetPosition(),track->GetGlobalTime())) {
                track->SetTrackStatus(fStopAndKill);
                if(steppingVerbose)
                        printf("Track Centerline radius exceeds radiusCut\n");
                c->segmentCLRadiusFailure = c->segmentCL;
        }
}

virtual void BLCoordinates::Print

(

)

const [inline, virtual]

Print from G4VUserTrackInformation.

{ }

void BLCoordinates::init

(

)

[static, private]

References CONSTRUCTING, currentCL, BLManager::getObject(), BLManager::getSteppingVerbose(), segmentCLVector, state, steppingVerbose, TRACKING, and UNUSED.

Referenced by corner(), getCurrentGlobal(), getCurrentRotation(), getCurrentTransform(), and start().

{
        if(state == TRACKING) {
                G4Exception("BLCoordinates","Invalid init during tracking",
                                                        FatalException, "");
        }
        if(state == UNUSED) {
                state = CONSTRUCTING;
                segmentCLVector.push_back(CLSegment(-DBL_MAX, +DBL_MAX, 0.0,
                                                BLCoordinateTransform()));
                currentCL = 0;
                steppingVerbose = 
                        BLManager::getObject()->getSteppingVerbose() != 0;
        }
}

void BLCoordinates::start	(	const G4double	point[4],
		G4double	z,
		G4RotationMatrix *	rotation = 0,
		G4double	radiusCut = 0.0,
		G4bool	_ring = false
	)			[static]

start() sets the starting point and direction for the first segmentCL. Must not be called after corner() is called, or after any element has been placed using centerline coordinates. point[] is in global coordinates, z is the starting value of z in CENTERLINE coordinates, _ring indicates whether a ring is present (so jumps in segmentCL # are permitted), and rotation should be the rotation of the first segmentCL's centerline wrt the global coordinate axes (i.e. it is an active rotation of the centerline as an object wrt the global coordinate axes).

References currentCL, BLManager::getObject(), BLManager::getSteppingVerbose(), init(), ring, segmentCLVector, state, steppingVerbose, and UNUSED.

Referenced by BLCMDstart::command().

{
        if(state != UNUSED || currentCL != 0) {
                G4Exception("BLCoordinates","Invalid start",FatalException, "");
        }
        init();
        
        G4ThreeVector pos(0,0,-z);
        if(rotation)
                pos = *rotation * pos;
        pos[0] += _global[0];
        pos[1] += _global[1];
        pos[2] += _global[2];
        segmentCLVector[0].transform = (rotation ?
                                        BLCoordinateTransform(rotation,pos) : 
                                        BLCoordinateTransform(pos));
        segmentCLVector[0].radiusCut = radiusCut;
        ring = _ring;
        steppingVerbose = BLManager::getObject()->getSteppingVerbose() != 0;
}

void BLCoordinates::corner	(	G4double	z,
		G4RotationMatrix *	rotation,
		G4double	radiusCut
	)			[static]

corner() creates a corner in the centerline by ending the current segmentCL and beginning a new one. z is the position in CENTERLINE coordinates of the current segmentCL, and rotation is relative to the current CENTERLINE coordinates (i.e. as an active rotation of the centerline as an object wrt the CENTERLINE coordinate axes of the current segmentCL). z must be greater than the centerline z of the previous corner or start. rotation can be an identity matrix (e.g. to merely set a new radiusCut).

References currentCL, getCurrentRotation(), getCurrentTransform(), init(), and segmentCLVector.

Referenced by BLCMDcornerarc::command(), and BLCMDcorner::command().

{
        init();
        
        G4double local[4], glob[4];
        local[0]=local[1]=local[3]=0.0;
        local[2] = z;
        segmentCLVector[currentCL].transform.getGlobal(local,glob);

        segmentCLVector[currentCL].maxZ = z;
        G4RotationMatrix *p=0;
        if(rotation)
                // if C=currentCL rot, and R=this rot, we want R referenced to
                // the CURRENT centerline coordinates, so we need C R C^-1.
                // But we compose this with C (on the right), and get C R.
                p = new G4RotationMatrix(*getCurrentRotation() * *rotation);
        else if(getCurrentTransform().isRotated())
                p = getCurrentRotation();

        G4ThreeVector pos(0,0,-z);
        if(p)
                pos = *p * pos;
        pos[0] += glob[0];
        pos[1] += glob[1];
        pos[2] += glob[2];
        segmentCLVector.push_back(CLSegment(z, +DBL_MAX, radiusCut,
                                        BLCoordinateTransform(p,pos)));
        currentCL = segmentCLVector.size() - 1;
}

BLCoordinateTransform & BLCoordinates::getCurrentTransform

(

)

[static]

getCurrentTransform() returns the current BLCoordinateTransform for the centerline coordinates (i.e. the coordinate transform global->centerline of the current segmentCL).

References currentCL, init(), and segmentCLVector.

Referenced by corner().

{
        init();
        return segmentCLVector[currentCL].transform;
}

G4RotationMatrix * BLCoordinates::getCurrentRotation

(

)

[static]

getCurrentRotation() returns the current G4RotationMatrix for the centerline coordinates (i.e. the active rotation of the current segmentCL, as an object rotated wrt global coordinate axes). Given a G4ThreeVector B in global coordinates, this transforms it to centerline components: B = *getCurrentRotation() * B;

References currentCL, init(), and segmentCLVector.

Referenced by BLCMDtracker::command(), BLCMDreference::command(), BLCMDcorner::command(), BLCMDbeam::command(), corner(), and BLGroup::placeElement().

{
        init();
        return &segmentCLVector[currentCL].transform.getRotationInverse();
}

void BLCoordinates::getCurrentGlobal	(	const G4double	local[4],
		G4double	_global[4]
	)			[static]

getCurrentGlobal() returns global coordinates from centerline coordinates, using the current segmentCL.

References currentCL, init(), and segmentCLVector.

Referenced by BLCMDtracker::command(), BLCMDreference::command(), BLCMDbeam::command(), and BLGroup::placeElement().

{
        init();
        segmentCLVector[currentCL].transform.getGlobal(local,_global);
}

void BLCoordinates::getCurrentGlobal	(	const G4ThreeVector &	local,
		G4ThreeVector &	_global
	)			[static]

getCurrentGlobal() returns global coordinates from centerline coordinates, using the current segmentCL.

References currentCL, init(), and segmentCLVector.

{
        init();
        segmentCLVector[currentCL].transform.getGlobal(local,_global);
}

void BLCoordinates::getGlobalAnywhere	(	const G4ThreeVector &	local,
		G4ThreeVector &	_global
	)			[static]

getGlobalAnywhere() returns global coordinates from centerline coordinates, using the lowest segmentCL containing local.

References segmentCLVector.

{
        for(unsigned int seg=0; seg<segmentCLVector.size(); ++seg) {
                // note no check against minZ -- segmentCLs are ordered
                if(local[2] <= segmentCLVector[seg].maxZ &&
                   (segmentCLVector[seg].radiusCut <= 0.0 ||
                    sqrt(local[0]*local[0]+local[1]*local[1]) <=
                                        segmentCLVector[seg].radiusCut)) {
                        segmentCLVector[seg].transform.getGlobal(local,_global);
                        return;
                }
        }
}

G4RotationMatrix * BLCoordinates::getGlobalRotation

(

const G4ThreeVector &

local

)

[static]

getGlobalRotation() returns the local->global rotation matrix coordinates, using the lowest segmentCL containing local.

References segmentCLVector.

{
        for(unsigned int seg=0; seg<segmentCLVector.size(); ++seg) {
                // note no check against minZ -- segmentCLs are ordered
                if(local[2] <= segmentCLVector[seg].maxZ &&
                   (segmentCLVector[seg].radiusCut <= 0.0 ||
                    sqrt(local[0]*local[0]+local[1]*local[1]) <=
                                        segmentCLVector[seg].radiusCut)) {
                        return &segmentCLVector[seg].transform.getRotation();
                }
        }

        return 0;
}

G4double BLCoordinates::getRadiusCut

(

const G4ThreeVector &

local

)

[static]

getRadiusCut() returns the radius cut for the lowest segmentCL containing local.

References segmentCLVector.

{
        for(unsigned int seg=0; seg<segmentCLVector.size(); ++seg) {
                // note no check against minZ -- segmentCLs are ordered
                if(local[2] <= segmentCLVector[seg].maxZ &&
                   (segmentCLVector[seg].radiusCut <= 0.0 ||
                    sqrt(local[0]*local[0]+local[1]*local[1]) <=
                                        segmentCLVector[seg].radiusCut)) {
                        return segmentCLVector[seg].radiusCut;
                }
        }

        return 0;
}

BLCoordinateType BLCoordinates::getCoordinateType

(

G4String

s

)

[static]

getCoordinateType() converts a G4String name to a BLCoordinateType. Names are: global, centerline, reference; only the first letter is used, case insensitive. Also enables the generation of REference Coordinates, if they are selected by s.

References BLCOORD_CENTERLINE, BLCOORD_GLOBAL, BLCOORD_REFERENCE, BLCommand::printError(), and useReferenceCoordinates().

Referenced by BLCMDzntuple::command(), BLCMDvirtualdetector::command(), BLCMDtrace::command(), BLCMDtimentuple::command(), BLCMDprofile::command(), BLCMDprintf::command(), BLCMDplace::command(), BLCMDnewparticlentuple::command(), BLCMDmovie::command(), and BLCMDbeamlossntuple::command().

{
        char c = tolower(s[0u]);
        switch(c) {
        case 'g':       return BLCOORD_GLOBAL;
        case 'c':       return BLCOORD_CENTERLINE;
        case 'r':       useReferenceCoordinates();
                        return BLCOORD_REFERENCE;
        default:        BLCommand::printError("Unknown coordinate type '%s',"
                                " Centerline used.\n",s.c_str());
                        return BLCOORD_CENTERLINE;
        }
}

void BLCoordinates::updateReferenceCoordinates

(

)

[private]

updateReferenceCoordinates() will update the reference coordinates, given the centerline coordintes are already updated and valid. Called by setGlobal().

References global, reference, referenceTransformUsed, segmentCL, segmentCLVector, segmentRC, and segmentRCVector.

Referenced by setGlobal().

{
        // if we are lost, use CL coord segment as a starting point
        if(segmentRC >= segmentRCVector.size()) {
                segmentRC = segmentCLVector[segmentCL].firstRCSegment;
                if(segmentRC > 0) --segmentRC; // try 1 previous
        }
        if(segmentRC >= segmentRCVector.size())
                segmentRC = 0;

        for( ; segmentRC<segmentRCVector.size(); ++segmentRC) {
                segmentRCVector[segmentRC].transform.getLocal(reference,global);
//printf("segmentRC=%d minZ=%.4g maxZ=%.4g global=%.1f,%.1f,%.1f ref=%.1f,%.1f,%.3f\n",segmentRC,segmentRCVector[segmentRC].minZ,segmentRCVector[segmentRC].maxZ,global[0],global[1],global[2],reference[0],reference[1],reference[2]);
                referenceTransformUsed = &segmentRCVector[segmentRC].transform;
                if(segmentRC != 0) // no correction (minZ = -DBL_MAX)
                   reference[2] += (segmentRCVector[segmentRC].correction - 1.0)
                               * (reference[2]-segmentRCVector[segmentRC].minZ);
//printf("         corrected reference[2]=%.1f\n",reference[2]);
                if(reference[2] > segmentRCVector[segmentRC].maxZ)
                        continue;
                return;
        }
        G4Exception("BLCoordinates","Cannot determine reference coordinate segment",
                                                FatalException,"");
}

void BLCoordinates::useReferenceCoordinates

(

)

[static]

useReferenceCoordinates() will arrange to fill segmentRCVector[] with reference coordinate segments as the reference particle is tracked. Must be called before the reference particle is tracked. Unless this is called, reference coordinates will not be available. Multiple calls are the same as one.

References useRC.

Referenced by BLCMDmovie::command(), and getCoordinateType().

{

        if(!useRC) {
                useRC = true;
                new ReferenceCoordinates();
        }
}

static void BLCoordinates::setMostRecentReferenceZ

(

G4double

z

)

[inline, static]

setMostRecentReferenceZ() sets the most recent z value of the reference coords. VALID ONLY WHILE TRACKING REFERENCE PARTICLE!

References mostRecentReferenceZ.

Referenced by BLCoordinates::ReferenceCoordinates::PreUserTrackingAction(), and BLCoordinates::ReferenceCoordinates::UserSteppingAction().

                { mostRecentReferenceZ = z; } 

static G4double BLCoordinates::getMostRecentReferenceZ

(

)

[inline, static]

getMostRecentReferenceZ() returns the most recent z value of the reference coords. VALID ONLY WHILE TRACKING REFERENCE PARTICLE!

References mostRecentReferenceZ.

Referenced by BLCMDmovie::referenceStep().

                { return mostRecentReferenceZ; } 

---

Member Data Documentation

int BLCoordinates::verify [private]

Referenced by BLCoordinates(), and isValid().

unsigned int BLCoordinates::segmentCL [private]

Referenced by BLCoordinates(), findCLSegment(), getCenterlineRotation(), getCoords(), getRotation(), getSegmentCL(), getTransformRotation(), setGlobal(), update(), and updateReferenceCoordinates().

unsigned int BLCoordinates::segmentRC [private]

Referenced by BLCoordinates(), getCoords(), BLCoordinates::ReferenceCoordinates::PreUserTrackingAction(), and updateReferenceCoordinates().

BLCoordinateType BLCoordinates::prevType [private]

Referenced by getCoords(), and getRotation().

G4double BLCoordinates::global[4] [private]

Referenced by BLCoordinates(), getCoords(), BLCoordinates::ReferenceCoordinates::PostUserTrackingAction(), setGlobal(), and updateReferenceCoordinates().

G4double BLCoordinates::centerline[4] [private]

Referenced by BLCoordinates(), findCLSegment(), getCenterlineCoords(), getCLZ(), getCoords(), and setGlobal().

G4double BLCoordinates::reference[4] [private]

Referenced by BLCoordinates(), getCoords(), and updateReferenceCoordinates().

int BLCoordinates::segmentCLRadiusFailure [private]

Referenced by BLCoordinates(), findCLSegment(), setGlobal(), and update().

G4Allocator< BLCoordinates > BLCoordinates::allocator [static, private]

Referenced by operator delete(), and operator new().

std::vector< BLCoordinates::CLSegment > BLCoordinates::segmentCLVector [static, private]

Referenced by BLCoordinates::ReferenceCoordinates::addStep(), corner(), findCLSegment(), getCenterlineRotation(), getCoords(), getCurrentGlobal(), getCurrentRadiusCut(), getCurrentRotation(), getCurrentTransform(), getGlobalAnywhere(), getGlobalRotation(), getRadiusCut(), getRotation(), getTransformRotation(), init(), setGlobal(), start(), and updateReferenceCoordinates().

unsigned BLCoordinates::currentCL = 0 [static, private]

Referenced by BLCoordinates::ReferenceCoordinates::addStep(), corner(), getCurrentGlobal(), getCurrentRadiusCut(), getCurrentRotation(), getCurrentTransform(), init(), and start().

G4bool BLCoordinates::ring = false [static, private]

Referenced by setGlobal(), and start().

BLCoordinates::State BLCoordinates::state = UNUSED [static, private]

Referenced by BLCoordinates(), init(), and start().

G4bool BLCoordinates::steppingVerbose = false [static, private]

Referenced by init(), start(), and update().

G4bool BLCoordinates::useRC = false [static, private]

Referenced by useReferenceCoordinates().

G4bool BLCoordinates::validRC = false [static, private]

Referenced by getCoords(), getRotation(), BLCoordinates::ReferenceCoordinates::PostUserTrackingAction(), BLCoordinates::ReferenceCoordinates::PreUserTrackingAction(), and setGlobal().

std::vector< BLCoordinates::RCSegment > BLCoordinates::segmentRCVector [static, private]

Referenced by BLCoordinates::ReferenceCoordinates::addStep(), getCoords(), BLCoordinates::ReferenceCoordinates::PostUserTrackingAction(), and updateReferenceCoordinates().

int BLCoordinates::currentRC [static, private]

G4double BLCoordinates::tolerance = 1.0e-4 [static, private]

Referenced by BLCoordinates::ReferenceCoordinates::addStep(), and BLCoordinates::ReferenceCoordinates::UserSteppingAction().

G4double BLCoordinates::mostRecentReferenceZ = 0 [static, private]

Referenced by getMostRecentReferenceZ(), and setMostRecentReferenceZ().

int BLCoordinates::referenceCLsegment [private]

Referenced by BLCoordinates().

BLCoordinateTransform* BLCoordinates::referenceTransformUsed [private]

Referenced by BLCoordinates(), getCoords(), getRotation(), and updateReferenceCoordinates().

---

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

• BLCoordinates.hh
• BLCoordinates.cc