/scratch0/jsnuveri/BDSIM/BDSIMgit/bdsim/src/BDSBeamPipeFactoryBase.cc

#include "BDSBeamPipeFactoryBase.hh"

#include "BDSDebug.hh"
#include "BDSExecOptions.hh"
#include "BDSGlobalConstants.hh"
#include "BDSMaterials.hh"
#include "BDSSDManager.hh"
#include "BDSUtilities.hh"            // for calculateorientation

#include "globals.hh"                 // geant4 globals / types
#include "G4Colour.hh"
#include "G4LogicalVolume.hh"
#include "G4Material.hh"
#include "G4PVPlacement.hh"
#include "G4ThreeVector.hh"
#include "G4UserLimits.hh"
#include "G4VisAttributes.hh"

BDSBeamPipeFactoryBase::BDSBeamPipeFactoryBase()
{
  lengthSafety              = BDSGlobalConstants::Instance()->GetLengthSafety();
  checkOverlaps             = BDSGlobalConstants::Instance()->GetCheckOverlaps();
  maxStepFactor             = 0.5; // fraction of length for maximum step size
  nSegmentsPerCircle        = 50;
  CleanUp();
}

void BDSBeamPipeFactoryBase::CleanUp()
{
  vacuumSolid               = NULL;
  beamPipeSolid             = NULL;
  containerSolid            = NULL;
  containerSubtractionSolid = NULL;
  vacuumLV                  = NULL;
  beamPipeLV                = NULL;
  containerLV               = NULL;
}


BDSBeamPipe* BDSBeamPipeFactoryBase::CreateBeamPipeAngledIn(G4String    nameIn,
                                                            G4double    lengthIn,
                                                            G4double    angleInIn, // the normal angle of the input face
                                                            G4double    aper1,
                                                            G4double    aper2,
                                                            G4double    aper3,
                                                            G4double    aper4,
                                                            G4Material* vacuumMaterialIn,
                                                            G4double    beamPipeThicknessIn,
                                                            G4Material* beamPipeMaterialIn)
{
  return CreateBeamPipeAngledInOut(nameIn,lengthIn,angleInIn,0,aper1,aper2,aper3,aper4,vacuumMaterialIn,beamPipeThicknessIn,beamPipeMaterialIn);
}

BDSBeamPipe* BDSBeamPipeFactoryBase::CreateBeamPipeAngledOut(G4String    nameIn,
                                                             G4double    lengthIn,
                                                             G4double    angleOutIn, // the normal angle of the output face
                                                             G4double    aper1,
                                                             G4double    aper2,
                                                             G4double    aper3,
                                                             G4double    aper4,
                                                             G4Material* vacuumMaterialIn,
                                                             G4double    beamPipeThicknessIn,
                                                             G4Material* beamPipeMaterialIn)
{
  return CreateBeamPipeAngledInOut(nameIn,lengthIn,0,angleOutIn,aper1,aper2,aper3,aper4,vacuumMaterialIn,beamPipeThicknessIn,beamPipeMaterialIn);
}

void BDSBeamPipeFactoryBase::TestInputParameters(G4Material*&  vacuumMaterialIn,
                                                 G4double&     beamPipeThicknessIn,
                                                 G4Material*&  beamPipeMaterialIn)
{
  if (!vacuumMaterialIn)
    {vacuumMaterialIn = BDSMaterials::Instance()->GetMaterial(BDSGlobalConstants::Instance()->GetVacuumMaterial());}

  if (beamPipeThicknessIn < 1e-10)
    {beamPipeThicknessIn = BDSGlobalConstants::Instance()->GetBeamPipeThickness();}

  if (!beamPipeMaterialIn)
    {beamPipeMaterialIn = BDSMaterials::Instance()->GetMaterial(BDSGlobalConstants::Instance()->GetBeamPipeMaterialName());}
}
  
void BDSBeamPipeFactoryBase::CommonConstruction(G4String    nameIn,
                                                G4Material* vacuumMaterialIn,
                                                G4Material* beamPipeMaterialIn,
                                                G4double    lengthIn)
{
#ifdef BDSDEBUG
  G4cout << __METHOD_NAME__ << G4endl;
#endif
  BuildLogicalVolumes(nameIn,vacuumMaterialIn,beamPipeMaterialIn);
  SetVisAttributes();
#ifndef NOUSERLIMITS
  SetUserLimits(lengthIn);
#endif
  PlaceComponents(nameIn);
}

void BDSBeamPipeFactoryBase::BuildLogicalVolumes(G4String    nameIn,
                                                 G4Material* vacuumMaterialIn,
                                                 G4Material* beamPipeMaterialIn)
{
#ifdef BDSDEBUG
  G4cout << __METHOD_NAME__ << G4endl;
#endif
  // build the logical volumes
  vacuumLV   = new G4LogicalVolume(vacuumSolid,
                                   vacuumMaterialIn,
                                   nameIn + "_vacuum_lv");
  
  beamPipeLV = new G4LogicalVolume(beamPipeSolid,
                                   beamPipeMaterialIn,
                                   nameIn + "_beampipe_lv");
  
  containerLV = new G4LogicalVolume(containerSolid,
                                    vacuumMaterialIn,
                                    nameIn + "_container_lv");
}

void BDSBeamPipeFactoryBase::SetVisAttributes()
{
#ifdef BDSDEBUG
  G4cout << __METHOD_NAME__ << G4endl;
#endif
  // VISUAL ATTRIBUTES
  // set visual attributes
  // beampipe
  G4VisAttributes* pipeVisAttr = new G4VisAttributes(G4Color(0.4,0.4,0.4));
  pipeVisAttr->SetVisibility(true);
  pipeVisAttr->SetForceLineSegmentsPerCircle(nSegmentsPerCircle);
  beamPipeLV->SetVisAttributes(pipeVisAttr);
  // vacuum
  vacuumLV->SetVisAttributes(BDSGlobalConstants::Instance()->GetInvisibleVisAttr());
  // container
  if (BDSExecOptions::Instance()->GetVisDebug())
    {containerLV->SetVisAttributes(BDSGlobalConstants::Instance()->GetVisibleDebugVisAttr());}
  else
    {containerLV->SetVisAttributes(BDSGlobalConstants::Instance()->GetInvisibleVisAttr());}
}

G4UserLimits* BDSBeamPipeFactoryBase::SetUserLimits(G4double lengthIn)
{
#ifdef BDSDEBUG
  G4cout << __METHOD_NAME__ << G4endl;
#endif
  // USER LIMITS
  // set user limits based on bdsim user specified parameters
  G4UserLimits* beamPipeUserLimits = new G4UserLimits("beampipe_cuts");
  beamPipeUserLimits->SetMaxAllowedStep( lengthIn * maxStepFactor );
  beamPipeUserLimits->SetUserMinEkine(BDSGlobalConstants::Instance()->GetThresholdCutCharged());
  beamPipeUserLimits->SetUserMaxTime(BDSGlobalConstants::Instance()->GetMaxTime());
  //attach cuts to volumes
  vacuumLV->SetUserLimits(beamPipeUserLimits);
  beamPipeLV->SetUserLimits(beamPipeUserLimits);
  containerLV->SetUserLimits(beamPipeUserLimits);
  return beamPipeUserLimits;
}

void BDSBeamPipeFactoryBase::PlaceComponents(G4String nameIn)
{
#ifdef BDSDEBUG
  G4cout << __METHOD_NAME__ << G4endl;
#endif
  // PLACEMENT
  // place the components inside the container
  // note we don't need the pointer for anything - it's registered upon construction with g4
  
  new G4PVPlacement((G4RotationMatrix*)0,         // no rotation
                    (G4ThreeVector)0,             // position
                    vacuumLV,                     // lv to be placed
                    nameIn + "_vacuum_pv",        // name
                    containerLV,                  // mother lv to be place in
                    false,                        // no boolean operation
                    0,                            // copy number
                    checkOverlaps);               // whether to check overlaps
  
  new G4PVPlacement((G4RotationMatrix*)0,         // no rotation
                    (G4ThreeVector)0,             // position
                    beamPipeLV,                   // lv to be placed
                    nameIn + "_beampipe_pv",      // name
                    containerLV,                  // mother lv to be place in
                    false,                        // no boolean operation
                    0,                            // copy number
                    checkOverlaps);               // whether to check overlaps
}

BDSBeamPipe* BDSBeamPipeFactoryBase::BuildBeamPipeAndRegisterVolumes(std::pair<double,double> extX,
                                                                     std::pair<double,double> extY,
                                                                     std::pair<double,double> extZ,
                                                                     G4double containerRadius)
{  
  // build the BDSBeamPipe instance and return it
  BDSBeamPipe* aPipe = new BDSBeamPipe(containerSolid,containerLV,extX,extY,extZ,
                                       containerSubtractionSolid,
                                       vacuumLV,false,containerRadius);

  // REGISTER all lvs
  aPipe->RegisterLogicalVolume(vacuumLV); //using geometry component base class method
  aPipe->RegisterLogicalVolume(beamPipeLV);

  // register sensitive volumes
  aPipe->RegisterSensitiveVolume(beamPipeLV);
  
  return aPipe;
}

std::pair<G4ThreeVector,G4ThreeVector> BDSBeamPipeFactoryBase::CalculateFaces(G4double angleIn,
                                                                              G4double angleOut)
{
  G4int orientationIn  = BDS::CalculateOrientation(angleIn);
  G4int orientationOut = BDS::CalculateOrientation(angleOut);
  
  G4double in_z  = cos(fabs(angleIn)); // calculate components of normal vectors (in the end mag(normal) = 1)
  G4double in_x  = sin(fabs(angleIn)); // note full angle here as it's the exit angle
  G4double out_z = cos(fabs(angleOut));
  G4double out_x = sin(fabs(angleOut));
  G4ThreeVector inputface  = G4ThreeVector(orientationIn*in_x, 0.0, -1.0*in_z); //-1 as pointing down in z for normal
  G4ThreeVector outputface = G4ThreeVector(orientationOut*out_x, 0.0, out_z);   // no output face angle
  return std::make_pair(inputface,outputface);
}

---