source: trunk/source/geometry/solids/test/SBT/src/SBTvoxelMessenger.cc @ 1358

//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
//
// SBTvoxelMessenger.cc
//
// Implementation of the messenger for the voxel test
//

#include "SBTvoxelMessenger.hh"
#include "SBTvoxel.hh"
#include "SBTVisManager.hh"
#include "G4SolidQuery.hh"

#include "G4VoxelLimits.hh"
#include "G4AffineTransform.hh"

#include "G4ios.hh"
#include "G4UIdirectory.hh"
#include "G4UIcommand.hh"
#include "G4UIcmdWith3VectorAndUnit.hh"
#include "G4UIcmdWithAnInteger.hh"
#include "G4UIcmdWithAString.hh"
#include "G4UIcmdWithoutParameter.hh"
#include "G4UIcmdWith3Vector.hh"

#include "G4UIcmdWithPargs.hh"
#include "G4UIcmdPargDouble.hh"
#include "G4UIcmdPargInteger.hh"

#include <fstream>

//
// Constructor
//
SBTvoxelMessenger::SBTvoxelMessenger( const G4String prefix, 
                                      const G4SolidQuery *theSolidQuery, SBTVisManager *theVisManager )
                        : tester(), errorFile("sbtvoxel.log")
{
        //
        // Initialize
        //
        visManager = theVisManager;
        translate = new G4ThreeVector;
        rotate = new G4RotationMatrix;
        voxel = 0;
        point = 0;
        limits[0] = +1000.0;
        limits[1] = -1000.0;
        axis = kXAxis;
        
        //
        // Store solid query
        //
        solidQuery = theSolidQuery;

        //
        // Declare directory
        //
        voxelDirectory = new G4UIdirectory( prefix );
        voxelDirectory->SetGuidance( "Controls for CSG batch voxel tester" );
        
        //
        // Target command
        //
        G4String com = prefix+"target";
        targetCmd = new G4UIcmdWith3VectorAndUnit( com, this );
        targetCmd->SetGuidance( "Center of distribution of random points" );
        targetCmd->SetParameterName( "X", "Y", "Z", true, true );
        
        //
        // Widths command
        //
        com = prefix+"widths";
        widthsCmd = new G4UIcmdWith3VectorAndUnit( com, this );
        widthsCmd->SetGuidance( "Widths of distribution of random points" );
        widthsCmd->SetParameterName( "Dx", "Dy", "Dz", true, true );

        //
        // Max Voxels command
        //
        com = prefix+"maxVoxels";
        maxVoxelsCmd = new G4UIcmdWithAnInteger( com, this );
        maxVoxelsCmd->SetGuidance( "Maximum number of Voxels before test ends" );

        //
        // Max Errors command
        //      
        com = prefix+"maxErrors";
        maxErrorsCmd = new G4UIcmdWithAnInteger( com, this );
        maxErrorsCmd->SetGuidance( "Maximum number of errors before test ends" );
        
        //
        // Error filename command
        //
        com = prefix+"errorFileName";
        errorFileCmd = new G4UIcmdWithAString( com, this );
        errorFileCmd->SetGuidance( "Filename in which to send error listings" );
        
        //
        // Run command
        //
        com = prefix+"run";
        runCmd = new G4UIcmdWithoutParameter( com, this );
        runCmd->SetGuidance( "Execute voxel test" );
        
        //
        // Picture directory
        //
        com = prefix+"picture/";
        pictDirectory = new G4UIdirectory( com );
        pictDirectory->SetGuidance( "Controls for drawing CSG voxel tests" );
        
        //
        // picture/voxel command
        //
        pictVoxelArgs[0] = new G4UIcmdPargDouble( "xmin", 1.0, mm );
        pictVoxelArgs[1] = new G4UIcmdPargDouble( "xmax", 1.0, mm );
        pictVoxelArgs[2] = new G4UIcmdPargDouble( "ymin", 1.0, mm );
        pictVoxelArgs[3] = new G4UIcmdPargDouble( "ymax", 1.0, mm );
        pictVoxelArgs[4] = new G4UIcmdPargDouble( "zmin", 1.0, mm );
        pictVoxelArgs[5] = new G4UIcmdPargDouble( "zmax", 1.0, mm );
        com = prefix+"picture/voxel";
        pictVoxelCmd = new G4UIcmdWithPargs( com, this, pictVoxelArgs, 6 );
        pictVoxelCmd->SetGuidance( "Specifies the voxel to draw" );

        //
        // picture/translate command
        //
        com = prefix+"picture/translate";
        pictTranCmd = new G4UIcmdWith3Vector( com, this );
        pictTranCmd->SetGuidance( "Specifies the voxel translation" );
        
        //
        // picture/rotate command
        //
        pictRotArgs[0] = new G4UIcmdPargDouble( "xaxis", 1.0, 1 );
        pictRotArgs[1] = new G4UIcmdPargDouble( "yaxis", 1.0, 1 );
        pictRotArgs[2] = new G4UIcmdPargDouble( "zaxis", 1.0, 1 );
        pictRotArgs[3] = new G4UIcmdPargDouble( "amount", 1.0, 1 );
        com = prefix+"picture/rotate";
        pictRotCmd = new G4UIcmdWithPargs( com, this, pictRotArgs, 4 );
        pictRotCmd->SetGuidance( "Specifies rotation matrix" );

        //
        // picture/point command
        //
        com = prefix+"picture/point";
        pictPointCmd = new G4UIcmdWith3Vector( com, this );
        pictPointCmd->SetGuidance( "Specifies one point to include in the picture" );
        
        //
        // picture/limit command
        //
        pictLimitArgs[0] = new G4UIcmdPargInteger( "axis", 1 );
        pictLimitArgs[1] = new G4UIcmdPargDouble( "min", 1.0, mm );
        pictLimitArgs[2] = new G4UIcmdPargDouble( "max", 1.0, mm );
        com = prefix+"picture/limit";
        pictLimitCmd = new G4UIcmdWithPargs( com, this, pictLimitArgs, 3 );
        pictLimitCmd->SetGuidance( "Specifies voxel limits" );
        
        //
        // picture/draw command
        //
        com = prefix+"picture/draw";
        pictDrawCmd = new G4UIcmdWithoutParameter( com, this );
        pictDrawCmd->SetGuidance( "Draw the picture" );

        //
        // picture/debug command
        //
        com = prefix+"picture/debug";
        pictDebugCmd = new G4UIcmdWithoutParameter( com, this );
        pictDebugCmd->SetGuidance( "Call CalculateExtent for the picture" );
}



//
// Destructor
//
SBTvoxelMessenger::~SBTvoxelMessenger()
{
        if (voxel) delete voxel;
        if (point) delete point;

//      delete targetCmd;
//      delete widthsCmd;
//      delete maxVoxelsCmd;
//      delete maxVoxelsCmd;
//      delete errorFileCmd;
        delete voxelDirectory;
        
        delete pictDirectory;
}
        

//
// InvokeTest
//
// Run the test
//
void SBTvoxelMessenger::InvokeTest()
{
        //
        // Is there a Solid to test?
        //
        G4VSolid *testSolid = solidQuery->GetSolid();
        if (testSolid == 0) {
                G4cerr << "Please initialize geometry before running test" << G4endl;
                G4cerr << "Test ABORTED" << G4endl;
                return;
        }

        //
        // Open output file
        //
        std::ofstream logFile( errorFile );
        
        //
        // Run the test
        //
        tester.RunTest( testSolid, logFile );
}


void SBTvoxelMessenger::Draw()
{
        if (!visManager) 
                G4cerr << "Visualization is not available in this executable" << G4endl;

        //
        // Is there a Solid to test?
        //
        G4VSolid *testSolid = solidQuery->GetSolid();
        if (testSolid == 0) {
                G4cerr << "Please initialize geometry before running test" << G4endl;
                return;
        }
        
        //
        // Is there a voxel to test?
        //
        if (voxel == 0) {
                G4cerr << "Please specify a voxel to draw using /pict/voxel command" << G4endl;
                return;
        }

        //
        // Go do it
        //
        visManager->BuildFakeWorld();
        
        G4AffineTransform transform( *rotate, *translate );
        
        tester.Draw( testSolid, *voxel, transform, point, point ? 1 : 0, axis, limits, visManager );
}


void SBTvoxelMessenger::Debug()
{
        //
        // Is there a Solid to test?
        //
        G4VSolid *testSolid = solidQuery->GetSolid();
        if (testSolid == 0) {
                G4cerr << "Please initialize geometry before running test" << G4endl;
                return;
        }
        
        //
        // Is there a voxel to test?
        //
        if (voxel == 0) {
                G4cerr << "Please specify a voxel to debug using /pict/voxel command" << G4endl;
                return;
        }

        //
        // Go do it
        //
        G4AffineTransform transform( *rotate, *translate );
        
        tester.Debug( testSolid, axis, *voxel, transform, point );
}


//
// SetNewValue
//
// Call by the UI when user requests a change
//
void SBTvoxelMessenger::SetNewValue( G4UIcommand *command, G4String newValues )
{
        if (command == targetCmd) {
                tester.SetTarget( targetCmd->GetNew3VectorValue( newValues ) );
        }
        else if (command == widthsCmd) {
                tester.SetWidths( widthsCmd->GetNew3VectorValue( newValues ) );
        }
        else if (command == maxVoxelsCmd) {
                tester.SetMaxVoxels( maxVoxelsCmd->GetNewIntValue( newValues ) );
        }
        else if (command == maxErrorsCmd) {
                tester.SetMaxErrors( maxErrorsCmd->GetNewIntValue( newValues ) );
        }
        else if (command == errorFileCmd) {
                errorFile = newValues;
        }
        else if (command == runCmd) {
                InvokeTest();
        }
        else if (command == pictVoxelCmd) {
                if (pictVoxelCmd->GetArguments( newValues )) {
                        G4UIcmdPargDouble *minX = (G4UIcmdPargDouble *)pictVoxelArgs[0],
                                          *maxX = (G4UIcmdPargDouble *)pictVoxelArgs[1],
                                          *minY = (G4UIcmdPargDouble *)pictVoxelArgs[2],
                                          *maxY = (G4UIcmdPargDouble *)pictVoxelArgs[3],
                                          *minZ = (G4UIcmdPargDouble *)pictVoxelArgs[4],
                                          *maxZ = (G4UIcmdPargDouble *)pictVoxelArgs[5];

                        if (voxel) delete voxel;

                        voxel = new G4VoxelLimits;

                        if (minX->GetValue() < maxX->GetValue())
                                voxel->AddLimit( kXAxis, minX->GetValue(), maxX->GetValue() );
                        if (minY->GetValue() < maxY->GetValue())
                                voxel->AddLimit( kYAxis, minY->GetValue(), maxY->GetValue() );
                        if (minZ->GetValue() < maxZ->GetValue())
                                voxel->AddLimit( kZAxis, minZ->GetValue(), maxZ->GetValue() );
                }
                else
                        G4cerr << "Syntax error" << G4endl;
        }
        else if (command == pictTranCmd) {
                *translate = pictTranCmd->GetNew3VectorValue( newValues );
        }
        else if (command == pictRotCmd) {
                if (pictRotCmd->GetArguments( newValues )) {
                        G4UIcmdPargDouble *rotX = (G4UIcmdPargDouble *)pictRotArgs[0],
                                          *rotY = (G4UIcmdPargDouble *)pictRotArgs[1],
                                          *rotZ = (G4UIcmdPargDouble *)pictRotArgs[2],
                                          *amount = (G4UIcmdPargDouble *)pictRotArgs[3];

                        G4ThreeVector rotAxis( rotX->GetValue(), rotY->GetValue(), rotZ->GetValue() );

                        delete rotate;
                        rotate = new G4RotationMatrix();
                        rotate->rotate( amount->GetValue(), &rotAxis );
                }
                else
                        G4cerr << "Syntax error" << G4endl;
        }
        else if (command == pictPointCmd) {
                if (point) delete point;
                point = new G4ThreeVector();
                *point = pictPointCmd->GetNew3VectorValue( newValues );
        }
        else if (command == pictLimitCmd) {
                if (pictLimitCmd->GetArguments( newValues )) {
                        static const EAxis axes[3] = { kXAxis, kYAxis, kZAxis };
                        
                        G4UIcmdPargInteger *axisArg = (G4UIcmdPargInteger *)pictLimitArgs[0];
                        G4UIcmdPargDouble     *min  = (G4UIcmdPargDouble  *)pictLimitArgs[1],
                                              *max  = (G4UIcmdPargDouble  *)pictLimitArgs[2];
                        
                        G4int axisIndex = axisArg->GetValue();    
                        if (axisIndex < 0 || axisIndex > 2) {
                                G4cerr << "Axis value must be from 0 to 2" << G4endl;
                        }
                        else {
                                axis = axes[axisIndex];
                                limits[0] = min->GetValue();
                                limits[1] = max->GetValue();
                        }
                }
                else
                        G4cerr << "Syntax error" << G4endl;
        }
        else if (command == pictDrawCmd) {
                Draw();
        }
        else if (command == pictDebugCmd) {
                Debug();
        }
        else {
                G4Exception( "Unrecognized command" );
        }
}

        

//
// GetCurrentValue
//
G4String SBTvoxelMessenger::GetCurrentValue( G4UIcommand *command )
{
        if (command == targetCmd) {
                return targetCmd->ConvertToString( tester.GetTarget(), "m" );
        }
        else if (command == widthsCmd) {
                return widthsCmd->ConvertToString( tester.GetWidths(), "m" );
        }
        else if (command == maxVoxelsCmd) {
                return maxVoxelsCmd->ConvertToString( tester.GetMaxVoxels() );
        }
        else if (command == maxErrorsCmd) {
                return maxErrorsCmd->ConvertToString( tester.GetMaxErrors() );
        }
        else if (command == errorFileCmd) {
                return errorFile;
        }
        else if (command == runCmd) {
                return "";
        }
        else if (command == pictVoxelCmd) {
                return "";
        }
        else if (command == pictTranCmd) {
                return "";
        }
        else if (command == pictRotCmd) {
                return "";
        }
        else if (command == pictPointCmd) {
                return "";
        }
        else if (command == pictLimitCmd) {
                return "";
        }
        else if (command == pictDebugCmd) {
                return "";
        }
        else if (command == pictDrawCmd) {
                return "";
        }
        
        G4Exception( "Unrecognized command" );
        return "foo!";
}