Ignore:
Timestamp:
Jan 8, 2010, 11:56:51 AM (14 years ago)
Author:
garnier
Message:

update geant4.9.3 tag

Location:
trunk/source/visualization/HepRep
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/source/visualization/HepRep/History

    r1140 r1228  
    1 .$Id: History,v 1.131 2009/10/21 15:13:36 allison Exp $
     1.$Id: History,v 1.132 2009/11/23 05:42:28 perl Exp $
    22-------------------------------------------------------------------
    33
    … …  
    2020History file for visualization/HepRep sub-category
    2121--------------------------------------------------
     22
     2322nd November 2009  Joseph Perl  (vis-HepRep-V09-02-03)
     24- Changed messenger to a singleton.
     25- Added messenger commands to HepRepFile.
     26- Render G4Tubs as polygons if G4Tubs is not at a standard angle.
    2227
    232821st October 2009  John Allison  (vis-HepRep-V09-02-02 coworks greps-V09-02-02)

  • trunk/source/visualization/HepRep/include/G4HepRep.hh

    r944 r1228  
    2424// ********************************************************************
    2525//
    26 // $Id: G4HepRep.hh,v 1.17 2006/06/29 21:17:04 gunter Exp $
     26// $Id: G4HepRep.hh,v 1.18 2009/11/23 05:42:28 perl Exp $
    2727// GEANT4 tag $Name:  $
    2828//
    … …  
    3636//G4
    3737#include "G4VGraphicsSystem.hh"
    38 
    39 class G4HepRepMessenger;
    4038
    4139class G4HepRep: public G4VGraphicsSystem {
    … …  
    5250        G4VSceneHandler* sceneHandler;
    5351        G4VViewer* viewer;
    54         G4HepRepMessenger* messenger;       
    5552};
    5653

  • trunk/source/visualization/HepRep/include/G4HepRepMessenger.hh

    r944 r1228  
    2424// ********************************************************************
    2525//
    26 // $Id: G4HepRepMessenger.hh,v 1.7 2006/06/29 21:17:14 gunter Exp $
     26// $Id: G4HepRepMessenger.hh,v 1.8 2009/11/23 05:42:28 perl Exp $
    2727// GEANT4 tag $Name:  $
    2828//
    … …  
    4040   
    4141    public:
    42         G4HepRepMessenger();
     42                static G4HepRepMessenger* GetInstance();  // Singleton constructor.
    4343        virtual ~G4HepRepMessenger();
    4444
    … …  
    4646        virtual void SetNewValue(G4UIcommand * command, G4String newValue);
    4747       
     48        // Used by HepRepFile
     49        virtual G4String getFileDir();
     50        virtual G4String getFileName();
     51        virtual G4bool getOverwrite();
     52        virtual G4bool getCullInvisibles();
     53       
     54        // Used by HepRepXML
    4855        virtual G4String getEventNumberSuffix();
    4956        virtual G4bool appendGeometry();
    … …  
    5360
    5461    private:           
     62                G4HepRepMessenger();  // Private constructor.
     63                static G4HepRepMessenger* fpInstance;
     64       
    5565        G4UIdirectory* heprepDirectory;
     66       
     67                G4String fileDir;
     68                G4UIcmdWithAString* setFileDirCommand;
     69       
     70                G4String fileName;
     71                G4UIcmdWithAString* setFileNameCommand;
     72       
     73                G4bool overwrite;
     74                G4UIcmdWithABool* setOverwriteCommand;
     75       
     76                G4bool cullInvisibles;
     77                G4UIcmdWithABool* setCullInvisiblesCommand;
    5678       
    5779        G4String suffix;
    … …  
    6688        G4bool solids;
    6789        G4UIcmdWithABool* useSolidsCommand;
    68 
     90       
    6991        G4bool invisibles;
    7092        G4UIcmdWithABool* writeInvisiblesCommand;

  • trunk/source/visualization/HepRep/include/G4HepRepSceneHandler.hh

    r1140 r1228  
    2424// ********************************************************************
    2525//
    26 // $Id: G4HepRepSceneHandler.hh,v 1.43 2009/10/21 15:08:35 allison Exp $
     26// $Id: G4HepRepSceneHandler.hh,v 1.44 2009/11/23 05:42:28 perl Exp $
    2727// GEANT4 tag $Name:  $
    2828//
    … …  
    6363#include "G4PhysicalVolumeModel.hh"
    6464
    65 #include "G4HepRepMessenger.hh"
    66 
    6765class G4HepRepSceneHandler: public G4VSceneHandler {
    6866
    6967    public:
    70         G4HepRepSceneHandler (G4VGraphicsSystem& system, G4HepRepMessenger& messenger, const G4String& name = "");
     68        G4HepRepSceneHandler (G4VGraphicsSystem& system, const G4String& name = "");
    7169        virtual ~G4HepRepSceneHandler ();
    7270
    … …  
    187185
    188186        // initialized Member Variables
    189         G4HepRepMessenger& messenger;
    190187        G4String geometryLayer, eventLayer, calHitLayer;
    191188        G4String trajectoryLayer, hitLayer;

  • trunk/source/visualization/HepRep/include/G4HepRepViewer.hh

    r944 r1228  
    2424// ********************************************************************
    2525//
    26 // $Id: G4HepRepViewer.hh,v 1.18 2006/06/29 21:17:18 gunter Exp $
     26// $Id: G4HepRepViewer.hh,v 1.19 2009/11/23 05:42:28 perl Exp $
    2727// GEANT4 tag $Name:  $
    2828//
    … …  
    4141#include "G4VViewer.hh"
    4242
    43 #include "G4HepRepMessenger.hh"
    44 
    4543class G4HepRepViewer: public G4VViewer {
    4644    public:
    47         G4HepRepViewer (G4VSceneHandler& scene, G4HepRepMessenger& messenger, const G4String& name = "");
     45        G4HepRepViewer (G4VSceneHandler& scene, const G4String& name = "");
    4846        virtual ~G4HepRepViewer ();
    4947        void SetView ();
    … …  
    5755    private:
    5856        bool geometryIncluded;
    59         G4HepRepMessenger& messenger;
    6057};
    6158

  • trunk/source/visualization/HepRep/src/G4HepRep.cc

    r944 r1228  
    2424// ********************************************************************
    2525//
    26 // $Id: G4HepRep.cc,v 1.22 2006/06/29 21:17:20 gunter Exp $
     26// $Id: G4HepRep.cc,v 1.23 2009/11/23 05:42:28 perl Exp $
    2727// GEANT4 tag $Name:  $
    2828//
    … …  
    5454          sceneHandler(NULL),
    5555          viewer(NULL) {
    56     messenger = new G4HepRepMessenger();
     56                G4HepRepMessenger::GetInstance();
    5757}
    5858
    5959G4HepRep::~G4HepRep () {
    60     delete messenger;
    6160}
    6261
    … …  
    6665        return NULL;
    6766    }
    68     sceneHandler = new G4HepRepSceneHandler (*this, *messenger, name);
     67    sceneHandler = new G4HepRepSceneHandler (*this, name);
    6968    return sceneHandler;
    7069}
    … …  
    7574        return NULL;
    7675    }
    77     viewer  = new G4HepRepViewer ((G4HepRepSceneHandler&)scene, *messenger, name);
     76    viewer  = new G4HepRepViewer ((G4HepRepSceneHandler&)scene, name);
    7877    return viewer;
    7978}

  • trunk/source/visualization/HepRep/src/G4HepRepFile.cc

    r944 r1228  
    2424// ********************************************************************
    2525//
    26 // $Id: G4HepRepFile.cc,v 1.11 2007/05/22 17:05:26 allison Exp $
     26// $Id: G4HepRepFile.cc,v 1.12 2009/11/23 05:42:28 perl Exp $
    2727// GEANT4 tag $Name:  $
    2828//
    … …  
    3838#include "G4HepRepFileSceneHandler.hh"
    3939#include "G4HepRepFileViewer.hh"
     40#include "G4HepRepMessenger.hh"
    4041
    4142static G4HepRepFileXMLWriter* hepRepXMLWriter;
    … …  
    4647                    "A HepRep (format 1) ascii file driver",
    4748                    G4VGraphicsSystem::threeD) {
     49                G4HepRepMessenger::GetInstance();
    4850        hepRepXMLWriter = new G4HepRepFileXMLWriter();
    4951}

  • trunk/source/visualization/HepRep/src/G4HepRepFileSceneHandler.cc

    r944 r1228  
    2424// ********************************************************************
    2525//
    26 // $Id: G4HepRepFileSceneHandler.cc,v 1.66 2008/01/04 22:11:31 allison Exp $
     26// $Id: G4HepRepFileSceneHandler.cc,v 1.68 2009/12/16 17:51:21 gunter Exp $
    2727// GEANT4 tag $Name:  $
    2828//
    … …  
    3434#include "G4HepRepFileSceneHandler.hh"
    3535#include "G4HepRepFile.hh"
     36#include "G4HepRepMessenger.hh"
     37#include "G4UIcommand.hh"
    3638
    3739#include "G4Version.hh"
    … …  
    7173        hepRepXMLWriter = ((G4HepRepFile*)(&system))->GetHepRepXMLWriter();
    7274        fileCounter = 0;
    73         int length;
    74        
    75         if (getenv("G4HEPREPFILE_DIR") == NULL)
    76                 strcpy(fileDir, "");
    77         else
    78                 length = sprintf (fileDir, "%s%s", getenv("G4HEPREPFILE_DIR"),"/");
    79        
    80         if (getenv("G4HEPREPFILE_NAME") == NULL)
    81                 strcpy(fileName, "G4Data");
    82         else
    83                 strcpy(fileName, getenv("G4HEPREPFILE_NAME"));
    84        
    85         if (getenv("G4HEPREPFILE_OVERWRITE") == NULL)
    86                 fileOverwrite = false;
    87         else
    88                 fileOverwrite = strcmp(getenv("G4HEPREPFILE_OVERWRITE"),"0");
    89        
    90         if (getenv("G4HEPREPFILE_CULL") == NULL)
    91                 cullInvisibleObjects = false;
    92         else
    93                 cullInvisibleObjects = strcmp(getenv("G4HEPREPFILE_CULL"),"0");
    9475       
    9576        inPrimitives2D = false;
    … …  
    180161        AddHepRepInstance("Prism", NULL);
    181162       
    182         if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && cullInvisibleObjects)
     163        G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     164       
     165        if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles())
    183166                return;
    184167       
    … …  
    243226                AddHepRepInstance("Cylinder", NULL);
    244227               
    245                 if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && cullInvisibleObjects)
     228                G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     229               
     230                if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles())
    246231                        return;
    247232               
    … …  
    278263#endif
    279264       
     265        // HepRApp does not correctly represent the end faces of cylinders at
     266        // non-standard angles, let the base class convert these solids to polygons.   
     267        CLHEP::HepRotation r = fpObjectTransformation->getRotation();   
     268        G4bool linedUpWithAnAxis = (std::fabs(r.phiX())<=.001 || 
     269                                                                std::fabs(r.phiY())<=.001 ||
     270                                                                std::fabs(r.phiZ())<=.001 ||
     271                                                                std::fabs(r.phiX()-pi)<=.001 ||
     272                                                                std::fabs(r.phiY()-pi)<=.001 ||
     273                                                                std::fabs(r.phiZ()-pi)<=.001); 
     274        //G4cout << "Angle X:" << r.phiX() << ", Angle Y:" << r.phiY() << ", Angle Z:" << r.phiZ() << G4endl;
     275        //G4cout << "linedUpWithAnAxis:" << linedUpWithAnAxis << G4endl;
     276       
    280277        // HepRep does not have a primitive for a cut cylinder,
    281278        // so if this cylinder is cut, let the base class convert this
    282279        // solid to polygons.
    283         if (tubs.GetDeltaPhiAngle() < twopi) {
     280        if (tubs.GetDeltaPhiAngle() < twopi || !linedUpWithAnAxis)
     281        {
    284282                G4VSceneHandler::AddSolid(tubs);  // Invoke default action.
    285283        } else {
    … …  
    294292                AddHepRepInstance("Cylinder", NULL);
    295293               
    296                 if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && cullInvisibleObjects)
     294                G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     295               
     296                if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles())
    297297                        return;
    298298               
    … …  
    340340        AddHepRepInstance("Prism", NULL);
    341341       
    342         if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && cullInvisibleObjects)
     342        G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     343       
     344        if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles())
    343345                return;
    344346       
    … …  
    10041006#endif
    10051007       
    1006         if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && cullInvisibleObjects)
     1008        G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     1009       
     1010        if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles())
    10071011                return;
    10081012       
    … …  
    10421046#endif
    10431047       
    1044         if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && cullInvisibleObjects)
     1048        G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     1049       
     1050        if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles())
    10451051                return;
    10461052       
    … …  
    11441150#endif
    11451151       
    1146         if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && cullInvisibleObjects)
     1152        G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     1153       
     1154        if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles())
    11471155                return;
    11481156       
    … …  
    11881196#endif
    11891197       
    1190         if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && cullInvisibleObjects)
     1198        G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     1199       
     1200        if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles())
    11911201                return;
    11921202       
    … …  
    12311241#endif
    12321242       
    1233         if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && cullInvisibleObjects)
     1243        G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     1244       
     1245        if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles())
    12341246                return;
    12351247       
    … …  
    14301442                hepRepXMLWriter->addInstance();
    14311443               
    1432                 if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && cullInvisibleObjects)
     1444                G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     1445               
     1446                if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles())
    14331447                        return;
    14341448               
    … …  
    15121526       
    15131527        if (!hepRepXMLWriter->isOpen) {
    1514                 char* newFileSpec;
    1515                 newFileSpec = new char [256];
    1516                 int length;
    1517                
    1518                 if (fileOverwrite)
    1519                         length = sprintf (newFileSpec, "%s%s%s",fileDir,fileName,".heprep");
    1520                 else
    1521                         length = sprintf (newFileSpec, "%s%s%d%s",fileDir,fileName,fileCounter,".heprep");
     1528                G4String newFileSpec;
     1529
     1530                G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     1531               
     1532                if (messenger->getOverwrite()) {
     1533                        newFileSpec = messenger->getFileDir()+messenger->getFileName()+".heprep";
     1534                } else {
     1535                        newFileSpec = messenger->getFileDir()+messenger->getFileName()+G4UIcommand::ConvertToString(fileCounter)+".heprep";
     1536                }
     1537               
    15221538                G4cout << "HepRepFile writing to " << newFileSpec << G4endl;
    15231539               
    15241540                hepRepXMLWriter->open(newFileSpec);
    1525                 fileCounter++;
     1541               
     1542                if (!messenger->getOverwrite())
     1543                        fileCounter++;
    15261544               
    15271545                hepRepXMLWriter->addAttDef("Generator", "HepRep Data Generator", "Physics","");

  • trunk/source/visualization/HepRep/src/G4HepRepMessenger.cc

    r944 r1228  
    2424// ********************************************************************
    2525//
    26 // $Id: G4HepRepMessenger.cc,v 1.10 2006/06/29 21:17:30 gunter Exp $
     26// $Id: G4HepRepMessenger.cc,v 1.11 2009/11/23 05:42:28 perl Exp $
    2727// GEANT4 tag $Name:  $
    2828//
    2929#include "G4HepRepMessenger.hh"
    3030
     31G4HepRepMessenger*
     32G4HepRepMessenger::fpInstance = 0;
     33
     34G4HepRepMessenger*
     35G4HepRepMessenger::GetInstance()
     36{
     37        if (!fpInstance) fpInstance = new G4HepRepMessenger;
     38        return fpInstance;
     39}
     40
    3141G4HepRepMessenger::G4HepRepMessenger() :
     42    fileDir(""),
     43        fileName("G4Data"),
     44        overwrite(false),
     45        cullInvisibles(false),
    3246    suffix (""),
    3347    geometry(true),
    … …  
    3751    heprepDirectory = new G4UIdirectory("/vis/heprep/");
    3852    heprepDirectory->SetGuidance("HepRep commands.");
    39 
     53               
     54        setFileDirCommand = new G4UIcmdWithAString("/vis/heprep/setFileDir", this);
     55        setFileDirCommand->SetGuidance("Set directory for output.");
     56        setFileDirCommand->SetGuidance("This command is used by HepRepFile, not by HepRepXML.");
     57        setFileDirCommand->SetParameterName("directory",false);
     58        if ( getenv( "G4HEPREPFILE_DIR" ) == NULL ) {
     59                setFileDirCommand->SetDefaultValue("");
     60        } else {
     61                setFileDirCommand->SetDefaultValue(getenv("G4HEPREPFILE_DIR"));
     62                fileDir = getenv("G4HEPREPFILE_DIR");
     63        }
     64        setFileDirCommand->AvailableForStates(G4State_Idle);
     65               
     66        setFileNameCommand = new G4UIcmdWithAString("/vis/heprep/setFileName", this);
     67        setFileNameCommand->SetGuidance("Set file name for output.");
     68        setFileNameCommand->SetGuidance("This command is used by HepRepFile, not by HepRepXML.");
     69        setFileNameCommand->SetParameterName("directory",false);
     70        if ( getenv( "G4HEPREPFILE_NAME" ) == NULL ) {
     71                setFileNameCommand->SetDefaultValue("G4Data");
     72        } else {
     73                setFileNameCommand->SetDefaultValue(getenv("G4HEPREPFILE_NAME"));
     74                fileName = getenv("G4HEPREPFILE_NAME");
     75        }
     76        setFileNameCommand->AvailableForStates(G4State_Idle);
     77
     78        setOverwriteCommand = new G4UIcmdWithABool("/vis/heprep/setOverwrite", this);
     79        setOverwriteCommand->SetGuidance("Set true to write all output to exact same file name.");
     80        setOverwriteCommand->SetGuidance("Set false to increment the file name for each new output.");
     81        setOverwriteCommand->SetGuidance("This command is used by HepRepFile, not by HepRepXML.");
     82        setOverwriteCommand->SetParameterName("flag",false);
     83        if ( getenv( "G4HEPREPFILE_OVERWRITE" ) == NULL ) {
     84                setOverwriteCommand->SetDefaultValue(false);
     85        } else {
     86                setOverwriteCommand->SetDefaultValue(getenv("G4HEPREPFILE_OVERWRITE"));
     87                overwrite = setOverwriteCommand->ConvertToBool(getenv("G4HEPREPFILE_OVERWRITE"));
     88        }
     89        setOverwriteCommand->AvailableForStates(G4State_Idle);
     90               
     91        setCullInvisiblesCommand = new G4UIcmdWithABool("/vis/heprep/setCullInvisibles", this);
     92        setCullInvisiblesCommand->SetGuidance("Remove invisible objects from output file.");
     93        setCullInvisiblesCommand->SetGuidance("This command is used by HepRepFile, not by HepRepXML.");
     94        setCullInvisiblesCommand->SetParameterName("flag",false);
     95        if ( getenv( "G4HEPREPFILE_CULL" ) == NULL ) {
     96                setCullInvisiblesCommand->SetDefaultValue(false);
     97        } else {
     98                setCullInvisiblesCommand->SetDefaultValue(getenv("G4HEPREPFILE_CULL"));
     99                cullInvisibles = setCullInvisiblesCommand->ConvertToBool(getenv("G4HEPREPFILE_CULL"));
     100        }
     101        setCullInvisiblesCommand->AvailableForStates(G4State_Idle);
     102               
    40103    setEventNumberSuffixCommand = new G4UIcmdWithAString("/vis/heprep/setEventNumberSuffix", this);
    41104    setEventNumberSuffixCommand->SetGuidance("Write separate event files, appended with given suffix.");
    42105    setEventNumberSuffixCommand->SetGuidance("Define the suffix with a pattern such as '-0000'.");
     106        setEventNumberSuffixCommand->SetGuidance("This command is used by HepRepXML, not by HepRepFile.");
    43107    setEventNumberSuffixCommand->SetParameterName("suffix",false);
    44108    setEventNumberSuffixCommand->SetDefaultValue("");
    … …  
    47111    appendGeometryCommand = new G4UIcmdWithABool("/vis/heprep/appendGeometry", this);
    48112    appendGeometryCommand->SetGuidance("Appends copy of geometry to every event.");
     113        appendGeometryCommand->SetGuidance("This command is used by HepRepXML, not by HepRepFile.");
    49114    appendGeometryCommand->SetParameterName("flag",false);
    50115    appendGeometryCommand->SetDefaultValue(true);
    … …  
    53118    addPointAttributesCommand = new G4UIcmdWithABool("/vis/heprep/addPointAttributes", this);
    54119    addPointAttributesCommand->SetGuidance("Adds point attributes to the points of trajectories.");
     120        addPointAttributesCommand->SetGuidance("This command is used by HepRepXML, not by HepRepFile.");
    55121    addPointAttributesCommand->SetParameterName("flag",false);
    56122    addPointAttributesCommand->SetDefaultValue(false);
    … …  
    59125    useSolidsCommand = new G4UIcmdWithABool("/vis/heprep/useSolids", this);
    60126    useSolidsCommand->SetGuidance("Use HepRep Solids, rather than Geant4 Primitives.");
     127        useSolidsCommand->SetGuidance("This command is used by HepRepXML, not by HepRepFile.");
    61128    useSolidsCommand->SetParameterName("flag",false);
    62129    useSolidsCommand->SetDefaultValue(true);
    63130    useSolidsCommand->AvailableForStates(G4State_Idle);
    64 
    65 /* Not Enabled Yet
    66     writeInvisiblesCommand = new G4UIcmdWithABool("/vis/heprep/writeInvisibles", this);
    67     writeInvisiblesCommand->SetGuidance("Write invisible objects.");
    68     writeInvisiblesCommand->SetParameterName("flag",false);
    69     writeInvisiblesCommand->SetDefaultValue(true);
    70     writeInvisiblesCommand->AvailableForStates(G4State_Idle);
    71 */
    72131}
    73132
    74133G4HepRepMessenger::~G4HepRepMessenger() {
     134        delete setFileDirCommand;
     135        delete setFileNameCommand;
     136        delete setOverwriteCommand;
     137        delete setCullInvisiblesCommand;
    75138    delete setEventNumberSuffixCommand;
    76139    delete appendGeometryCommand;
    77140    delete addPointAttributesCommand;
    78141    delete useSolidsCommand;
    79 //    delete writeInvisiblesCommand;
    80142    delete heprepDirectory;
    81143}
    82144
    83145G4String G4HepRepMessenger::GetCurrentValue(G4UIcommand * command) {
    84     if (command==setEventNumberSuffixCommand) {
    85         return suffix;
     146    if (command==setFileDirCommand) {
     147        return fileDir;
     148    } else if (command==setFileNameCommand) {
     149        return fileName;
     150    } else if (command==setOverwriteCommand) {
     151        return overwrite;
     152    } else if (command==setCullInvisiblesCommand) {
     153        return cullInvisibles;
     154    } else if (command==setEventNumberSuffixCommand) {
     155        return suffix;
    86156    } else if (command==appendGeometryCommand) {
    87157        return appendGeometryCommand->ConvertToString(geometry);
    … …  
    90160    } else if (command==useSolidsCommand) {
    91161        return useSolidsCommand->ConvertToString(solids);
    92 //    } else if (command==writeInvisiblesCommand) {
    93 //        return writeInvisiblesCommand->ConvertToString(invisibles);
    94162    } else {
    95163        return "";
    … …  
    98166
    99167void G4HepRepMessenger::SetNewValue(G4UIcommand * command, G4String newValue) {
    100     if (command==setEventNumberSuffixCommand) {
     168    if (command==setFileDirCommand) {
     169        fileDir = newValue;
     170    } else if (command==setFileNameCommand) {
     171        fileName = newValue;
     172    } else if (command==setOverwriteCommand) {
     173        overwrite = setOverwriteCommand->GetNewBoolValue(newValue);
     174    } else if (command==setCullInvisiblesCommand) {
     175                cullInvisibles = setCullInvisiblesCommand->GetNewBoolValue(newValue);
     176    } else if (command==setEventNumberSuffixCommand) {
    101177        suffix = newValue;
    102178    } else if (command==appendGeometryCommand) {
    … …  
    106182    } else if (command==useSolidsCommand) {
    107183        solids = useSolidsCommand->GetNewBoolValue(newValue);
    108 //    } else if (command==writeInvisiblesCommand) {
    109 //        invisibles = writeInvisiblesCommand->GetNewBoolValue(newValue);
    110184    }
     185}
     186
     187G4String G4HepRepMessenger::getFileDir() {
     188    return fileDir;
     189}
     190
     191G4String G4HepRepMessenger::getFileName() {
     192    return fileName;
     193}
     194
     195G4bool G4HepRepMessenger::getOverwrite() {
     196    return overwrite;
     197}
     198
     199G4bool G4HepRepMessenger::getCullInvisibles() {
     200    return cullInvisibles;
    111201}
    112202

  • trunk/source/visualization/HepRep/src/G4HepRepSceneHandler.cc

    r944 r1228  
    2424// ********************************************************************
    2525//
    26 // $Id: G4HepRepSceneHandler.cc,v 1.101 2007/11/16 20:29:04 perl Exp $
     26// $Id: G4HepRepSceneHandler.cc,v 1.102 2009/11/23 05:42:28 perl Exp $
    2727// GEANT4 tag $Name:  $
    2828//
    … …  
    4545//HepRep
    4646#include "HEPREP/HepRep.h"
     47#include "G4HepRepMessenger.hh"
    4748
    4849//G4
    … …  
    9091//#define PDEBUG 1
    9192
    92 G4HepRepSceneHandler::G4HepRepSceneHandler (G4VGraphicsSystem& system, G4HepRepMessenger& heprepMessenger, const G4String& name)
     93G4HepRepSceneHandler::G4HepRepSceneHandler (G4VGraphicsSystem& system, const G4String& name)
    9394        : G4VSceneHandler (system, sceneIdCount++, name),
    94           messenger             (heprepMessenger),
    9595          geometryLayer         ("Geometry"),
    9696          eventLayer            ("Event"),
    … …  
    247247            writeMultipleFiles = false;
    248248            int startDigit = -1; int endDigit = -1;
    249             string suffix = messenger.getEventNumberSuffix();
     249
     250                        G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     251
     252            string suffix = messenger->getEventNumberSuffix();
    250253            if (suffix != "") {
    251254                // look for 0000 pattern in suffix
    … …  
    331334        }
    332335    } else {
     336               
     337                G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
    333338
    334339        // add geometry to the heprep if there is an event (separate geometries are written
    … …  
    338343       
    339344            // couple geometry
    340             if (messenger.appendGeometry()) {
     345
     346            if ( messenger->appendGeometry()) {
    341347                // couple geometry to event if geometry was written
    342348                if ((_geometryInstanceTree != NULL)) {
    … …  
    374380
    375381        // write out separate geometry
    376         if (!messenger.appendGeometry() && (_heprepGeometry != NULL)) {
     382        if (! messenger->appendGeometry() && (_heprepGeometry != NULL)) {
    377383            if (writeMultipleFiles) {
    378384                char fileName[128];
    … …  
    493499
    494500    if (dontWrite()) return;
    495 
    496     if (!messenger.useSolids()) {
     501       
     502        G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     503
     504    if (! messenger->useSolids()) {
    497505        G4VSceneHandler::AddSolid(box);
    498506        return;
    … …  
    547555
    548556    if (dontWrite()) return;
    549 
    550     if (!messenger.useSolids() || (cons.GetDeltaPhiAngle() < twopi)) {
     557       
     558        G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     559
     560    if (! messenger->useSolids() || (cons.GetDeltaPhiAngle() < twopi)) {
    551561        G4VSceneHandler::AddSolid(cons);
    552562        return;
    … …  
    609619
    610620    if (dontWrite()) return;
    611 
    612     if (!messenger.useSolids() || (tubs.GetDeltaPhiAngle() < twopi)) {
     621       
     622        G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     623
     624    if (! messenger->useSolids() || (tubs.GetDeltaPhiAngle() < twopi)) {
    613625        G4VSceneHandler::AddSolid(tubs);
    614626        return;
    … …  
    666678#endif
    667679    if (dontWrite()) return;
    668 
    669     if (!messenger.useSolids()) {
     680       
     681        G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     682
     683    if (! messenger->useSolids()) {
    670684        G4VSceneHandler::AddSolid(trd);
    671685        return;
    … …  
    9941008
    9951009
    996 G4bool G4HepRepSceneHandler::dontWrite() {
    997     return !(messenger.writeInvisibles() || (fpVisAttribs ? (bool)fpVisAttribs->IsVisible() : true));
     1010G4bool G4HepRepSceneHandler::dontWrite() {     
     1011        G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     1012    return !( messenger->writeInvisibles() || (fpVisAttribs ? (bool)fpVisAttribs->IsVisible() : true));
    9981013}
    9991014
    … …  
    13671382    type->addAttDef(  "PointUnit", "Length", "Physics", "");
    13681383    type->addAttValue("PointUnit", G4String("m"));
     1384       
     1385        G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
    13691386
    13701387    type->addAttDef(  "UseSolids", "Use HepRep Solids rather than Geant4 Primitives", "Draw", "");
    1371     type->addAttValue("UseSolids", messenger.useSolids());
     1388    type->addAttValue("UseSolids", messenger->useSolids());
    13721389
    13731390    type->addAttDef(  "WriteInvisibles", "Write Invisible Objects", "Draw", "");
    1374     type->addAttValue("WriteInvisibles", messenger.writeInvisibles());
     1391    type->addAttValue("WriteInvisibles", messenger->writeInvisibles());
    13751392}           
    13761393
    … …  
    14091426        // Create the Geometry InstanceTree.
    14101427        _geometryInstanceTree = factory->createHepRepInstanceTree("G4GeometryData", "1.0", getGeometryTypeTree());
    1411         if (messenger.appendGeometry()) {
     1428               
     1429                G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     1430        if ( messenger->appendGeometry()) {
    14121431            getHepRep()->addInstanceTree(_geometryInstanceTree);
    14131432        } else {
    … …  
    14761495        HepRepTreeID* geometryTreeID = factory->createHepRepTreeID("G4GeometryTypes", "1.0");
    14771496        _geometryTypeTree = factory->createHepRepTypeTree(geometryTreeID);
    1478         if (messenger.appendGeometry()) {
     1497               
     1498                G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     1499        if ( messenger->appendGeometry()) {
    14791500            getHepRep()->addTypeTree(_geometryTypeTree);
    14801501        } else {

  • trunk/source/visualization/HepRep/src/G4HepRepViewer.cc

    r944 r1228  
    2424// ********************************************************************
    2525//
    26 // $Id: G4HepRepViewer.cc,v 1.26 2006/06/29 21:17:34 gunter Exp $
     26// $Id: G4HepRepViewer.cc,v 1.27 2009/11/23 05:42:28 perl Exp $
    2727// GEANT4 tag $Name:  $
    2828//
    … …  
    4040#include "G4Scene.hh"
    4141#include "G4HepRep.hh"
     42#include "G4HepRepMessenger.hh"
    4243#include "G4HepRepSceneHandler.hh"
    4344//This
    … …  
    4748using namespace std;
    4849
    49 G4HepRepViewer::G4HepRepViewer (G4VSceneHandler& sceneHandler, G4HepRepMessenger& heprepMessenger, const G4String& name)
     50G4HepRepViewer::G4HepRepViewer (G4VSceneHandler& sceneHandler, const G4String& name)
    5051        : G4VViewer (sceneHandler, sceneHandler.IncrementViewCount(), name),
    51         geometryIncluded(false),
    52         messenger(heprepMessenger) {
     52        geometryIncluded(false) {
    5353
    5454#ifdef SDEBUG
    … …  
    111111    if (sceneHandler->closeHepRep()) {
    112112        sceneHandler->openHepRep();
    113         if (messenger.appendGeometry()) geometryIncluded = false;
     113               
     114                G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     115        if (messenger->appendGeometry()) geometryIncluded = false;
    114116    }
    115117}
Note: See TracChangeset for help on using the changeset viewer.