//
//
// RPCScanner-DetectorConstruction.cc
//
//
// class RPCScanner_DetectorConstruction - implementation
//
//
// ***********************************
// * Implements RPC Scanner detector *
// ***********************************
//
//
// ----------------------------------------------------------------------
// Author:      Miguel Couceiro
// Version:     3.0
// Date:        May 2009
// ----------------------------------------------------------------------




/* ********************** */
/* **** Header Files **** */
/* ********************** */
#include <algorithm>
#include <cmath>


#include <globals.hh>

#include <G4VPVParameterisation.hh>
#include <G4SubtractionSolid.hh>
#include <G4GeometryManager.hh>
#include <G4PVParameterised.hh>
#include <G4PVPlacement.hh>
#include <G4ThreeVector.hh>


#include <PhantomFactory.hh>
#include <Materials.hh>

#ifdef	G4VIS_USE
	#include <VisManager.hh>
#endif	//	G4VIS_USE


#include <RPC-DetectorParameterisation.hh>
#include <RPC-ScannerParameterisation.hh>
#include <RPC-ModuleParameterisation.hh>
#include <RPC-HeadParameterisation.hh>

#include <RPC-ScannerParameters.hh>
#include <RPC-HeadParameters.hh>
#include <RPC-DetectorParameters.hh>
#include <RPC-ModuleParameters.hh>
#include <RPC-Parameters.hh>
#include <RPC-SD.hh>

#include "RPCScanner-DetectorConstruction.hh"




/* ********************************* */
/* **** Constructors/Destructor **** */
/* ********************************* */

//	Default Constructor
RPCScanner_DetectorConstruction::RPCScanner_DetectorConstruction()
{
	//	World volume
	m_pExpWorld_box			= 0;
	m_pExpWorld_log			= 0;
	m_pExpWorld_phys		= 0;

#ifdef G4VIS_USE
	m_pExpWorld_vis			= 0;
#endif	//	G4VIS_USE


	//	RPC Scanner
	for (G4int i = 0 ; i < 3 ; i++)
		m_pScanner_box[i] = 0;

	m_pScanner_log			= 0;
	m_pScanner_phys			= 0;
#ifdef G4VIS_USE
	m_pScanner_vis			= 0;
#endif	//	G4VIS_USE


	//	RPC Head
	for (G4int i = 0 ; i < 2 ; i++)
	{
		m_pHead_box[i]		= 0;
		m_pHead_log[i]		= 0;
		m_pHead_phys[i]		= 0;

#ifdef G4VIS_USE
		m_pHead_vis[i]		= 0;
#endif	//	G4VIS_USE
	}


	//	RPC Detector
	m_pDetector_box			= 0;
	m_pDetector_log			= 0;
	m_pDetector_phys		= 0;

#ifdef G4VIS_USE
	m_pDetector_vis			= 0;
#endif	//	G4VIS_USE


	//	RPC Module
	m_pModule_box			= 0;
	m_pModule_log			= 0;
	m_pModule_phys			= 0;
#ifdef G4VIS_USE
	m_pModule_vis			= 0;
#endif	//	G4VIS_USE


	//	RPC Module Layers
	m_pLayer_box			= 0;
	m_pLayer_log			= 0;
	m_pLayer_phys			= 0;
#ifdef G4VIS_USE
	m_pLayer_vis			= 0;
#endif	//	G4VIS_USE
}


//	Destructor
RPCScanner_DetectorConstruction::~RPCScanner_DetectorConstruction()
{
	DestructPhantom();
	DestructScanner();
	DestructWorld();
}




/* ************************************* */
/* **** Overloaded member functions **** */
/* ************************************* */

//	Construct function - constructs the detector geometry
G4VPhysicalVolume* RPCScanner_DetectorConstruction::Construct()
{
	RPC_Parameters::GetParameters()->ComputeAllDimensions();
// 	RPC_ScannerParameters::GetParameters()->ComputeAllDimentions();

	ConstructWorld();
	ConstructScanner();
	ConstructPhantom();

	return m_pExpWorld_phys;
}




/* ********************************** */
/* **** Private member functions **** */
/* ********************************** */

//	ConstructWorld function - constructs the world volume
void RPCScanner_DetectorConstruction::ConstructWorld (void)
{
	PhantomFactory*			pPhantomFactory			= PhantomFactory::GetPhantomFactory();
	RPC_ScannerParameters*	pScannerParameters		= RPC_Parameters::GetParameters()->GetScannerParameters();
// 	RPC_ScannerParameters*	pScannerParameters		= RPC_ScannerParameters::GetParameters();

	G4ThreeVector			minPhantomExtent		= pPhantomFactory->GetMinimumPhantomExtent();
	G4ThreeVector			maxPhantomExtent		= pPhantomFactory->GetMaximumPhantomExtent();
	G4double				maxPhantomHalfZ			= std::max(fabs(minPhantomExtent.getZ()), fabs(maxPhantomExtent.getZ()));

	G4ThreeVector			minScannerExtent		= pScannerParameters->GetMinimumExtent();
	G4ThreeVector			maxScannerExtent		= pScannerParameters->GetMaximumExtent();
	G4double				maxScannerHalfX			= std::max(fabs(minScannerExtent.getX()), fabs(maxScannerExtent.getX()));
	G4double				maxScannerHalfY			= std::max(fabs(minScannerExtent.getY()), fabs(maxScannerExtent.getY()));
	G4double				maxScannerHalfZ			= std::max(fabs(minScannerExtent.getZ()), fabs(maxScannerExtent.getZ()));

	G4double				fExpWorldMargin			= 5.0*cm;

	G4double				fExpWorldLength			= 2.0*(fExpWorldMargin + std::max(maxPhantomHalfZ, maxScannerHalfZ));
	G4double				fExpWorldWidth			= 2.0*(fExpWorldMargin + maxScannerHalfY);
	G4double				fExpWorldThickness		= 2.0*(fExpWorldMargin + maxScannerHalfX);

// 	G4GeometryManager::GetInstance()->SetWorldMaximumExtent(std::max(std::max(fExpWorldLength,fExpWorldWidth),fExpWorldThickness));


	m_pExpWorld_box		= new G4Box("ExpWorld_box", fExpWorldThickness/2.0, fExpWorldWidth/2.0, fExpWorldLength/2.0);
//	m_pExpWorld_log		= new G4LogicalVolume(m_pExpWorld_box, Materials::GetInstance()->GetMaterial("Air"), "ExpWorld_log", 0, RPC_SD::GetSensitiveDetector());
	m_pExpWorld_log		= new G4LogicalVolume(m_pExpWorld_box, Materials::GetInstance()->GetMaterial("Air"), "ExpWorld_log", 0, 0);
	m_pExpWorld_phys	= new G4PVPlacement(0, G4ThreeVector(), m_pExpWorld_log, "ExpWorld_phys", 0, false, 0, true);


#ifdef	G4VIS_USE
	G4Color colour(0.8, 0.8, 0.8);	//	ligth gray

	m_pExpWorld_vis = new G4VisAttributes();
	m_pExpWorld_vis->SetVisibility(true);
	m_pExpWorld_vis->SetColour(colour);
	m_pExpWorld_vis->SetForceWireframe(true);
	m_pExpWorld_vis->SetForceSolid(false);
	m_pExpWorld_vis->SetForceAuxEdgeVisible(false);
	m_pExpWorld_log->SetVisAttributes(m_pExpWorld_vis);
#endif	//	G4VIS_USE
}

//	DestructWorld function - destructs the world volume
inline void RPCScanner_DetectorConstruction::DestructWorld (void)
{
#ifdef G4VIS_USE
	if (m_pExpWorld_vis != 0)
	{
		delete m_pExpWorld_vis;
		m_pExpWorld_vis = 0;
	}
#endif	//	G4VIS_USE

	if (m_pExpWorld_phys != 0)
	{
		delete m_pExpWorld_phys;
		m_pExpWorld_phys = 0;
	}

	if (m_pExpWorld_log != 0)
	{
		delete m_pExpWorld_log;
		m_pExpWorld_log = 0;
	}

	if (m_pExpWorld_box != 0)
	{
		delete m_pExpWorld_box;
		m_pExpWorld_box = 0;
	}
}


//	ConstructScanner function - constructs the Scanner box
void RPCScanner_DetectorConstruction::ConstructScanner (void)
{
	RPC_ScannerParameters*	pScannerParameters	= RPC_Parameters::GetParameters()->GetScannerParameters();

	G4double				fInnerHalfX			= 0.5*pScannerParameters->GetContainerInnerThickness() - pScannerParameters->GetInternalMargin();
	G4double				fInnerHalfY			= 0.5*pScannerParameters->GetContainerInnerWidth()     - pScannerParameters->GetInternalMargin();
	G4double				fInnerHalfZ			= 0.5*pScannerParameters->GetContainerInnerLength();
//	G4double				fInnerHalfZ			= 0.5*pScannerParameters->GetContainerOuterLength();

	G4double				fOuterHalfX			= 0.5*pScannerParameters->GetContainerOuterThickness();
	G4double				fOuterHalfY			= 0.5*pScannerParameters->GetContainerOuterWidth();
	G4double				fOuterHalfZ			= 0.5*pScannerParameters->GetContainerOuterLength();

	m_pScanner_box[0]	= new G4Box("Scanner_Inner_box", fInnerHalfX, fInnerHalfY, fInnerHalfZ);
	m_pScanner_box[1]	= new G4Box("Scanner_Outer_box", fOuterHalfX, fOuterHalfY, fOuterHalfZ);
	m_pScanner_box[2]	= new G4SubtractionSolid("Scanner_box", m_pScanner_box[1], m_pScanner_box[0]);

	m_pScanner_log		= new G4LogicalVolume(m_pScanner_box[2], Materials::GetInstance()->GetMaterial(pScannerParameters->GetContainerMaterial()), "Scanner_log", 0, RPC_SD::GetSensitiveDetector());
	m_pScanner_phys		= new G4PVPlacement(0, pScannerParameters->GetCenter(), m_pScanner_log, "Scanner_phys", m_pExpWorld_log, false, 0, true);


#ifdef	G4VIS_USE
	G4Color colour(0.5, 0.5, 0.5);	//	gray

	m_pScanner_vis = new G4VisAttributes();
	m_pScanner_vis->SetVisibility(true);
	m_pScanner_vis->SetColour(colour);
	m_pScanner_vis->SetForceWireframe(true);
	m_pScanner_vis->SetForceSolid(true);
	m_pScanner_vis->SetForceAuxEdgeVisible(false);
	m_pScanner_log->SetVisAttributes(m_pScanner_vis);
#endif	//	G4VIS_USE


	ConstructHead();
}

//	DestructScanner function - destructs the Scanner
inline void RPCScanner_DetectorConstruction::DestructScanner (void)
{
	DestructHead();

#ifdef G4VIS_USE
	if (m_pScanner_vis != 0)
	{
		delete m_pScanner_vis;
		m_pScanner_vis = 0;
	}
#endif	//	G4VIS_USE

	if (m_pScanner_phys != 0)
	{
		delete m_pScanner_phys;
		m_pScanner_phys = 0;
	}

	if (m_pScanner_log != 0)
	{
		delete m_pScanner_log;
		m_pScanner_log = 0;
	}

	for (G4int i = 2 ; i >= 0 ; i--)
	{
		if (m_pScanner_box[i] != 0)
		{
			delete m_pScanner_box[i];
			m_pScanner_box[i] = 0;
		}
	}
}


//	ConstructHead function - constructs the Scanner Head
void RPCScanner_DetectorConstruction::ConstructHead (void)
{
// 	RPC_ScannerParameters*	pScannerParameters	= RPC_ScannerParameters::GetParameters();
// 	RPC_HeadParameters*		pHeadParameters		= RPC_HeadParameters::GetParameters();
	RPC_ScannerParameters*	pScannerParameters	= RPC_Parameters::GetParameters()->GetScannerParameters();
	RPC_HeadParameters*		pHeadParameters		= RPC_Parameters::GetParameters()->GetHeadParameters();

	G4double				fInnerHalfX			= 0.5*pHeadParameters->GetContainerInnerThickness();
	G4double				fInnerHalfY			= 0.5*pHeadParameters->GetContainerInnerWidth();
	G4double				fInnerHalfZ			= 0.5*pHeadParameters->GetContainerInnerLength();

	G4double				fOuterHalfX			= 0.5*pHeadParameters->GetContainerOuterThickness();
	G4double				fOuterHalfY			= 0.5*pHeadParameters->GetContainerOuterWidth();
	G4double				fOuterHalfZ			= 0.5*pHeadParameters->GetContainerOuterLength();


	m_pHead_box[0]	= new G4Box("Head_Inner_box", fInnerHalfX, fInnerHalfY, fInnerHalfZ);
	m_pHead_box[1]	= new G4Box("Head_Outer_box", fOuterHalfX, fOuterHalfY, fOuterHalfZ);

	m_pHead_log[0]	= new G4LogicalVolume(m_pHead_box[0], Materials::GetInstance()->GetMaterial(pHeadParameters->GetContainerFillMaterial()), "Head_Fill_log", 0, RPC_SD::GetSensitiveDetector());
	m_pHead_log[1]	= new G4LogicalVolume(m_pHead_box[1], Materials::GetInstance()->GetMaterial(pHeadParameters->GetContainerWallMaterial()), "Head_Case_log", 0, RPC_SD::GetSensitiveDetector());

	m_pHead_phys[0]	= new G4PVPlacement(0, G4ThreeVector(), m_pHead_log[0], "Head_Fill_phys", m_pHead_log[1], false, 0, true);
	m_pHead_phys[1]	= new G4PVParameterised("Head_Case_phys", m_pHead_log[1], m_pScanner_log, kUndefined, pScannerParameters->GetNumberOfHeads(), new RPC_ScannerParameterisation(), true);
// 	m_pHead_phys[1]	= new G4PVParameterised("Head_Case_phys", m_pHead_log[1], m_pScanner_log, kUndefined, pScannerParameters->GetNumberOfHeads(), RPC_ScannerParameterisation::GetParameterisation(), true);



#ifdef	G4VIS_USE
	G4Color colour_1(0.5, 0.0, 0.5);	//	magenta

	m_pHead_vis[0] = new G4VisAttributes();
	m_pHead_vis[0]->SetVisibility(true);
	m_pHead_vis[0]->SetColour(colour_1);
	m_pHead_vis[0]->SetForceWireframe(true);
	m_pHead_vis[0]->SetForceSolid(false);
	m_pHead_vis[0]->SetForceAuxEdgeVisible(false);
	m_pHead_log[0]->SetVisAttributes(m_pHead_vis[0]);


	G4Color colour_2(1.0, 0.0, 1.0);	//	red

	m_pHead_vis[1] = new G4VisAttributes();
	m_pHead_vis[1]->SetVisibility(true);
	m_pHead_vis[1]->SetColour(colour_2);
	m_pHead_vis[1]->SetForceWireframe(true);
	m_pHead_vis[1]->SetForceSolid(false);
	m_pHead_vis[1]->SetForceAuxEdgeVisible(false);
	m_pHead_log[1]->SetVisAttributes(m_pHead_vis[1]);
#endif	//	G4VIS_USE


	ConstructDetector();
}

//	DestructHead function - destructs the Head
inline void RPCScanner_DetectorConstruction::DestructHead (void)
{
	DestructDetector();

#ifdef G4VIS_USE
	for (G4int i = 0 ; i < 2; i++)
	{
		if (m_pHead_vis[i] != 0)
		{
			delete m_pHead_vis[i];
			m_pHead_vis[i] = 0;
		}
	}
#endif	//	G4VIS_USE

	for (G4int i = 0 ; i < 2 ; i++)
	{
		if (m_pHead_phys[i] != 0)
		{
			delete m_pHead_phys[i];
			m_pHead_phys[i] = 0;
		}
	}

	for (G4int i = 0 ; i < 2 ; i++)
	{
		if (m_pHead_log[i] != 0)
		{
			delete m_pHead_log[i];
			m_pHead_log[i] = 0;
		}
	}

	for (G4int i = 0 ; i < 2 ; i++)
	{
		if (m_pHead_box[i] != 0)
		{
			delete m_pHead_box[i];
			m_pHead_box[i] = 0;
		}
	}
}


//	ConstructRPCDetector function - constructs the RPC detector
void RPCScanner_DetectorConstruction::ConstructDetector (void)
{
// 	RPC_HeadParameters*		pHeadParameters		= RPC_HeadParameters::GetParameters();
// 	RPC_DetectorParameters*	pDetectorParameters	= RPC_DetectorParameters::GetParameters();
	RPC_HeadParameters*		pHeadParameters		= RPC_Parameters::GetParameters()->GetHeadParameters();
	RPC_DetectorParameters*	pDetectorParameters	= RPC_Parameters::GetParameters()->GetDetectorParameters();

	G4double				fHalfX				= 0.5*pDetectorParameters->GetContainerThickness();
	G4double				fHalfY				= 0.5*pDetectorParameters->GetContainerWidth();
	G4double				fHalfZ				= 0.5*pDetectorParameters->GetContainerLength();

	m_pDetector_box		= new G4Box("Detector_box", fHalfX, fHalfY, fHalfZ);
	m_pDetector_log		= new G4LogicalVolume(m_pDetector_box, Materials::GetInstance()->GetMaterial(pDetectorParameters->GetContainerMaterial()), "Detector_log", 0, RPC_SD::GetSensitiveDetector());
	m_pDetector_phys	= new G4PVParameterised("Detector_phys", m_pDetector_log, m_pHead_log[0], kUndefined, pHeadParameters->GetNumberOfDetectors(), new RPC_HeadParameterisation(), true);
// 	m_pDetector_phys	= new G4PVParameterised("Detector_phys", m_pDetector_log, m_pHead_log[0], kUndefined, pHeadParameters->GetNumberOfDetectors(), RPC_HeadParameterisation::GetParameterisation(), true);


#ifdef	G4VIS_USE
	G4Color				colour(0.0, 0.7, 0.7);	//	cyan

	m_pDetector_vis = new G4VisAttributes();
	m_pDetector_vis->SetVisibility(true);
	m_pDetector_vis->SetColour(colour);
	m_pDetector_vis->SetForceWireframe(true);
	m_pDetector_vis->SetForceSolid(false);
	m_pDetector_vis->SetForceAuxEdgeVisible(false);
	m_pDetector_log->SetVisAttributes(m_pDetector_vis);
#endif	//	G4VIS_USE


	ConstructModule();
}

//	DestructDetector function - destructs the Detector
inline void RPCScanner_DetectorConstruction::DestructDetector (void)
{
	DestructModule();

#ifdef	G4VIS_USE
	if (m_pDetector_vis != 0)
	{
		delete m_pDetector_vis;
		m_pDetector_vis = 0;
	}
#endif	//	G4VIS_USE

	if (m_pDetector_phys != 0)
	{
		delete m_pDetector_phys;
		m_pDetector_phys = 0;
	}

	if (m_pDetector_log != 0)
	{
		delete m_pDetector_log;
		m_pDetector_log = 0;
	}

	if (m_pDetector_box != 0)
	{
		delete m_pDetector_box;
		m_pDetector_box = 0;
	}
}


//	ConstructModule function - constructs the RPC Module
void RPCScanner_DetectorConstruction::ConstructModule (void)
{
// 	RPC_DetectorParameters*	pDetectorParameters	= RPC_DetectorParameters::GetParameters();
// 	RPC_ModuleParameters*	pModuleParameters	= RPC_ModuleParameters::GetParameters();
	RPC_DetectorParameters*	pDetectorParameters	= RPC_Parameters::GetParameters()->GetDetectorParameters();
	RPC_ModuleParameters*	pModuleParameters	= RPC_Parameters::GetParameters()->GetModuleParameters();

	G4double				fHalfX				= 0.5*pModuleParameters->GetContainerThickness();
	G4double				fHalfY				= 0.5*pModuleParameters->GetContainerWidth();
	G4double				fHalfZ				= 0.5*pModuleParameters->GetContainerLength();

	m_pModule_box	= new G4Box("Module_box", fHalfX, fHalfY, fHalfZ);
	m_pModule_log	= new G4LogicalVolume(m_pModule_box, Materials::GetInstance()->GetMaterial(pModuleParameters->GetContainerMaterial()), "Module_log", 0, RPC_SD::GetSensitiveDetector());
	m_pModule_phys	= new G4PVParameterised("Module_phys", m_pModule_log, m_pDetector_log, kUndefined, pDetectorParameters->GetNumberOfModules(), new RPC_DetectorParameterisation(), true);
// 	m_pModule_phys	= new G4PVParameterised("Module_phys", m_pModule_log, m_pDetector_log, kUndefined, pDetectorParameters->GetNumberOfModules(), RPC_DetectorParameterisation::GetParameterisation(), true);


#ifdef	G4VIS_USE
	G4Color				colour(0.0, 0.6, 0.0);	//	green

	m_pModule_vis = new G4VisAttributes();
	m_pModule_vis->SetVisibility(true);
	m_pModule_vis->SetColour(colour);
	m_pModule_vis->SetForceWireframe(true);
	m_pModule_vis->SetForceSolid(false);
	m_pModule_vis->SetForceAuxEdgeVisible(false);
	m_pModule_log->SetVisAttributes(m_pModule_vis);
#endif	//	G4VIS_USE


	ConstructLayer();
}

//	DestructModule function - destructs the Module
inline void RPCScanner_DetectorConstruction::DestructModule (void)
{
	DestructLayer();

#ifdef	G4VIS_USE
	if (m_pModule_vis != 0)
	{
		delete m_pModule_vis;
		m_pModule_vis = 0;
	}
#endif	//	G4VIS_USE

	if (m_pModule_phys != 0)
	{
		delete m_pModule_phys;
		m_pModule_phys = 0;
	}

	if (m_pModule_log != 0)
	{
		delete m_pModule_log;
		m_pModule_log = 0;
	}

	if (m_pModule_box != 0)
	{
		delete m_pModule_box;
		m_pModule_box = 0;
	}
}


//	ConstructModuleLayers function - constructs the RPC Module Layers
void RPCScanner_DetectorConstruction::ConstructLayer (void)
{
// 	RPC_ModuleParameters*	pModuleParameters	= RPC_ModuleParameters::GetParameters();
	RPC_ModuleParameters*	pModuleParameters	= RPC_Parameters::GetParameters()->GetModuleParameters();

	G4double				fHalfX				= 0.5*pModuleParameters->GetContainerThickness();
	G4double				fHalfY				= 0.5*pModuleParameters->GetContainerWidth();
	G4double				fHalfZ				= 0.5*pModuleParameters->GetContainerLength();

	m_pLayer_box	= new G4Box("ModuleLayer_box", fHalfX, fHalfY, fHalfZ);
	m_pLayer_log	= new G4LogicalVolume(m_pLayer_box, Materials::GetInstance()->GetMaterial(pModuleParameters->GetContainerMaterial()), "ModuleLayer_log", 0, RPC_SD::GetSensitiveDetector());
	m_pLayer_phys	= new G4PVParameterised("ModuleLayer_phys", m_pLayer_log, m_pModule_log, kUndefined, pModuleParameters->GetNumberOfLayers(), new RPC_ModuleParameterisation(), true);
// 	m_pLayer_phys	= new G4PVParameterised("ModuleLayer_phys", m_pLayer_log, m_pModule_log, kUndefined, pModuleParameters->GetNumberOfLayers(), RPC_ModuleParameterisation::GetParameterisation(), true);


#ifdef	G4VIS_USE
	G4Color				colour(1.0, 1.0, 0.0);	//	yellow

	m_pLayer_vis = new G4VisAttributes();
	m_pLayer_vis->SetVisibility(true);
	m_pLayer_vis->SetColour(colour);
	m_pLayer_vis->SetForceWireframe(true);
	m_pLayer_vis->SetForceSolid(false);
	m_pLayer_vis->SetForceAuxEdgeVisible(false);
	m_pModule_log->SetVisAttributes(m_pLayer_vis);
#endif	//	G4VIS_USE
}

//	DestructModuleLayers function - destructs the Module Layers
inline void RPCScanner_DetectorConstruction::DestructLayer (void)
{
#ifdef	G4VIS_USE
	if (m_pLayer_vis != 0)
	{
		delete m_pLayer_vis;
		m_pLayer_vis = 0;
	}
#endif	//	G4VIS_USE

	if (m_pLayer_phys != 0)
	{
		delete m_pLayer_phys;
		m_pLayer_phys = 0;
	}

	if (m_pLayer_log != 0)
	{
		delete m_pLayer_log;
		m_pLayer_log = 0;
	}

	if (m_pLayer_box != 0)
	{
		delete m_pLayer_box;
		m_pLayer_box = 0;
	}
}


//	ConstructPhantom function
void RPCScanner_DetectorConstruction::ConstructPhantom (void)
{
	PhantomFactory*	thePhantomFactory	= PhantomFactory::GetPhantomFactory();

	for (G4int i = 0 ; i < thePhantomFactory->GetNumberOfPhantoms() ; i++)
		thePhantomFactory->GetPhantom(i)->PlacePhantom(m_pExpWorld_log);
}


//	DestructPhantom function
void RPCScanner_DetectorConstruction::DestructPhantom (void)
{
	PhantomFactory*	thePhantomFactory	= PhantomFactory::GetPhantomFactory();

	while (thePhantomFactory->GetNumberOfPhantoms())
		thePhantomFactory->RemovePhantom(thePhantomFactory->GetPhantom(0)->GetPhantomName());
}