BLGroup.hh

Go to the documentation of this file.

//      BLGroup.hh
/*
This source file is part of G4beamline, http://g4beamline.muonsinc.com
Copyright (C) 2003,2004,2005,2006 by Tom Roberts, all rights reserved.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

http://www.gnu.org/copyleft/gpl.html
*/

#ifndef BLGROUP_HH
#define BLGROUP_HH

#include <vector>
#include "G4RotationMatrix.hh"
#include "G4VPhysicalVolume.hh"
#include "G4ThreeVector.hh"
#include "BLGroupElement.hh"


/**     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.
 **/
class BLGroup : public BLGroupElement {
        struct Child { G4RotationMatrix rot; G4ThreeVector offset;
                                BLElement *element; G4String rename; };
        static BLGroup *current;
        static BLGroup *world;
        static G4VPhysicalVolume *worldPhysVol;
        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;   // exclusively for the place command
        friend class BLCMDendgroup;
public:
        /// Default Constructor. registers the command and provides help text.
        BLGroup();

        /// Copy Constructor for a real BLGroup.
        BLGroup(BLGroup& r) : 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; }

        /// Destructor.
        ~BLGroup();

        /// clone() - invalid.
        BLElement *clone() { return 0; }

        /// commandName() returns "group";
        virtual G4String commandName() { return "group"; }

        /// command() implements the group command.
        int command(BLArgumentVector& argv, BLArgumentMap& namedArgs);

        /// defineNamedArgs() defines the arguments to the command.
        void defineNamedArgs();

        /// construct() will construct an instance of this group, and construct
        /// its contents recursively.
        virtual void construct(G4RotationMatrix *relativeRotation,
                        G4ThreeVector relativePosition, 
                        G4LogicalVolume *parent, 
                        G4String parentName,
                        G4RotationMatrix *parentRotation,
                        G4ThreeVector parentPosition);

        /// getLength() returns this group's Length along the Z axis.
        G4double getLength() { return length; }

        /// getWidth() returns this group's Width along the X axis.
        G4double getWidth() { return width; }

        /// getHeight() returns this group's height along the Y axis.
        G4double getHeight() { return height; }

        /// setMinWidth() will increase the width, if necessary.
        void setMinWidth(G4double minWidth) 
                { if(width < minWidth) width = minWidth; }

        /// setMinHeight() will increase the height, if necessary.
        void setMinHeight(G4double minHeight) 
                { if(height < minHeight) height = minHeight; }

        /// setMinLength() will increase the length, if necessary.
        void setMinLength(G4double minLength) 
                { if(highZ < minLength) highZ = minLength; }

        /// setMaterial() sets the name of the group's material.
        void setMaterial(G4String mat) { material = mat; }

        /// isOK() returns true; individual elements are responsible for
        /// their own status.
        G4bool isOK() { return true; }

        /// isOutside() from BLElement.
        bool isOutside(G4ThreeVector &local, G4double tolerance);

        /// generatePoints from BLElement.
        void generatePoints(int npoints, std::vector<G4ThreeVector> &v);

        /// isWithin() from BLGroupElement.
        bool isWithin(G4ThreeVector &local, G4double tolerance);

        /// 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, G4RotationMatrix *rot,
                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, G4ThreeVector& offset, 
                                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.
        virtual void placeElement(BLElement* element, G4String rename, 
                                                        G4bool global=false);

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

        /// getOffset() returns the offset for the place command.
        G4ThreeVector& getOffset() { return offset; }

        /// setOffset() sets the offset for the place command.
        void setOffset(G4ThreeVector& offset) { this->offset = offset; }

        /// 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 *getCurrent();

        /// getWorld() returns a pointer to the World group.
        ///  Creates current and world if necessary.
        static BLGroup *getWorld();

        /// constructWorld() constructs the beamline and returns a pointer
        /// to its world PhysicalVolume.
        static G4VPhysicalVolume *constructWorld();
private:
        BLGroup& operator=(const BLGroup&);     // undefined
};

#endif // BLGROUP_HH