//
// ********************************************************************
// * 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.          *
// ********************************************************************
//
// This is the modified version of the example electromagnetic/TestEm7/include/DetectorConstruction.hh

#ifndef DetectorConstruction_h
#define DetectorConstruction_h 1

#include "G4VUserDetectorConstruction.hh"
#include "globals.hh"
#include "G4ThreeVector.hh"


class G4LogicalVolume;
class G4Material;
class DetectorMessenger;
class G4VPhysicalVolume;
class G4Polyhedra;
class G4Box;
class G4Tubs;
class G4SubtractionSolid;
class G4Region;
class SensitiveDetector;
class CollSD;

class DetectorConstruction : public G4VUserDetectorConstruction
{
  public:
  
    DetectorConstruction();
   ~DetectorConstruction();

     
  public:    
     G4VPhysicalVolume* Construct();
     void               UpdateGeometry();
     
  public:  
                    
     G4double     GetWorldSizeY()    {return fWorldSizeY;};
     G4double     GetWorldSizeXZ()   {return fWorldSizeXZ;};
     G4Material*  GetWorldMaterial() {return vacMaterial;};     
     G4double     GetAbsorSizeZ()    {return fAbsorSizeZ;};
     G4double     GetAbsorSizeXY()   {return fAbsorSizeXY;};           
     G4Material*  GetAbsorMaterial() {return waterMaterial;};
      
     G4int            GetLayerNumber()         {return fLayerNumber;};
     G4double         GetLayerMass()           {return fLayerMass;}; 
     G4double         GetLayerSizeXY()         {return fLayerSizeXY;};

     void         PrintParameters();
                       
  private:
  
     G4double            fWorldSizeY;
     G4double            fWorldSizeXZ;
     G4Material*         vacMaterial;          
     G4double            fAbsorSizeZ;
     G4double            fAbsorSizeXY;     
     G4Material*         waterMaterial;
     G4Material*         brassMaterial;
     G4Material*         defaultMaterial;
     G4Material*         marbleMaterial;
     G4Material*         alMaterial;
     G4Material*         mylMaterial;
     G4Material*         kaptonMaterial;
     G4Material*         tungstenMaterial; 
     G4Material*         ironMaterial;
     G4Material*         PMMAmaterial;
     G4Material*         borPlasticMaterial;

     G4LogicalVolume*    fLAbsor;
     G4LogicalVolume*    fLLayer;
     G4VPhysicalVolume*  fPhysLayer;

     G4Box*              solidWorld;
     G4LogicalVolume*    logicWorld;
     G4VPhysicalVolume*  physiWorld;

     G4Box*              solidRoomOuter;
     G4LogicalVolume*    logicRoomOuter;
     G4VPhysicalVolume*   physiRoomOuter;

     G4Box*              solidRoomInner;
     G4LogicalVolume*    logicRoomInner;
     G4VPhysicalVolume*   physiRoomInner;

     G4Box*              solidWater;
     G4LogicalVolume*    logicWater;
     G4VPhysicalVolume*  physiWater;

     G4Tubs*            solidAlTubeOuter1;
     G4LogicalVolume*   logicAlTubeOuter1;
     G4VPhysicalVolume* physiAlTubeOuter1;

     G4Tubs*            solidAlTubeInner1;
     G4LogicalVolume*   logicAlTubeInner1;
     G4VPhysicalVolume* physiAlTubeInner1;

     G4Tubs*            solidCollimator1;
     G4LogicalVolume*   logicCollimator1;
     G4VPhysicalVolume* physiCollimator1;

     G4Tubs*            solidScatterFoil1;
     G4LogicalVolume*   logicScatterFoil1;
     G4VPhysicalVolume* physiScatterFoil1;

     G4Tubs*            solidStopper;
     G4LogicalVolume*   logicStopper;
     G4VPhysicalVolume* physiStopper;

     G4Tubs*            solidScatterFoil2;
     G4LogicalVolume*   logicScatterFoil2;
     G4VPhysicalVolume* physiScatterFoil2;

     G4Tubs*            solidKapton;
     G4LogicalVolume*   logicKapton;
     G4VPhysicalVolume* physiKapton;

     G4Box*             solidAlBoxInner1; 
     G4Box*             solidAlBoxOuter1; 
  
     G4LogicalVolume*   logicAlBoxInner1;
    G4VPhysicalVolume* physiAlBoxInner1;
  G4LogicalVolume*   logicAlBoxOuter1;
  G4VPhysicalVolume* physiAlBoxOuter1;

  G4Tubs*            solidAlBoxHole1;
  G4LogicalVolume*   logicAlBoxHole1;
  G4VPhysicalVolume* physiAlBoxHole1;

  G4Tubs*            solidAlBoxHole2;
  G4LogicalVolume*   logicAlBoxHole2;
  G4VPhysicalVolume* physiAlBoxHole2;
  
  G4Tubs*            solidAlTubeOut2;
  G4LogicalVolume*   logicAlTubeOut2;
  G4VPhysicalVolume* physiAlTubeOut2;

  G4Tubs*            solidAlTubeIn2;
  G4LogicalVolume*   logicAlTubeIn2;
  G4VPhysicalVolume* physiAlTubeIn2;

  G4Box*             solidAlBoxInner2;
  G4Box*             solidAlBoxOuter2;
  G4LogicalVolume*   logicAlBoxInner2;
  G4VPhysicalVolume* physiAlBoxInner2;
  G4LogicalVolume*   logicAlBoxOuter2;
  G4VPhysicalVolume* physiAlBoxOuter2;

  G4Box* solidIronBlockOuter;
  G4Tubs* solidIronBlockInner;
  G4SubtractionSolid* solidIronBlock;
  G4LogicalVolume* logicIronBlock;
  G4VPhysicalVolume* physiIronBlock;

  G4Tubs*            solidAlBoxHole3;
  G4LogicalVolume*   logicAlBoxHole3;
  G4VPhysicalVolume* physiAlBoxHole3;

  G4Tubs*            solidAlBoxHole4;
  G4LogicalVolume*   logicAlBoxHole4;
  G4VPhysicalVolume* physiAlBoxHole4;

  G4Tubs*            solidScatterCollimatorInner; 
  G4Box*             solidScatterCollimatorOuter; 

  G4SubtractionSolid* solidScatterCollimator1;
  G4LogicalVolume*   logicScatterCollimator1;
  G4VPhysicalVolume* physiScatterCollimator1;
  // DOSE MONITOR 1
  G4Box* solidPerspexMonitorOuter1;
  G4Tubs* solidPerspexMonitorOuterHole;
  G4SubtractionSolid* solidPerspex1Monitor1;
  G4LogicalVolume* logicPerspex1Monitor1;
  G4VPhysicalVolume* physiPerspex1Monitor1;

  G4Box*             solidMylarMonitor1;
  G4LogicalVolume*   logicMylarMonitor1;
  G4VPhysicalVolume* physiMylarMonitor1;

  G4Box*             solidAlMonitor1;
  G4LogicalVolume*   logicAlMonitor1;
  G4VPhysicalVolume* physiAlMonitor1;

  G4Tubs* solidGuardRing1;
  G4LogicalVolume* logicGuardRing1;
  G4VPhysicalVolume* physiGuardRing1;

  G4Box*             solidMylarMonitor2;
  G4LogicalVolume*   logicMylarMonitor2;
  G4VPhysicalVolume* physiMylarMonitor2;

  G4Box*             solidAlMonitor2;
  G4LogicalVolume*   logicAlMonitor2;
  G4VPhysicalVolume* physiAlMonitor2;

  G4SubtractionSolid* solidPerspex2Monitor1;
  G4LogicalVolume* logicPerspex2Monitor1;
  G4VPhysicalVolume* physiPerspex2Monitor1;
  
  G4Box*             solidPlasticBlockOuter1;
  G4Tubs*            solidPlasticBlockInner1;
  G4SubtractionSolid* solidPlasticBlock1;
  G4LogicalVolume*   logicPlasticBlock1;
  G4VPhysicalVolume* physiPlasticBlock1;

  G4Box*             solidPlasticBlockOuter2;
  G4Tubs*            solidPlasticBlockInner2;
  G4SubtractionSolid* solidPlasticBlock2;
  G4LogicalVolume*   logicPlasticBlock2;
  G4VPhysicalVolume*     physiPlasticBlock2;
  
  // DOSE MONITOR 2
  G4Box* solidPerspexMonitorOuter2;
  G4Tubs* solidPerspexMonitorOuterHole2;
  G4SubtractionSolid* solidPerspex1Monitor2;
  G4LogicalVolume* logicPerspex1Monitor2;
  G4VPhysicalVolume* physiPerspex1Monitor2;

  G4Box*             solidMylarMonitor3;
  G4LogicalVolume*   logicMylarMonitor3;
  G4VPhysicalVolume* physiMylarMonitor3;

  G4Box*             solidAlMonitor3;
  G4LogicalVolume*   logicAlMonitor3;
  G4VPhysicalVolume* physiAlMonitor3;

  G4Tubs* solidGuardRing2;
  G4LogicalVolume* logicGuardRing2;
  G4VPhysicalVolume* physiGuardRing2;

  G4Box*             solidMylarMonitor4;
  G4LogicalVolume*   logicMylarMonitor4;
  G4VPhysicalVolume* physiMylarMonitor4;

  G4Box*             solidAlMonitor4;
  G4LogicalVolume*   logicAlMonitor4;
  G4VPhysicalVolume* physiAlMonitor4;

  G4SubtractionSolid* solidPerspex2Monitor2;
  G4LogicalVolume* logicPerspex2Monitor2;
  G4VPhysicalVolume* physiPerspex2Monitor2;
  //

  G4Tubs*            solidScatterCollimatorInner2; 
  G4Box*             solidScatterCollimatorOuter2; 

   G4SubtractionSolid* solidScatterCollimator2;
  G4LogicalVolume*   logicScatterCollimator2;
  G4VPhysicalVolume* physiScatterCollimator2;

  G4Box* solidShielding1;
  G4LogicalVolume* logicShielding1;
  G4VPhysicalVolume* physiShielding1;

G4Box* solidShielding2;
  G4LogicalVolume* logicShielding2;
  G4VPhysicalVolume* physiShielding2;

    G4Tubs*             solidNozzleInside1; 
     G4LogicalVolume*    logicNozzleInside1;
     G4VPhysicalVolume*  physiNozzleInside1;

     G4Tubs*             solidNozzle1; 
     G4LogicalVolume*    logicNozzle1;
     G4VPhysicalVolume*  physiNozzle1;

     G4Tubs*             solidPatientCollimatorOuter;
     G4LogicalVolume*    logicPatientCollimatorOuter;
     G4VPhysicalVolume*  physiPatientCollimatorOuter;

     G4Tubs*             solidPatientCollimatorInner;
     G4LogicalVolume*    logicPatientCollimatorInner;
     G4VPhysicalVolume*  physiPatientCollimatorInner;

     G4Tubs*             solidPatientCollimatorHolder;
     G4LogicalVolume*    logicPatientCollimatorHolder;
     G4VPhysicalVolume*  physiPatientCollimatorHolder;

     G4Tubs*             solidPatientCollimatorHolderInner;
     G4LogicalVolume*    logicPatientCollimatorHolderInner;
     G4VPhysicalVolume*  physiPatientCollimatorHolderInner;

     G4double            fLayerSizeXY;
     G4double            fLayerSizeZ;
     
     G4int               fLayerNumber;
     G4double            fLayerMass; 
     DetectorMessenger*  fDetectorMessenger;

     SensitiveDetector*  DetectorSD; //pointer to sensitive detectors
  CollSD*  DetectorCol1;
    
private:
    
     void               DefineMaterials();
     G4VPhysicalVolume* ConstructVolumes();     
};



#endif