BLGroup Class Reference

#include <BLGroup.hh>

Inheritance diagram for BLGroup:

List of all members.

---

Detailed Description

BLGroup - define one group (container for BLElement-s).

NOTE: the class for the group command is BLGroup, not BLCMDgroup. This class is too intertwinded between command and infrastructure, so a single class was used.

Implements the group command, which begins defining the contents of the group; the endgroup command ends the group's definition, and computes the size of the group (if it wasn't specified via arguments). The group expands to hold its contents, unless its size is specified in arguments to the group command. The World is a expandable group.

If radius is set to 0, uses a Tubs with radius equal to the larger of the widest or highest element placed into the group; if radius is set >0 that is the fixed radius of the Tubs. If radius is not set then uses a Box.

Public Member Functions
	BLGroup ()
	Default Constructor. registers the command and provides help text.
	BLGroup (BLGroup &r)
	Copy Constructor for a real BLGroup.
	~BLGroup ()
	Destructor.
BLElement *	clone ()
	clone() - invalid.
virtual G4String	commandName ()
	commandName() returns "group";
int	command (BLArgumentVector &argv, BLArgumentMap &namedArgs)
	command() implements the group command.
void	defineNamedArgs ()
	defineNamedArgs() defines the arguments to the command.
virtual void	construct (G4RotationMatrix *relativeRotation, G4ThreeVector relativePosition, G4LogicalVolume *parent, G4String parentName, G4RotationMatrix *parentRotation, G4ThreeVector parentPosition)
	construct() will construct an instance of this group, and construct its contents recursively.
G4double	getLength ()
	getLength() returns this group's Length along the Z axis.
G4double	getWidth ()
	getWidth() returns this group's Width along the X axis.
G4double	getHeight ()
	getHeight() returns this group's height along the Y axis.
void	setMinWidth (G4double minWidth)
	setMinWidth() will increase the width, if necessary.
void	setMinHeight (G4double minHeight)
	setMinHeight() will increase the height, if necessary.
void	setMinLength (G4double minLength)
	setMinLength() will increase the length, if necessary.
void	setMaterial (G4String mat)
	setMaterial() sets the name of the group's material.
G4bool	isOK ()
	isOK() returns true; individual elements are responsible for their own status.
bool	isOutside (G4ThreeVector &local, G4double tolerance)
	isOutside() from BLElement.
void	generatePoints (int npoints, std::vector< G4ThreeVector > &v)
	generatePoints from BLElement.
bool	isWithin (G4ThreeVector &local, G4double tolerance)
	isWithin() from BLGroupElement.
virtual void	placeElement (BLElement *element, G4RotationMatrix *rot, G4ThreeVector &offset, G4String rename, G4bool global=false)
	placeElement() will place an element within this group. With a rotation, an offset must be given, and the length of the group must have been specified via an argument. Called by the place command. The object being placed is rotated wrt the fixed axes of the group's local coordinates. global=true means use global coordinates for the world group, not centerline coords.
virtual void	placeElement (BLElement *element, G4ThreeVector &offset, G4String rename, G4bool global=false)
	placeElement() will place an element within this group. With an offset, the length of the group must have been specified via an argument. Called by the place command.
virtual void	placeElement (BLElement *element, G4String rename, G4bool global=false)
	placeElement() will place an element within this group. With no offset, this element is placed immediately downstream of the previous element. If necessary, the endgroup command will compute the size of the group and readjust offsets so they are relative to the center of the group. Called by the place command.
void	end ()
	end() will compute the size of the group, if necessary, and pop the current group.
G4ThreeVector &	getOffset ()
	getOffset() returns the offset for the place command.
void	setOffset (G4ThreeVector &offset)
	setOffset() sets the offset for the place command.
Static Public Member Functions
static BLGroup *	getCurrent ()
	getCurrent() returns a pointer to the current group (innermost active group command). Creates current and world if necessary. Used by the place command.
static BLGroup *	getWorld ()
	getWorld() returns a pointer to the World group. Creates current and world if necessary.
static G4VPhysicalVolume *	constructWorld ()
	constructWorld() constructs the beamline and returns a pointer to its world PhysicalVolume.
Private Member Functions
BLGroup &	operator= (const BLGroup &)
Private Attributes
BLGroup *	prevCurrent
G4double	highZ
G4double	lastZ
G4double	length
G4double	width
G4double	height
G4double	radius
G4String	material
G4String	color
G4double	maxStep
G4bool	fixedLength
G4bool	fixedWidth
G4bool	fixedHeight
G4ThreeVector	offset
Static Private Attributes
static BLGroup *	current = 0
static BLGroup *	world = 0
static G4VPhysicalVolume *	worldPhysVol = 0
Friends
class	BLCMDendgroup
Classes
struct	Child

---

Constructor & Destructor Documentation

BLGroup::BLGroup

(

)

Default Constructor. registers the command and provides help text.

References BLCMDTYPE_CONTROL, color, fixedHeight, fixedLength, fixedWidth, height, highZ, lastZ, length, material, maxStep, prevCurrent, radius, BLCommand::registerCommand(), BLCommand::setDescription(), BLCommand::setSynopsis(), and width.

Referenced by command(), and getWorld().

                 : BLGroupElement(), offset(0,0,0)
{
        registerCommand(BLCMDTYPE_CONTROL);
        setSynopsis("begins definition of a group.");
        setDescription("A group is a collection of elements that can be placed\n"
                "together, preserving their relative positions. The group\n"
                "is a LogicalVolume in the geant4 geometry -- this means that "
                "a group cannot overlap any other group or object, even if the "
                "overlapping portion of the group is empty. If you need to "
                "permit overlaps, consider using a macro instead (the define "
                "command).\n\n"
                "If the group is\n"
                "given a length, then children can be placed at specific\n"
                "z offsets relative to the center of the group. If the group\n"
                "is not given a length, then children can only be placed\n"
                "sequentially along z, and the length will be computed by\n"
                "the endgroup command. Width and height are computed\n"
                "from the largest child or the argument.\n"
                "If radius is set to 0, the group will be a cylinder with\n"
                "radius determined by the largest width or height placed\n"
                "into it; if >0 then that is the fixed radius. If radius\n"
                "is not set then a box is used.\n\n"
                "Note: when placing objects into a group, if the rename "
                "argument is used, it should begin with a '+' to include the "
                "group's name in the object's name; otherwise there may be "
                "multiple objects with the same name -- this is only a major "
                "problem for virtualdetector-s and other output objects. The "
                "group's name is included by default if no rename is used on "
                "the place command.");

        prevCurrent = 0;
        highZ = 0.0;
        lastZ = 0.0;
        length = 0.0;
        width = 0.0;
        height = 0.0;
        radius = -1.0;
        material = "Vacuum";
        color = "";
        maxStep = -1.0;
        fixedLength = false;
        fixedWidth = false;
        fixedHeight = false;
}

BLGroup::BLGroup

(

BLGroup &

r

)

[inline]

Copy Constructor for a real BLGroup.

References color, fixedHeight, fixedLength, fixedWidth, height, highZ, lastZ, length, material, maxStep, prevCurrent, radius, and width.

                            : BLGroupElement(r), offset(0,0,0)
                { prevCurrent=0; highZ=0.0; lastZ=0.0; length=r.length;
                  width=r.width; height=r.height; material=r.material;
                  radius=r.radius; color = r.color; maxStep = r.maxStep; 
                  fixedLength = r.fixedLength;
                  fixedWidth = r.fixedWidth;
                  fixedHeight = r.fixedHeight; }

BLGroup::~BLGroup

(

)

Destructor.

{
}

---

Member Function Documentation

BLElement* BLGroup::clone

(

)

[inline, virtual]

clone() - invalid.

Implements BLElement.

{ return 0; }

virtual G4String BLGroup::commandName

(

)

[inline, virtual]

commandName() returns "group";

Implements BLCommand.

{ return "group"; }

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

command() implements the group command.

Implements BLCommand.

References BLGroup(), current, fixedHeight, fixedLength, fixedWidth, getCurrent(), BLParam::getDouble(), BLCommand::getMaterial(), BLCommand::handleNamedArgs(), height, highZ, lastZ, length, material, maxStep, Param, prevCurrent, BLCommand::print(), BLCommand::printError(), radius, BLGroupElement::setName(), and width.

{
        if(argv.size() != 1) {
                printError("invalid group command -- requires name");
                argv.clear();
                argv.push_back("UnnamedGroup");
        }

        BLGroup *c = new BLGroup(defaultGroup);
        c->setName(argv[0]);
        c->handleNamedArgs(namedArgs);
        if(c->length > 0.0)
                c->lastZ = c->highZ = -c->length/2.0;

        if(c->maxStep < 0.0) c->maxStep = Param.getDouble("maxStep");

        if(c->radius > 0.0)
                c->width = c->height = 2.0*c->radius;
        c->fixedLength = (c->length > 0.0);
        c->fixedWidth = (c->width > 0.0);
        c->fixedHeight = (c->height > 0.0);

        c->prevCurrent = getCurrent();  // (current could be 0)
        current = c;

        // check material exists
        if(c->material.size() > 0) getMaterial(c->material,false);

        c->print(argv[0]);

        return 0;
}

void BLGroup::defineNamedArgs

(

)

[virtual]

defineNamedArgs() defines the arguments to the command.

Reimplemented from BLCommand.

References BLCommand::argDouble(), BLCommand::argString(), color, height, length, material, maxStep, radius, and width.

{
        argDouble(length,"length","Overall group length along z (mm)",mm,"",false);
        argDouble(width,"width","Overall group width (mm)",mm,"",false);
        argDouble(height,"height","Overall group height (mm)",mm,"",false);
        argDouble(radius,"radius","Radius for a cylindrical group (mm)",mm,"",false);
        argString(material,"material","Material of the volume outside children");
        argString(color,"color","Color of the volume of the group");
        argDouble(maxStep,"maxStep","The maximum stepsize in the volume (mm)");
}

void BLGroup::construct	(	G4RotationMatrix *	relativeRotation,
		G4ThreeVector	relativePosition,
		G4LogicalVolume *	parent,
		G4String	parentName,
		G4RotationMatrix *	parentRotation,
		G4ThreeVector	parentPosition
	)			[virtual]

construct() will construct an instance of this group, and construct its contents recursively.

Implements BLElement.

References color, BLGroupElement::constructChildren(), BLParam::getDouble(), getHeight(), getLength(), BLCommand::getMaterial(), BLElement::getName(), BLCommand::getVisAttrib(), getWidth(), height, length, material, maxStep, Param, radius, width, world, and worldPhysVol.

Referenced by constructWorld().

{
        if(radius == 0.0) radius = std::max<double>(width,height)/2.0;
        bool silent = (getName() == "World");
        if(radius > 0.0 && !silent)
            printf("BLGroup::Construct %s parent=%s relZ=%.1f globZ=%.1f length=%.1f\n"
                        "\tzmin=%.1f zmax=%.1f radius=%.1f\n",
                getName().c_str(),parentName.c_str(),relativePosition[2],
                parentPosition[2],getLength(),
                parentPosition.z()-getLength()/2.0,
                parentPosition.z()+getLength()/2.0,
                radius);
        else if(!silent)
            printf("BLGroup::Construct %s parent=%s relZ=%.1f globZ=%.1f length=%.1f\n"
                        "\tzmin=%.1f zmax=%.1f width=%.1f Height=%.1f\n",
                getName().c_str(),parentName.c_str(),relativePosition[2],
                parentPosition[2],getLength(),
                parentPosition.z()-getLength()/2.0,
                parentPosition.z()+getLength()/2.0,
                getWidth(),getHeight());
        
        if(maxStep <= 0.0) maxStep = Param.getDouble("maxStep");

        // add safety region to the world volume, so steps are guaranteed
        // to remain inside the world volume. Double it to be sure.
        G4double safety = 0.0;
        if(this == world) safety = maxStep * 2.0;

        G4VSolid *solid=0;
        if(radius > 0.0)
                solid = new G4Tubs(getName()+"Tubs", 0.0, radius+safety,
                        length/2.0+safety, 0.0, 2.0*pi);
        else
                solid = new G4Box(getName()+"Box",getWidth()/2.0+safety,
                                getHeight()/2.0+safety,getLength()/2.0+safety);
        G4Material *mat = getMaterial(material);
        G4LogicalVolume *lv = new G4LogicalVolume(solid,mat,getName()+"LogVol");
        lv->SetVisAttributes(getVisAttrib(color));
        lv->SetUserLimits(new G4UserLimits(maxStep));

        // geant4 rotation convention is backwards from g4beamline
        G4RotationMatrix *g4rot = 0;
        if(relativeRotation)
                g4rot = new G4RotationMatrix(relativeRotation->inverse());

        G4VPhysicalVolume *phys = new G4PVPlacement(g4rot, relativePosition,lv,
                                        parentName+getName(),parent, false,0);

        G4String xname = parentName + getName();
        if(this == world) {
                worldPhysVol = phys;
                xname = "";     // omit "World" from the start of every name
        }

        // get globalRotation and globalPosition
        G4RotationMatrix *globalRotation = 0;
        if(relativeRotation && parentRotation) {
                globalRotation = 
                    new G4RotationMatrix(*parentRotation * *relativeRotation);
        } else if(relativeRotation) {
                globalRotation = relativeRotation;
        } else if(parentRotation) {
                globalRotation = parentRotation;
        }
        G4ThreeVector globalPosition(relativePosition + parentPosition);
        if(parentRotation)
                globalPosition = *parentRotation * relativePosition +
                                parentPosition;

        if(!silent) printf("\tParent pos=%.1f,%.1f,%.1f Relative pos=%.1f,%.1f,%.1f Global pos=%.1f,%.1f,%.1f\n",
                parentPosition[0],parentPosition[1],parentPosition[2],
                relativePosition[0],relativePosition[1],relativePosition[2],
                globalPosition[0],globalPosition[1],globalPosition[2]);

        constructChildren(lv,xname,globalRotation,globalPosition);
}

G4double BLGroup::getLength

(

)

[inline, virtual]

getLength() returns this group's Length along the Z axis.

Implements BLElement.

References length.

Referenced by BLCMDfieldlines::callback(), and construct().

{ return length; }

G4double BLGroup::getWidth

(

)

[inline, virtual]

getWidth() returns this group's Width along the X axis.

Implements BLElement.

References width.

Referenced by BLCMDfieldlines::callback(), and construct().

{ return width; }

G4double BLGroup::getHeight

(

)

[inline, virtual]

getHeight() returns this group's height along the Y axis.

Implements BLElement.

References height.

Referenced by BLCMDfieldlines::callback(), and construct().

{ return height; }

void BLGroup::setMinWidth

(

G4double

minWidth

)

[inline]

setMinWidth() will increase the width, if necessary.

References width.

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

                { if(width < minWidth) width = minWidth; }

void BLGroup::setMinHeight

(

G4double

minHeight

)

[inline]

setMinHeight() will increase the height, if necessary.

References height.

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

                { if(height < minHeight) height = minHeight; }

void BLGroup::setMinLength

(

G4double

minLength

)

[inline]

setMinLength() will increase the length, if necessary.

References highZ.

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

                { if(highZ < minLength) highZ = minLength; }

void BLGroup::setMaterial

(

G4String

mat

)

[inline]

setMaterial() sets the name of the group's material.

References material.

Referenced by main().

{ material = mat; }

G4bool BLGroup::isOK

(

)

[inline, virtual]

isOK() returns true; individual elements are responsible for their own status.

Implements BLElement.

{ return true; }

G4bool BLGroup::isOutside	(	G4ThreeVector &	local,
		G4double	tolerance
	)			[virtual]

isOutside() from BLElement.

Implements BLElement.

References height, length, radius, and width.

{
        if(radius > 0.0)
                return sqrt(local[0]*local[0]+local[1]*local[1]) > radius-tolerance ||
                        fabs(local[2]) > length/2.0-tolerance;
        else
                return fabs(local[0]) > width/2.0-tolerance ||
                        fabs(local[1]) > height/2.0-tolerance ||
                        fabs(local[2]) > length/2.0-tolerance;
}

void BLGroup::generatePoints	(	int	npoints,
		std::vector< G4ThreeVector > &	v
	)			[virtual]

generatePoints from BLElement.

Implements BLElement.

References BLElement::generateBox(), BLElement::generateTubs(), height, length, radius, and width.

{
        if(radius > 0.0)
                generateTubs(npoints, 0.0, radius, 0.0, 2.0*pi, length, v);
        else
                generateBox(npoints,width,height,length,v);
}

G4bool BLGroup::isWithin	(	G4ThreeVector &	local,
		G4double	tolerance
	)			[virtual]

isWithin() from BLGroupElement.

Implements BLGroupElement.

References height, length, radius, and width.

{
        if(radius > 0.0)
                return sqrt(local[0]*local[0]+local[1]*local[1]) < radius+tolerance ||
                        fabs(local[2]) < length/2.0+tolerance;
        else
                return fabs(local[0]) < width/2.0+tolerance &&
                        fabs(local[1]) < height/2.0+tolerance &&
                        fabs(local[2]) < length/2.0+tolerance;
}

void BLGroup::placeElement	(	BLElement *	element,
		G4RotationMatrix *	rot,
		G4ThreeVector &	offset,
		G4String	rename,
		G4bool	global = false
	)			[virtual]

placeElement() will place an element within this group. With a rotation, an offset must be given, and the length of the group must have been specified via an argument. Called by the place command. The object being placed is rotated wrt the fixed axes of the group's local coordinates. global=true means use global coordinates for the world group, not centerline coords.

References BLGroupElement::child, BLGroupElement::Child::element, fixedHeight, fixedLength, fixedWidth, BLCoordinates::getCurrentGlobal(), BLCoordinates::getCurrentRotation(), BLElement::getHeight(), BLElement::getLength(), BLElement::getName(), BLElement::getWidth(), height, highZ, lastZ, length, NO_RENAME(), BLGroupElement::Child::offset, Param, BLCommand::printError(), BLGroupElement::Child::rename, BLGroupElement::Child::rot, setMinHeight(), setMinLength(), setMinWidth(), BLParam::setParam(), width, and world.

Referenced by BLCMDplace::command(), BLCMDcorner::command(), and placeElement().

{
        BLGroupElement::Child c;
        c.element = element;
        c.rename = rename;

        // convert centerline coordinates to global coordinates, if world
        if(this == world && !global) {
                BLCoordinates::getCurrentGlobal(offset,c.offset);
                if(rot)
                        c.rot = *BLCoordinates::getCurrentRotation() * *rot;
                else
                        c.rot = *BLCoordinates::getCurrentRotation();
        } else {
                if(rot) c.rot = *rot;
                c.offset = offset;
        }

        // add this child
        child.push_back(c);

        // handle renamme
        if(rename == NO_RENAME)
                c.rename = element->getName();
        else if(rename.find('+') == 0)
                c.rename = getName()+rename.substr(1);

        // expand group to element's size.
        G4ThreeVector corner(element->getWidth()/2.0,element->getHeight()/2.0,
                                                element->getLength()/2.0);
        G4ThreeVector parent;
        // loop over all 8 corners of the bounding box of the element.
        for(int i=0; i<2; ++i) {
            corner[0] = -corner[0];
            for(int j=0; j<2; ++j) {
                corner[1] = -corner[1];
                for(int k=0; k<2; ++k) {
                        corner[2] = -corner[2];
                        if(rot)
                                parent = *rot * corner;
                        else
                                parent = corner;
                        G4double x = offset[0]+parent[0];
                        if(!fixedWidth)
                                setMinWidth(2.0*fabs(x));
                        else if(fabs(x) > width/2.0)
                            printError("Element '%s' extends outside '%s' in x",
                                c.rename.c_str(),getName().c_str());
                        G4double y = offset[1]+parent[1];
                        if(!fixedHeight)
                                setMinHeight(2.0*fabs(y));
                        else if(fabs(y) > height/2.0)
                            printError("Element '%s' extends outside '%s' in y",
                                c.rename.c_str(),getName().c_str());
                        G4double z = offset[2]+parent[2];
                        if(!fixedLength)
                                setMinLength(this==world ? fabs(z) : z);
                        else if(fabs(z) > length/2.0)
                            printError("Element '%s' extends outside '%s' in z",
                                c.rename.c_str(),getName().c_str());
                        if(i+j+k == 0 || z > lastZ)
                                lastZ = z;
                        if(this == world && !global) {
                                G4ThreeVector gp;
                                BLCoordinates::getCurrentGlobal(offset+parent,gp);
                                setMinWidth(2.0*fabs(gp[0]));
                                setMinHeight(2.0*fabs(gp[1]));
                                setMinLength(gp[2]);
                        }
                }
            }
        }

        // update z positions used
        if(lastZ > highZ)
                highZ = lastZ;
        if(this == world && !global)
                Param.setParam("Zcl",lastZ);
}

void BLGroup::placeElement	(	BLElement *	element,
		G4ThreeVector &	offset,
		G4String	rename,
		G4bool	global = false
	)			[virtual]

placeElement() will place an element within this group. With an offset, the length of the group must have been specified via an argument. Called by the place command.

References placeElement().

{
        placeElement(element,0,offset,rename,global);
}

void BLGroup::placeElement	(	BLElement *	element,
		G4String	rename,
		G4bool	global = false
	)			[virtual]

placeElement() will place an element within this group. With no offset, this element is placed immediately downstream of the previous element. If necessary, the endgroup command will compute the size of the group and readjust offsets so they are relative to the center of the group. Called by the place command.

References BLElement::getLength(), lastZ, offset, and placeElement().

{
        G4double l = element->getLength();
        G4ThreeVector offset(0.0,0.0,lastZ + l/2.0);
        placeElement(element,0,offset,rename,global);
}

void BLGroup::end

(

)

end() will compute the size of the group, if necessary, and pop the current group.

References BLGroupElement::child, current, height, highZ, length, prevCurrent, width, and world.

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

{
        // compute length if not set by argument, and adjust child offsets
        if(length == 0.0) {
                if(this == world) {
                        // z=0 is center
                        length = highZ * 2.0;
                } else {
                        // z=0 is where we started
                        length = highZ;
                        std::vector<BLGroupElement::Child>::iterator i;
                        for(i=child.begin(); i!=child.end(); ++i) {
                                i->offset[2] -= length/2.0;
                        }
                }
        }

        // expand world by 20.1357 cm
        if(this == world) {
                printf("\nWorld size (before incrementing by 201.357 mm): "
                    "%.1f H  %.1f W  %.1f L\n",height/mm,width/mm,length/mm);
                width += 20.1357*cm;
                height += 20.1357*cm;
                length += 20.1357*cm;
        }

        // pop current group
        if(current != world && prevCurrent != 0)
                current = prevCurrent;
        prevCurrent = 0;
}

G4ThreeVector& BLGroup::getOffset

(

)

[inline]

getOffset() returns the offset for the place command.

References offset.

Referenced by BLCMDplace::command().

{ return offset; }

void BLGroup::setOffset

(

G4ThreeVector &

offset

)

[inline]

setOffset() sets the offset for the place command.

Referenced by BLCMDplace::command().

{ this->offset = offset; }

BLGroup * BLGroup::getCurrent

(

)

[static]

getCurrent() returns a pointer to the current group (innermost active group command). Creates current and world if necessary. Used by the place command.

References current, and getWorld().

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

{
        if(!current) current = getWorld();
        return current;
}

BLGroup * BLGroup::getWorld

(

)

[static]

getWorld() returns a pointer to the World group. Creates current and world if necessary.

References BLGroup(), BLGroupElement::setName(), and world.

Referenced by BLCMDgeometry::callback(), BLCMDfieldlines::callback(), BLCMDreference::command(), BLCMDplace::command(), BLCMDendgroup::command(), BLCMDcosmicraybeam::command(), BLCMDcornerarc::command(), BLCMDcorner::command(), BLCMDbeam::command(), constructWorld(), getCurrent(), and main().

{
        if(!world) {
                world = new BLGroup(defaultGroup);
                world->setName("World");
        }
        return world;
}

G4VPhysicalVolume * BLGroup::constructWorld

(

)

[static]

constructWorld() constructs the beamline and returns a pointer to its world PhysicalVolume.

References construct(), getWorld(), and worldPhysVol.

Referenced by BLManager::Construct().

{
        G4ThreeVector abs;
        getWorld()->construct(0,abs,0,"",0,abs);
        worldPhysVol->GetLogicalVolume()->
                        SetVisAttributes(G4VisAttributes::GetInvisible());
        return worldPhysVol;
}

BLGroup& BLGroup::operator=

(

const BLGroup &

)

[private]

---

Friends And Related Function Documentation

friend class BLCMDendgroup [friend]

---

Member Data Documentation

BLGroup * BLGroup::current = 0 [static, private]

Referenced by command(), end(), and getCurrent().

BLGroup * BLGroup::world = 0 [static, private]

Referenced by construct(), end(), getWorld(), and placeElement().

G4VPhysicalVolume * BLGroup::worldPhysVol = 0 [static, private]

Referenced by construct(), and constructWorld().

BLGroup* BLGroup::prevCurrent [private]

Referenced by BLGroup(), command(), and end().

G4double BLGroup::highZ [private]

Referenced by BLGroup(), command(), end(), placeElement(), and setMinLength().

G4double BLGroup::lastZ [private]

Referenced by BLGroup(), command(), and placeElement().

G4double BLGroup::length [private]

Referenced by BLGroup(), command(), BLCMDendgroup::command(), construct(), defineNamedArgs(), end(), generatePoints(), getLength(), isOutside(), isWithin(), and placeElement().

G4double BLGroup::width [private]

Referenced by BLGroup(), command(), BLCMDendgroup::command(), construct(), defineNamedArgs(), end(), generatePoints(), getWidth(), isOutside(), isWithin(), placeElement(), and setMinWidth().

G4double BLGroup::height [private]

Referenced by BLGroup(), command(), BLCMDendgroup::command(), construct(), defineNamedArgs(), end(), generatePoints(), getHeight(), isOutside(), isWithin(), placeElement(), and setMinHeight().

G4double BLGroup::radius [private]

Referenced by BLGroup(), command(), construct(), defineNamedArgs(), generatePoints(), isOutside(), and isWithin().

G4String BLGroup::material [private]

Referenced by BLGroup(), command(), construct(), defineNamedArgs(), and setMaterial().

G4String BLGroup::color [private]

Referenced by BLGroup(), construct(), and defineNamedArgs().

G4double BLGroup::maxStep [private]

Referenced by BLGroup(), command(), construct(), and defineNamedArgs().

G4bool BLGroup::fixedLength [private]

Referenced by BLGroup(), command(), and placeElement().

G4bool BLGroup::fixedWidth [private]

Referenced by BLGroup(), command(), and placeElement().

G4bool BLGroup::fixedHeight [private]

Referenced by BLGroup(), command(), and placeElement().

G4ThreeVector BLGroup::offset [private]

Referenced by getOffset(), and placeElement().

---

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

• BLGroup.hh
• BLCMDgroup.cc
• BLGroup.cc