LBNEVolumePlacements.hh

Go to the documentation of this file.

//---------------------------------------------------------------------------// 
// $Id: LBNEVolumePlacements.hh,v 1.1.2.35 2013/12/06 18:23:50 lebrun Exp $
//---------------------------------------------------------------------------// 

#ifndef LBNEVolumePlacement_H
#define LBNEVolumePlacement_H 1

#include <vector>
#include <map>

//#include "G4VUserVolumePlacement.hh"
#include "globals.hh"
#include "G4ThreeVector.hh"
#include "G4RotationMatrix.hh"
#include "G4UImessenger.hh"
#include "G4UIdirectory.hh"
#include "G4UIcmdWithADoubleAndUnit.hh"
#include "G4UIcmdWithABool.hh"
#include "G4UIcmdWithADoubleAndUnit.hh"
#include "G4PVPlacement.hh"
#include "G4ExceptionSeverity.hh"

//---------------------------------------------------------------------------// 
// This class controls the placement of everything within the geometry. 

//class LBNEVolumePlacement : public G4VUserVolumePlacement
//
// The file G4VUserVolumePlacement.hh was found missing in my cvs instance of the package.
// Not sure what happened here. 
// In any event, do we need inheritance here? 
//
// Rephrasing the scope and goal for this class: a container that all hold 
// critical volume nominal placements in the package. 
// Real placements can be modifed before physical placement by correcting 
// for misalignments using the LBNESurveyor data.
// Thus, for a given subVolume, we might have two placements, two entries in the 
// in the map.  
//
// Benefits of this class are (i) a central repository of all 
//   nominal and tried placements data. 
//  (ii) interface to the messenger to get nominal data from User's cards.  
//  (iii) interface with the Surveyor data class, in case misalignment are studied
//
// The Dectetor construction handles the list of materials, and will use this repository 
// of placement 
//
// Key functionality : 
//
//  CheckPlacement 
//
// This is a singleton class 
//

//
// Paul L. G. Lebrun, July 2013 
//
// Type of alignment study algorythms one could use 

enum LBNEVolumePlacements_AlignmentAlgo {eNominal, eFixed, eRandom}; 
//
// First, one more container to avoid the search through the map more then once 
//
class LBNEVolumePlacements;

struct LBNEVolumePlacementData {
  LBNEVolumePlacements_AlignmentAlgo fAlignmentModel;
  bool fIsPlaced;
  G4ThreeVector fPosition;
  G4RotationMatrix fRotation;
  bool fRotationIsUnitMatrix;
  std::vector<double> fParams; // sizes, or others.. 
  G4String fTypeName; // Box, tube, etc...
  G4VPhysicalVolume *fMother; // Not Owned. G4 maintain this pointer.  Do not delete in the destructor of this class. 
  G4LogicalVolume* fCurrent; // Same 

  void initialize() {
      fAlignmentModel = eNominal;
      fIsPlaced = false;
      fRotation = G4RotationMatrix();
      fRotationIsUnitMatrix = true;
      fPosition = G4ThreeVector(0.0, 0.0, 0.0);
      fParams.resize(3, 0.0);
      fMother = 0;
      fTypeName = G4String("Tubs"); // most common type of volume..
  }
 
};

class LBNEHornRadialEquation  {

  public:
      LBNEHornRadialEquation(); // to be able to store in an stl vector. 
      LBNEHornRadialEquation(double rSqrtCoefficient, double zCoefficient, double rOffset, bool parabolic=true);
      double GetVal(double z) const ; 
      void test1() const; // Cross check for equation 1. Will generate G4Exception 
  
  private:
      static double inchDef;
      bool parabolic;
      double rCoeff;
      double zCoeff;
      double rOff;
      double rResc;
      double rRescCst;
      double zResc;
      
  public:    
    inline void SetLongRescaleFactor(double r) {zResc = r;}
    inline void SetRadialRescaleFactor(double r) {rResc = r;}
    inline void SetRadialRescaleFactorCst(double r) {rRescCst = r;}

};

class LBNEVolumePlacements
{

private:
  LBNEVolumePlacements();
  ~LBNEVolumePlacements();
  LBNEVolumePlacements (LBNEVolumePlacements const &); // not implemented 
  LBNEVolumePlacements& operator=(LBNEVolumePlacements const&); // not implemented 
  static LBNEVolumePlacements* fInstance;

public:
//
// Alignment algorithm See also LBNE Surveyor 
// eNominal:  the element on the beam line is placed perfectly, no misalignment 
// eFixed:  The placement occurs after picking up the surveyed value for one or more points 
//          rigidly attached to the placed volume in question. 
// eRandom: The survey point is understood as a tolerance figure, the actual placement will be taken randomly
//           assuming the actual placement occurs within +- 2 sigma, truncated gaussian. (to be negotiated )
   
  static LBNEVolumePlacements* Instance(); 
  
  void InitializeMessenger(); // Can't be in the constructor, inf. loop otherwise
  void Initialize(const G4LogicalVolume* matriarch); // Define only the top of the hierarchy
 
  LBNEVolumePlacementData* Create(const G4String &name);                                                                                            
  
  G4PVPlacement* PlaceFinal(const G4String &name, G4VPhysicalVolume *mother);
                               
  void PlaceFinalUpstrTarget(G4PVPlacement *mother); // Aug 2014: if NoSplit target, this method name is confusing
                                                     // As there is downstream target any longer. 
  void PlaceFinalDownstrTarget(G4PVPlacement *mother);
 
  void PlaceFinalHorn1(G4PVPlacement *mother,  G4PVPlacement *motherDownstrTarget);
  void PlaceFinalNoSplitHorn1(G4PVPlacement *mother, G4PVPlacement *motherTop); //2nd argument is to place plug in Horn1. 
  void UpdateParamsForHorn1MotherPoly();
// August 2015 Multiple Horns 
  void PlaceFinalSimpleHornPolyNumber( size_t iHorn, G4PVPlacement *mother); // For Horns Optimization studies. 
                             // iHorn ranges from 0 to 4, inclusive.   
  void UpdateParamsForHornMotherPolyNum(size_t iH);
  
  
  void ExtendChaseLengthForHorn2(); // Feb. 2015: Optimization seems to require longer chase. 
  void PlaceFinalHorn2(G4PVPlacement *mother);
  
  void PlaceFinalDecayPipeSnout(G4PVPlacement *mother);
  double GetMaxRadiusMotherHorn1();
                               
  void PrintAll() const;

  inline double GetTargetHallZ() const { return fTargetHallZ; }
  inline double GetDecayHallZ()  const { return fDecayHallZ; }
  inline double GetDecayPipeLength()  const { return fDecayPipeLength; }
  inline double GetDecayPipeRadius()  const { return fDecayPipeRadius; }
  inline double GetDecayPipeUpstrWindowThick()  const { return fDecayPipeUpstrWindowThick; }
  inline double GetDecayPipeLongPosition()  const { return fDecayPipeLongPosition; }
  inline G4String GetDecayPipeGas() const {return fDecayPipeGas; }
  inline G4String GetHorn1InnerConductorMaterial() const {return fHorn1InnerCondMat; }
  inline G4String GetHorn2InnerConductorMaterial() const {return fHorn2InnerCondMat; }
  inline G4String GetHorn3InnerConductorMaterial() const {return fHorn3InnerCondMat; }
  inline G4String GetHorn1AllConductorMaterial() const {return fHorn1AllCondMat; }
  inline G4String GetHorn2AllConductorMaterial() const {return fHorn2AllCondMat; }
  inline G4String GetHorn3AllConductorMaterial() const {return fHorn3AllCondMat; }
  inline double GetAbsorberHallZ()  const { return fAbsorberHallZ; }
  inline double GetHorn1Length()  const { return fHorn1Length; }
  inline double GetBaffleLength() const  { return fBaffleLength; }
  inline double GetBaffleWindowThickness() const  { return fBaffleWindowThickness; }
  inline double GetBaffleInnerRadius() const  { return fBaffleInnerRadius; }
  inline double GetBaffleZPosition()  const { return fBaffleZPosition; }
  inline double GetPlugLength() const  { return fPlugLength; }
  inline double GetPlugInnerRadius() const  { return fPlugInnerRadius; }
  inline double GetPlugOuterRadius() const  { return fPlugOuterRadius; }
  inline double GetPlugZPosition()  const { return fPlugZPosition; }
  inline std::string GetPlugMaterial()  const { return fPlugMaterial; }
  
  // Interface to the Detector construction classes, or others..  
   
  inline void SetTotalLengthOfRock(double l) { fTotalLength = l;}
  inline double GetTotalLengthOfRock() const { return fTotalLength;}
  inline void SetLengthOfRockDownstreamAlcove(double l) {
   fLengthOfRockDownstr = 2.0*l; // Downstream and upstream, actually, the latter does not matter.
   const double aRockLength = 2.0*(fDecayPipeLength + 160.*CLHEP::m ); // before digging the tunnel. 
      // Approximate.. 150 m. is for the target hall, Horn1 + horn2, and the Hadron absorber hall + muon alcove. 
   fTotalLength = aRockLength+fLengthOfRockDownstr;
  }
  inline double GetLengthOfRockDownstreamAlcove() const { return fLengthOfRockDownstr;}
  
 // Interface to the Messenger command 
 
  inline void SetDecayPipeLength(double l) {
     const double lCorr = l + fDecayPipeLengthCorrection;
     fDecayPipeLength=lCorr; fTotalLength = 2.0*(fDecayPipeLength + 160.*CLHEP::m + fLengthOfRockDownstr);
  }
  inline void SetDecayPipeRadius(double l) {fDecayPipeRadius=l;}
  inline void SetDecayPipeLongPosition(double l) {fDecayPipeLongPosition=l;}
  inline void SetDecayPipeUpstrWindowThick(double l) {fDecayPipeUpstrWindowThick=l;}
  inline void SetDecayPipeGas(G4String &name) {fDecayPipeGas = name;}
  inline void SetHorn1InnerConductorMaterial(G4String &name) {fHorn1InnerCondMat = name;}
  inline void SetHorn2InnerConductorMaterial(G4String &name) {fHorn2InnerCondMat = name;}
  inline void SetHorn3InnerConductorMaterial(G4String &name) {fHorn3InnerCondMat = name;}
  inline void SetHorn1AllConductorMaterial(G4String &name) {fHorn1AllCondMat = name;}
  inline void SetHorn2AllConductorMaterial(G4String &name) {fHorn2AllCondMat = name;}
  inline void SetHorn3AllConductorMaterial(G4String &name) {fHorn3AllCondMat = name;}
  inline void SetTotalLength(double l) {fTotalLength=l;} // dangerous! Possible conflict with length of rock downstream 
  inline void SetWaterLayerThickInHorns(double l) { fWaterLayerThickInHorns = l;}
  inline void SetHorn1Length(double l) { fHorn1Length = l;}
  inline void SetBaffleLength(double l) { fBaffleLength = l;}
  inline void SetBaffleInnerRadius(double r) { fBaffleInnerRadius = r;}
  inline void SetBaffleZPosition(double z) { fBaffleZPosition = z;}
  inline void SetPlugLength(double l) { fPlugLength = l;}
  inline void SetPlugInnerRadius(double r) { fPlugInnerRadius = r;}
  inline void SetPlugOuterRadius(double r) { fPlugOuterRadius = r;}
  inline void SetPlugMaterial(std::string name) { fPlugMaterial = name;}
  inline void SetPlugZPosition(double z) { fPlugZPosition = z;}
  inline void SetConstructPlug(bool t) { fConstructPlug = t;}
  inline void SetConstructPlugInHorn1(bool t) { fConstructPlugInHorn1 = t;} // Added, August 31 2014. 
//
// december 2013: Simple target 
//
  inline void SetUseSimpleTargetBox(bool t) { fUseSimpleTargetBox = t;}
  inline void SetUseSimpleTargetCylinder(bool t) { fUseSimpleTargetCylinder = t;}
  inline void SetSimpleTargetRadius(double r) { fSimpleTargetRadius = r;} 
  inline void SetSimpleTargetWidth(double r) { fSimpleTargetWidth = r;} 
  inline void SetSimpleTargetHeight(double r) { fSimpleTargetHeight = r;} 
  inline void SetSimpleTargetLength(double l) { fSimpleTargetLength = l;} 
//
  inline bool GetUseSimpleTargetBox() const { return fUseSimpleTargetBox;}
  inline bool GetUseSimpleTargetCylinder() const { return fUseSimpleTargetCylinder;}
  inline bool GetConstructPlug() const { return fConstructPlug;}
  inline bool GetConstructPlugInHorn1() const { return fConstructPlugInHorn1;}
  inline double GetSimpleTargetRadius() const {return  fSimpleTargetRadius;} 
  inline double GetSimpleTargetWidth() const { return fSimpleTargetWidth;} 
  inline double GetSimpleTargetHeight() const {return  fSimpleTargetHeight;} 
  inline double GetSimpleTargetLength() const {return  fSimpleTargetLength;} 
//
// October 2015 
//
  inline void SetRemoveTargetAlltogether(bool t) { fRemoveTargetAlltogether = t;}
  inline bool GetRemoveTargetAlltogether() { return fRemoveTargetAlltogether;}
  
// Interface to the Messenger, Target stuff. 

  inline double GetTargetSLengthGraphite() const { return fTargetSLengthGraphite; }
  inline void SetTargetSLengthGraphite(double l) { fTargetSLengthGraphite = l; }
  inline double GetTargetFinWidth() const { return fTargetFinWidth; }
  inline void SetTargetFinWidth(double l) { 
       fTargetFinWidth = l; 
       if (fUse1p2MW) {
           fTargetFinWidth /=2.; // since we will place two of them side by side 
           fTargetFinWidthRequired = fTargetFinWidth; 
           // October, November 2016.. Install the 1/2 fins as a subtracted volume, 
           // such the cooling pipe diameter (OD) can be larger than 1/2 fin width. 
//           if (fTargetFinWidth > fTargetCTubeOuterRadius) {
//            fTargetFinExtraWidth = (fTargetFinWidth - 2.0*fTargetCTubeOuterRadius);
//            fTargetFinWidth = fTargetCTubeOuterRadius - 0.001*CLHEP::mm;
//         }

        }
  }
  inline unsigned int GetTargetNumFinsWithWings() const { return fTargetNumFinsWithWings; }
  inline void SetTargetNumFinsWithWings(unsigned int n) {fTargetNumFinsWithWings=n;} 
  inline double GetTargetDensity() const { return fTargetDensity; }
  inline void SetTargetDensity(double l) { fTargetDensity = l; }

  inline double GetTargetSpecificLambda() const {return fTargetSpecificLambda;}
  inline void SetTargetSpecificLambda(double l) {fTargetSpecificLambda = l;}

  inline G4String GetTargetMaterialName() const { return fTargetMaterialName; }
  inline void SetTargetMaterialName(G4String &aName) { fTargetMaterialName = aName; }
  inline double GetTargetLengthIntoHorn() const { return fTargetLengthIntoHorn; }
  inline void SetTargetLengthIntoHorn(double l) { fTargetLengthIntoHorn = l; }
  inline void SetTargetLengthOutsideHorn(double l) { fTargetLengthOutsideHorn = l; }
  inline double GetTargetBerylDownstrWindowThick() const { return fTargetBerylDownstrWindowThick;}
  inline void SetTargetBerylDownstrWindowThick(double t) { fTargetBerylDownstrWindowThick = t;}
  inline void SetHorn1RadialSafetyMargin(double t) { fHorn1RadialSafetyMargin = t;}
  inline double GetHorn1RadialSafetyMargin() const { return fHorn1RadialSafetyMargin;}
  inline void SetHorn1RadiusBigEnough(bool t) { fHorn1RadiusBigEnough = t;}
  inline bool IsHorn1RadiusBigEnough() const { return fHorn1RadiusBigEnough;}
  
//
// Interface to the Messenger, Horn1 and Horn2 parameters  
//
  inline void SetHorn1LongRescale(double r) {fHorn1LongRescale = r;}  
  inline double GetHorn1LongRescale() const {return fHorn1LongRescale;}  
  inline void SetHorn1RadialRescale(double r) {fHorn1RadialRescale = r;}  
  inline double GetHorn2LongRescale() const {return fHorn2LongRescale;}  
  inline void SetHorn2LongRescale(double r) {fHorn2LongRescale = r;}  
  inline double GetHorn2RadialRescale() {return fHorn2LongRescale;}  
  inline void SetHorn2RadialRescale(double r) {fHorn2RadialRescale = r;}  
  inline void SetHorn2RadialRescaleCst(double r) {fHorn2RadialRescaleCst = r;}  
  inline double GetHorn2LongPosition() const { return fHorn2LongPosition; }
  inline void SetHorn2LongPosition(double l) { fHorn2LongPosition = l; }

  inline bool GetUseMarsTargetHorns() const { return fUseMarsTargetHorns;} 
  inline void SetUseMarsTargetHorns( bool v) { fUseMarsTargetHorns=v;}

  inline G4String GetMarsTargetHornsGDMLFilename() const { return fMarsTargetHornsGDMLFilename; }
  inline void SetMarsTargetHornsGDMLFilename(G4String &name) { fMarsTargetHornsGDMLFilename=name; }

  inline G4String GetAbsorberGDMLFilename() const { return fAbsorberGDMLFilename; }
  inline void SetAbsorberGDMLFilename(G4String &name) { fAbsorberGDMLFilename=name; }
//
// more public getter to support the Magnetic field 
//
  inline double GetHorn1NeckZPosition() const { return fHorn1NeckZPosition; } // in Drawing coordinate system 
  inline double GetHorn1NeckLength() const { return fHorn1NeckLength; } //  ... but rescaled is asked for..
  inline double GetHorn1NeckOuterRadius() const { return fHorn1NeckOuterRadius; } // same coordinate system.. 
  inline double GetHorn1NeckInnerRadius() const { return fHorn1NeckInnerRadius; } // same coordinate system.. 
  inline double GetHorn1ZDEndNeckRegion() const { return fHorn1ZDEndNeckRegion; } // same coordinate system.. 
  inline double GetHorn1ZEndIC() const { return fHorn1ZEndIC; } // the Z end of the inner conductor, rescaled..
  inline double GetHorn1EffectiveLength() const { return  (fHorn1TopUpstrLength + fHorn1TopDownstrLength); }
  inline double GetHorn1DeltaZEntranceToZOrigin() const { return -fHorn1LongRescale*3.0*CLHEP::cm;} // To be checked!...
  inline double GetHorn1OuterTubeOuterRad() const {return  fHorn1OuterTubeOuterRad; }
  inline double GetHornsOuterTubeOuterRad(size_t iH) const {return  fHornsOuterTubeOuterRad[iH]; }
     //Same thing for Horn2 
  inline double GetHorn2NeckZPosition() const { return fHorn2NeckZPosition; } // in Drawing coordinate system 
  inline double GetHorn2NeckLength() const { return fHorn2NeckLength; } //  ... but rescaled is asked for..
  inline double GetHorn2NeckOuterRadius() const { return fHorn2NeckOuterRadius; } // same coordinate system.. 
  inline double GetHorn2NeckInnerRadius() const { return fHorn2NeckInnerRadius; } // same coordinate system.. 
  inline double GetHorn2ZEndIC() const { return fHorn2ZEndIC; } // the Z end of the inner conductor, rescaled..
  inline double GetHorn2ZEqnChange(size_t k) const {return fHorn2ZEqnChanges[k]; } 
  inline size_t GetHorn2ZEqnChangeNumEqn() const {return fHorn2ZEqnChanges.size(); } 
  inline double GetHorn2DeltaZEntranceToZOrigin() const {return fHorn2DeltaZEntranceToZOrigin; } 
  inline double GetHorn2OuterTubeOuterRad() const {return  fHorn2OuterTubeOuterRad; }
  inline bool GetDoInstallShield() const { return fDoInstallShield;} 
  inline void SetDoInstallShield( bool v) { fDoInstallShield=v;}
  void SegmentTarget(); // Check the target segmentation. Assume fixed Fin size. 
  void SegmentTargetSmallTgt(); // Check the target segmentation. Assume fixed Fin size. 
  void SegmentRALTGTv1();
// 
  //Additional Functions to ppfx..... Amit Bashyal 05/27/2016
  inline std::vector<G4String> GetHorn1ICList() const {return fHorn1IC;}
  inline std::vector<G4String> GetHorn2ICList() const {return fHorn2IC;}
       
  void RescaleHorn1Lengthwise();
  void RescaleHorn2Lengthwise();
  void RescaleHorn1Radially();
  void RescaleHorn2Radially();
  void ShiftHorn2Radially();
  // Custom stuff for the upstream part of Horn1 
  //
  // Custom Horn1, based on a G4Polycone
  //
  bool fUseHorn1Polycone; 
  bool fUseHornsPolycone; // Extension to arbitrary number of Horns
  int fUseHorn1PolyNumInnerPts; 
  std::vector<G4ThreeVector> fHorn1PolyListRinThickZVects;
  double fHorn1PolyOuterRadius;
  //
  // Additional Custom Horns, based on a G4Polycone  up to 5.  (set by the G4UI limits) 
  // August 2015. 
  //
  int fUseNumberOfHornsPoly; 
  std::vector<int> fUseHornsPolyNumInnerPts; 
  std::vector< std::vector<G4ThreeVector> > fHornsPolyListRinThickZVects;
  std::vector<double> fHornsPolyOuterRadius;
  std::vector<double> fHornsPolyZStartPos;
  //
  std::vector<bool>  fPolyconeHornsAreParabolic;  // October 2015: LoSecco, Horns can be parabolic.... 
  bool fPolyconeHorn1IsParabolic; // for consistency with the old Horn1 Optimization.
  //
  // November/December 2016:  Improve the accuracy of the magnetic field calculation.
  // We record the position of the inner conductor, as we build in the "PlaceFinalxxx" method. 
  // These will transfered to magnetic field methods, if the "ConceptualDesign, realistic" version of 
  // the horns are selected (on a horn by horn basis....) 
  // The coordinate system is the one from the LBNFSimpleHornxContainer, 
  // where x = 1,2,3 for Horn A, B, C respectively.  For sake of convenience, the Z coordinates are global,
  // returning from PlaceFinalLBNFConceptHornx.  
  //
  // The raddi are in local coordinate system. The LBNFSimpleHornxContainer volumes are surveyed, 
  // the rotation are taken out in the Magnetic field routines. It is implicitely assume that Z-translation effects 
  // are very small. 
  //
  std::vector<double>  fZCoordCDRevisedHornA;
  std::vector<double>  fRInCoordCDRevisedHornA;
  double fThickICDRevisedHornA;
  std::vector<double>  fZCoordCDRevisedHornB;
  std::vector<double>  fRInCoordCDRevisedHornB;
  double fThickICDRevisedHornB;
   std::vector<double>  fZCoordCDRevisedHornC;
  std::vector<double>  fRInCoordCDRevisedHornC;
  double fThickICDRevisedHornC;
 
  
  //
  LBNEVolumePlacementData* CreateHorn1TopLevelUpstr();
  
  const LBNEVolumePlacementData* Find(const G4String &name, const char *motherName, const char *method) const ;
  
  inline double GetConductorRadiusHorn1(double zD, size_t eqn) const {
     if (eqn >= fHorn1Equations.size()) return -1.;
     return fHorn1Equations[eqn].GetVal(zD);
  }
   inline double GetConductorRadiusHorn2(double zD, size_t eqn) const {
     if (eqn >= fHorn2Equations.size()) return -1.;
     return fHorn2Equations[eqn].GetVal(zD);
  }
//
// 1.2 MW, Feb 2014, November-December 2016. 
// 
  inline bool GetUse1p2MW() const { return fUse1p2MW; }
  inline void SetUse1p2MW(bool t) { fUse1p2MW = t; }
  
  inline bool GetUse1p2MWSmallTgt() const { return fUse1p2MWSmallTgt; }
  inline void SetUse1p2MWSmallTgt(bool t) { fUse1p2MWSmallTgt = t; }
  
  inline bool GetUseRALTGTv1() const { return fUseRALTGTv1; }
  inline void SetUseRALTGTv1(bool t) { fUseRALTGTv1 = t; }
  
//
  inline bool GetUseRoundedTargetFins() const { return fUseRoundedTargetFins; }
  inline void SetUseRoundedTargetFins(bool t) { fUseRoundedTargetFins = t; }
  void adaptTargetFor1p2MW();
  void adaptTargetFor1p2MWSmallTgt();
  void adaptRALTGTv1();
  void configureTargetForConceptHornARev2();
  //
  // Accessor of the accurate RZ map, as built.  
  //
  inline std::vector<double> GetHornsPolyInnerConductorRadiiHornARev2() const {return  fRInCoordCDRevisedHornA;} 
  // Inefficient, but done once per detector construction, per horn 
  inline std::vector<double> GetHornsPolyInnerConductorZsHornARev2() const {return  fZCoordCDRevisedHornA;} 
  inline double GetThickICDRevisedHornA() const { return fThickICDRevisedHornA; }
 
  // Same for Horn B. We will also add the point from the IO transition. 
  //
  inline std::vector<double> GetHornsPolyInnerConductorRadiiHornBRev2() const {return  fRInCoordCDRevisedHornB;} 
  inline std::vector<double> GetHornsPolyInnerConductorZsHornBRev2() const {return  fZCoordCDRevisedHornB;} 
  // Thickness is almost constant... Not true in I/O region, where field map very inaccurate, anyhow.. 
  inline double GetThickICDRevisedHornB() const { return fThickICDRevisedHornB; }
//
  // Same for Horn C. We will also add the point from the IO transition. 
  //
  inline std::vector<double> GetHornsPolyInnerConductorRadiiHornCRev2() const {return  fRInCoordCDRevisedHornC;} 
  inline std::vector<double> GetHornsPolyInnerConductorZsHornCRev2() const {return  fZCoordCDRevisedHornC;} 
  // Thickness is almost constant... Not true in I/O region, where field map very inaccurate, anyhow.. 
  inline double GetThickICDRevisedHornC() const { return fThickICDRevisedHornC; }
// August 2014, add arbitrary shaped Polycone. 
// 
  inline bool GetUseHorn1Polycone() const { return fUseHorn1Polycone; }
  inline int GetUseHorn1PolyNumInnerPts() const { return fUseHorn1PolyNumInnerPts; }
  inline double GetHorn1PolyInnerConductorRadius(size_t numPts) const {
      if (numPts >= static_cast<size_t>(fUseHorn1PolyNumInnerPts)) {
        G4Exception("GetHorn1PolyInnerConductorRadius",  " ", FatalErrorInArgument, "Bad Index");
      }
      G4ThreeVector v =  fHorn1PolyListRinThickZVects[numPts];
      return v[0];
  }
  inline double GetHorn1PolyInnerConductorThickness(size_t numPts) const {
      if (numPts >= static_cast<size_t>(fUseHorn1PolyNumInnerPts)) {
        G4Exception("GetHorn1PolyInnerConductorThickness",  " ", FatalErrorInArgument, "Bad Index");
      }
      G4ThreeVector v =  fHorn1PolyListRinThickZVects[numPts];
      return v[1];
  }
  inline double GetHorn1PolyInnerConductorZCoord(size_t numPts) const {
      if (numPts >= static_cast<size_t>(fUseHorn1PolyNumInnerPts)) {
        G4Exception("GetHorn1PolyInnerConductorZCoord",  " ", FatalErrorInArgument, "Bad Index");
      }
      G4ThreeVector v =  fHorn1PolyListRinThickZVects[numPts];
      return v[2];
  }
  inline double GetHorn1PolyOuterRadius() const { return fHorn1PolyOuterRadius;}
  //
  //Settors 
  //
  inline void SetUseHorn1Polycone(bool t) {
      
     fUseHorn1Polycone = t; 
     if (!t) return;
     fUseHornsPolycone = false; // not a typo, indicating new mode for defining the geometry. 
                              // we support the idea to have one and only horn, simple Polycone.
     fUseNumberOfHornsPoly = 1;
     fMotherHornsAllLengths.resize(1); 
     fMotherHornsAllRads.resize(1);
     fUseHornsPolyNumInnerPts.resize(1);
     fHornsPolyOuterRadius.resize(1);
     fHornsPolyListRinThickZVects.resize(1);
     fPolyconeHornsAreParabolic.resize(1); fPolyconeHornsAreParabolic[0] = false;
     fMotherHornsAllThick.resize(1);
     fHornsLength.resize(1);
     fHornsPolyZStartPos.resize(1); 
     fHornsPolyZStartPos[0] = 0.; // defining here the G4 world coordinate system with respect to the Horns
     fHornsOuterTubeOuterRad.resize(1);
     fRemoveDecayPipeSnout = true; 
  }
  inline void SetUseHorn1PolyNumInnerPts(int n)  { 
     fUseHorn1PolyNumInnerPts = n; 
     fHorn1PolyListRinThickZVects.resize(static_cast<size_t>(n));
  }
  inline void SetHorn1PolyInnerThreeVect(size_t iP, G4ThreeVector vVal) {
      if (fHorn1PolyListRinThickZVects.size() < iP) {
        size_t numMiss = iP - fHorn1PolyListRinThickZVects.size();
        for (size_t ipp = 0; ipp != numMiss; ipp++) { 
          G4ThreeVector vNew; vNew[0] = 40.;  vNew[1] = 2; vNew[2] = 400.;
          fHorn1PolyListRinThickZVects.push_back(vNew); 
        }
      }
      for (size_t kv=0; kv != 3; kv++) 
           fHorn1PolyListRinThickZVects[iP][kv] = vVal[kv];
  }
  inline void SetHorn1PolyOuterRadius(double r) { fHorn1PolyOuterRadius = r;}
  //
  // August 2015: extend this to an arbitrary number of Polycone horns  
  //
  inline int GetNumberOfHornsPolycone() const { return fUseNumberOfHornsPoly; }
  inline int GetUseHornsPolyNumInnerPts(size_t i) const {
    if ((i < 1) || (i > fUseHornsPolyNumInnerPts.size())) {
       G4Exception("GetUseHornsPolyNumInnerPts",  " ", FatalErrorInArgument, "Illegal Horn number");
    }   
    return fUseHornsPolyNumInnerPts[i-1]; 
  }
  inline double GetHornsPolyInnerConductorRadius(size_t iH, size_t numPts) const {
      if ((iH < 1) || (iH > fUseHornsPolyNumInnerPts.size())) {
       G4Exception("GetHornsPolyInnerConductorRadius",  " ", FatalErrorInArgument, "Illegal Horn number");
      }   
      std::vector<G4ThreeVector> data = fHornsPolyListRinThickZVects[(iH-1)];
      if (numPts >= data.size()) {
        G4Exception("GetHornsPolyInnerConductorRadius",  " ", FatalErrorInArgument, "Bad Index");
      }
      G4ThreeVector v =  data[numPts];
      return v[0];
  }
  inline double GetHornsPolyInnerConductorThickness(size_t iH, size_t numPts) const {
      if ((iH < 1) || (iH > fUseHornsPolyNumInnerPts.size())) {
       G4Exception("GetHornsPolyInnerConductorThickness",  " ", FatalErrorInArgument, "Illegal Horn number");
      }   
      std::vector<G4ThreeVector> data = fHornsPolyListRinThickZVects[(iH-1)];
      if (numPts >= data.size()) {
        G4Exception("GetHornsPolyInnerConductorThickness",  " ", FatalErrorInArgument, "Bad Index");
      }
      G4ThreeVector v =  data[numPts];
      return v[1];
  }
  inline double GetHornsPolyInnerConductorZCoord(size_t iH, size_t numPts) const {
     if ((iH < 1) || (iH > fUseHornsPolyNumInnerPts.size())) {
       G4Exception("GetHorn2PolyInnerConductorZCoord",  " ", FatalErrorInArgument, "Illegal Horn number");
      }   
      std::vector<G4ThreeVector> data = fHornsPolyListRinThickZVects[(iH-1)];
      if (numPts >= data.size()) {
        G4Exception("GetHornsPolyInnerConductorZCoord",  " ", FatalErrorInArgument, "Bad Index");
      }
      G4ThreeVector v =  data[numPts];
      return v[2];
  }
  inline double GetHornsPolyOuterRadius(size_t iH) const {
     if ((iH < 1) || (iH > fHornsPolyOuterRadius.size())) {
       std::cerr << " GetHornsPolyOuterRadius, iH = " << iH <<  " size of container.. " << fHornsPolyOuterRadius.size() << std::endl;
       G4Exception("GetHornsPolyOuterRadius",  " ", FatalErrorInArgument, "Illegal Horn number");
      }   
     
    return fHornsPolyOuterRadius[(iH-1)];
  }
  inline double GetHornsPolyZStartPos(size_t iH) const {
     if ((iH < 1) || (iH > fHornsPolyZStartPos.size())) {
       G4Exception("GetHornsPolyZStartPos",  " ", FatalErrorInArgument, "Illegal Horn number");
      }   
     
    return fHornsPolyZStartPos[(iH-1)];
  }
  //
  // Parabolic horns, as ( very ) segmented Polycone
  //
  inline bool IsHornPnParabolic(size_t numHorn) const {
    return fPolyconeHornsAreParabolic[numHorn-1]; // same convention as the other accessors. 
  }
  inline bool IsHorn1PlParabolic() const {
    return fPolyconeHorn1IsParabolic;
  }
  inline size_t GetHornParabolicNumInnerPts(size_t iH) const { return fMotherHornsAllLengths[iH].size();}
  inline double GetHornParabolicRZCoord(size_t iH, size_t k) const { return fMotherHornsAllLengths[iH][k];}
  inline double GetHornParabolicRIn(size_t iH, size_t k) const { return fMotherHornsAllRads[iH][k];}
  inline double GetHornParabolicThick(size_t iH, size_t k) const { return fMotherHornsAllThick[iH][k];}
  
  //
  //Settors 
  //
  inline void SetNumberOfHornsPolycone(int n) {
    if ((n < 1) || (n > 5)) {
         G4Exception("SetNumberOfHornsPolycone",  " ", FatalErrorInArgument, "Valid Number are 1, 2, 3, 4 or 5 ");
    }
    G4String msg0(
    " We hereby declaring the number of horns used in the simulation, either simple Polycone, or engineered \n"); 
    std::cout << msg0 << std::endl;
    std::cerr << msg0 << std::endl;
    if (n == 1) {
      G4String msg1(" We will be using one and only one  Horn, Mother is Polycone style. \n ");
      msg1 += std::string(" We assume it is the first horn. \n");
      std::cout << msg1 << std::endl;
     std::cerr << msg1 << std::endl;
    }
    fUseHorn1Polycone = false; // we will use the generic Placement even for Horn1, more consistent this way
    fUseHornsPolycone = true; // not a typo, indicating new mode for defining the geometry. 
                              // we support the idea to have one and only horn, simple Polycone.
    fUseNumberOfHornsPoly = n;
    fMotherHornsAllLengths.resize(n); 
    fMotherHornsAllRads.resize(n);
    fUseHornsPolyNumInnerPts.resize(n);
    fHornsPolyOuterRadius.resize(n);
    fHornsPolyListRinThickZVects.resize(n);
    fHornsLength.resize(n);
    fHornsPolyZStartPos.resize(n); 
    fHornsPolyZStartPos[0] = 0.; // defining here the G4 world coordinate system with respect to the Horns
    if (n > 1) { 
      for (size_t k=1; k != static_cast<size_t>(n); k++) { 
         fHornsPolyZStartPos[k] = -10000.*CLHEP::m; fHornsLength[k] = -1.;
       }
    } // used to check the initialization.
    fHornsOuterTubeOuterRad.resize(n);
    fPolyconeHornsAreParabolic.resize(n); 
    fMotherHornsAllThick.resize(n);
    for (size_t k=0; k != static_cast<size_t>(n); k++) fPolyconeHornsAreParabolic[k] = false; //default is false.. 
    fRemoveDecayPipeSnout = true; 
  }
  inline void SetPolyconeHornParabolic(size_t hornNumber, bool t) {
     if (hornNumber > 5) {
       G4Exception("SetPolyconeHornParabolic",  " ", FatalErrorInArgument, "Valid Number are 1, 2, 3, 4 or 5 ");
     }
     if (fUseNumberOfHornsPoly < static_cast<int>(hornNumber)) 
       this->SetNumberOfHornsPolycone(hornNumber);
     std::cerr << " Setting index " <<  hornNumber-1 
                 << " Hornpara.., size  " << fPolyconeHornsAreParabolic.size() << std::endl;
     fPolyconeHornsAreParabolic[hornNumber-1] = t;
  }
  inline void SetPolyconeHorn1Parabolic( bool t) {
    fPolyconeHorn1IsParabolic = t;
  }
  inline void SetUseHornsPolyNumInnerPts(size_t hornNumber, size_t nElem)  { 
     if (hornNumber > 5) {
       G4Exception("SetUseHornsPolyNumInnerPts",  " ", FatalErrorInArgument, "Valid Number are 1, 2, 3, 4 or 5 ");
     }
     fUseHornsPolyNumInnerPts[hornNumber-1] = nElem; 
     fHornsPolyListRinThickZVects[hornNumber-1].resize(nElem);
     fMotherHornsAllLengths[hornNumber-1].resize(nElem);
     fMotherHornsAllRads[hornNumber-1].resize(nElem);
  }
  inline void SetHornsPolyInnerThreeVect(size_t hornNumber, size_t iP, G4ThreeVector vVal) {
     if (hornNumber > 5) {
       G4Exception("SetUseHornsPolyInnerThreeVect",  " ", FatalErrorInArgument, "Valid Number are 1, 2, 3, 4 or 5 ");
     } 
     if (fHornsPolyListRinThickZVects[hornNumber-1].size() < iP) {
        size_t numMiss = iP - fHornsPolyListRinThickZVects[hornNumber-1].size();
        for (size_t ipp = 0; ipp != numMiss; ipp++) { 
          G4ThreeVector vNew; vNew[0] = 40.;  vNew[1] = 2; vNew[2] = 400.;
          fHornsPolyListRinThickZVects[hornNumber-1].push_back(vNew); 
        }
      }
      for (size_t kv=0; kv != 3; kv++) 
           fHornsPolyListRinThickZVects[hornNumber-1][iP][kv] = vVal[kv];
  }
  inline void SetHornsPolyOuterRadius(size_t hornNumber, double r) {
     if (hornNumber > 5) {
       G4Exception("SetUseHornsPolyOuterRadius",  " ", FatalErrorInArgument, "Valid Number are 1, 2, 3, 4 or 5 ");
     } 
     fHornsPolyOuterRadius[hornNumber-1] = r;
  }
  inline void SetHornsPolyZStartPos(size_t hornNumber, double z) {
     if (hornNumber > 5) {
       G4Exception("SetUseHornsPolyZStartPos",  " ", FatalErrorInArgument, "Valid Number are 1, 2, 3, 4 or 5 ");
     } 
     if ((hornNumber == 1) && (std::abs(z) > 5.0*CLHEP::mm)) {
       std::ostringstream mStrStr; mStrStr << " The Z start of the 1rst simple Horn must be at zero. Found value : " << z;
       std::string mStr(mStrStr.str()); 
       G4Exception("SetUseHornsPolyZStartPos",  " ", FatalErrorInArgument, mStr.c_str());
     } 
     
     fHornsPolyZStartPos[hornNumber-1] = z;
     
  }
  
private:
  // GUI Interface  
  
  // Messenger
  G4UImessenger *fPlacementMessenger;

  // maps, to map the name of the detector to its placement, rotation, and the
  // logical volume in which it is placed.
  
  std::map<G4String, LBNEVolumePlacementData> fSubVolumes;
  //
  // A rotation matrix we will use often, to implement the round corners  
  //
  G4RotationMatrix fRotVertical;
  //
  // A rotation matrix for the Titanium Cooling tube, HornA downstream target support.  
  //
  G4RotationMatrix fRotTgtTitCTubeVert;
  G4RotationMatrix fRotTgtTitCTubeHor;

  // Useful lengths/dimensions, gotten from the messenger class, or set internally.  

  G4double fTotalLength;
  G4double fLengthOfRockDownstr;
  G4double fTargetHallZ;
  G4double fAbsorberHallZ;
  G4double fDecayHallZ;
  G4double fDecayPipeLength; 
  G4double fDecayPipeLengthCorrection;
  G4double fDecayPipeRadius;
  G4double fDecayPipeUpstrWindowThick;
  G4double fDecayPipeWallThick;
  G4double fDecayPipeLongPosition; 
  G4String fDecayPipeGas;
  
  G4double fWaterLayerThickInHorns;
  G4double fHorn1Length; 
  std::vector<double> fHornsLength; // Aug. 2015.  Extensions to multiple Simple Polycone Horns 
  G4double fTargetAndBaffleLengthApprox; 
  G4double fTargetAndPlugLengthApprox;
  G4double fHorn1DownstreamPlateLength; // Bulkhead, guess work at this point 
  //
  G4double fDistMCZeroToACTRN1Pts; // See drawing 8875.112-MD-363097, with Jim Hylen annotation. 
  // 
  G4double fBaffleInnerRadius;
  G4double fBaffleOuterRadius;
  G4double fBaffleLength;
  G4double fBaffleWindowThickness;
  G4double fBaffleZPosition; // With respect to 0. of TargetHallAndHorn1 center (MCZERO) 
  G4double fPlugInnerRadius;
  G4double fPlugOuterRadius;
  G4double fPlugLength;
  G4double fPlugZPosition; // With respect to 0. of Horn2 center (MCZERO) 
  std::string fPlugMaterial;
  //
  // Target description.  Variable name 
  // borrowed (inspired, actually) from LBNENumiDataInput, when applicable. 
  //
  G4double fTargetSLength; // total length from first fin Beryllium window end cap. 
  G4double fTargetSLengthGraphite;// total length for the graphite target per-se. **Settable via Messenger. 
  G4double fTargetDensity; // Density of the target
  G4double fTargetSpecificLambda; // Specific nuclear interaction length of the target material
  G4String fTargetMaterialName;
  G4double fTargetLengthIntoHorn;
                       // offset with respecto MCZERO, and/or the transition between UpstreamTarget Hall and Horn1 Hall
                       // **Settable via Messenger. 
  G4double fTargetLengthOutsideHorn; // defined from the above.
  G4double fTargetLengthOutsideExtra; // Only for the Pseudo Nova option 
  G4double fTargetSLengthDownstrEnd;
  G4double fTargetZOffsetStart; 
  // No fTargetX0, Y0:  These would be surveyed point, part of the alignement 
  // realm, i.e. handled in the Surveyor class.
  G4double fTargetFinWidth;
  G4double fTargetFinWidthRequired;
  // Oct. Nov. 2016, Conceptual design of Horn A & NuMI target, adopting these wings 
  unsigned int fTargetNumFinsWithWings;
  G4double fTargetFinWWingRadius; // New variable. 
  G4double fTargetFinContainerWidth; // No longer used in the Conceptual 
  // design for HornA, October/November 2016. 
  G4double fTargetFinExtraWidth;// same... 
  G4double fTargetFinHeight;
  G4double fTargetFinLength; // 
  G4int fTargetNumFins;
  G4int fTargetNumFinsUpstr;
  G4int fTargetNumFinsInHorn;
  // Quynh, August 2014. 
  G4int fTargetNumSphere;
  G4double fTargetFinLengthSplitUpstr; // 
  G4double fTargetFinLengthSplitDwnstr; // 
  G4double fTargetFinSpacingLength; // Averaged over the whole length
  G4double fTargetUpstrUpstrMargin; 
  G4double fTargetUpstrDwnstrMargin; 
  G4String fTargetUpstrPlateMaterial;
  G4double fTargetUpstrPlateHoleRadius;
  G4double fTargetUpstrPlateOuterRadius;
  G4double fTargetUpstrPlateThick;
  G4String fTargetCanMaterial;
  G4double fTargetCanInnerRadius;
  G4double fTargetCanOuterRadius;
  G4double fTargetCanLength;
  G4String fTargetDownstrCanFlangeMaterial;
  G4double fTargetDownstrCanFlangeOuterRadius;
  G4double fTargetDownstrCanFlangeInnerRadius;
  G4double fTargetDownstrCanFlangeThick;
  G4String fTargetFlangeMaterial;
  G4double fTargetFlangeInnerRadius;
  G4double fTargetFlangeOuterRadius;
  G4double fTargetFlangeThick;
  G4String fTargetCTubeMaterial;
  G4double fTargetCTubeOuterRadius;
  G4double fTargetCTubeInnerRadius;
  G4double fTargetCTubeUpstrLength;
  G4double fTargetCTubeUpstrOffset;
  G4double fTargetCTubeUpstrRadCurve;
  G4double fTargetCTubeReturnLengthUpstr;
  G4int fTargetCTubeUpstrNumSegCurve;
  G4double fTargetCTubeReturnHOffset;
  G4double fTargetCTubeReturnLengthDownstr;// Obsolete.but keep for possible upgrade if need 
  // Replaced by an effective thicness Titanium + water effective thickness
  G4double fTargetCTubeReturnDownstrCutAngleStart; // The angle at which we start, from 90 dgree (x=0., y ~ 16.5 mm) 
  G4double fTargetCTubeReturnDownstrCutAngleSize; // The angular size of the wedge representing the volume
  G4double fTargetCTubeReturnDownstrRadInner;
  G4double fTargetCTubeReturnDownstrRadOuter;
  G4double fTargetCTubeReturnDownstrThickTitanium;
  G4double fTargetCTubeReturnDownstrThickWater;
  // 
  G4double fTargetCTubeReturnLengthUstr;
  G4double fTargetCTubeReturnLengthUpstrEnd;
  G4double fTargetDistFlangeToTargetStart;
  G4double fTargetDistToStartOfFlange;
  G4double fTargetAlignRingThick;
  G4double fTargetAlignRingInnerRadius;
  G4double fTargetAlignRingOuterRadius;
  G4double fTargetAlignRingCutAngle;
  G4String fTargetAlignRingMaterial;
  G4double fTargetAlignRingSpacing;
  G4int fMaxNumAlignRings;
  G4double fTargetBerylDownstrWindowThick;
  G4double fTargetBerylDownstrWindowRadius;
  G4double fTargetBerylUpstrWindowThick;
  G4double fTargetBerylUpstrWindowRadius;
  G4double fTargetHeContTubeThickness;
  G4double fTargetHeContTubeInnerRadius;
  G4double fTargetHeContTubeOuterRadius;
  G4double fTargetOutHeContTubeInnerRadius;
  G4double fTargetOutHeContTubeOuterRadius;
  G4double fTargetCTubeLength;
  G4double fTargetHeContTubeSmallConeLength;
  G4double fTargetHeContTubeSmallCylLength;
  G4double fTargetHeContTubeSmallConeInnerRad;
  G4double fTargetHeContTubeSmallConeOuterRad;
  G4double fRALSimpleTargetLength;
  G4double fTargetHeContTubeLargeConeInnerRad; 
  G4double fTargetHeContTubeLargeConeOuterRad; 
  G4double fTargetHeContTubeLargeConeLength;
  G4double fTargetHeContTubeBaffletLength;
  G4double fTargetBaffletOutRadius;
  G4double fTargetDSSupportConnRing;
  G4double fTargetBaffletLengthNoFlange;
  G4double fTargetBaffletFlangeLength;
  G4double fTargetHeContTubeColdHeCurvature;
  G4double fTargetOutHeContTubeInnerRadiusTapered;
  G4double fTargetOutHeContTubeOuterRadiusTapered;
  G4double fTargetOutHeContTubeTaperedLength;
  G4double fTargetOutHeContTubeStraightLength;
  G4double fTargetOutHeContTubeOuterSphericalEndCap;
  G4double fTargetOutHeContTubeInnerSphericalEndCap;
  G4double fTargetHeContTubeLengthUpstr;
  G4double fTargetHeContTubeLengthInHorn;
  G4double fTargetHeContTubeLength; // New August/Sept 2014. 
  G4double fThicknessWall;
  G4double fTargetDSSupportAlRingThickness;
  G4double fTargetDSSupportAlRingInnerRad;
  G4double fTargetDSSupportSmallConeLength;
  G4double fTargetDSSupportLargeConeLength;
  G4double fTargetDSSupportSmallConeSmallInnerRad;   
  G4double fTargetDSSupportSmallConeSmallOuterRad;
  G4double fTargetDSSupportSmallConeLargeInnerRad;
  G4double fTargetDSSupportSmallConeLargeOuterRad;
  G4double fTargetDSSupportLargeConeSmallInnerRad; 
  G4double fTargetDSSupportLargeConeSmallOuterRad; 
  G4double fTargetDSSupportLargeConeLargeInnerRad; 
  G4double fTargetDSSupportLargeConeLargeOuterRad; 
  G4double fTargetDSSupportOuterRingInnerRad; 
  G4double fTargetDSSupportOuterRingOuterRad; 
  G4double fTargetDSSupportOuterRingLength;
  // derived quantities
  G4double fTargetZ0; // offset with respecto MCZERO 
  G4double fTargetZ0Upstr; // For the two sections of the target. 
  G4double fTargetZ0Downstr; // For the two sections of the target. 
  G4double fTargetSWidth;
  G4double fTargetSHeight;
  //
  // Variables that are part physicall part of Horn1 but located logically in G4, in UpstreamTargetAssembly. 
  // We decompose the Inner to Outer conductor transition into 5 section of cones. 
  //
  std::vector<G4double> fTargetHorn1InnerRadsUpstr;
  std::vector<G4double> fTargetHorn1InnerRadsDownstr;
  std::vector<G4double> fTargetHorn1TransThick;
  std::vector<G4double> fTargetHorn1Lengths;
  std::vector<G4double> fTargetHorn1ZPositions;
  //
  // December 2013: Request to support 1.2 MW target option.  1rst step is to provide 
  // a simple target, box and/or cylinder 
  //
  G4bool fUseSimpleTargetBox;  
  G4bool fConstructPlug; 
  G4bool fConstructPlugInHorn1; 
  G4bool fUseSimpleTargetCylinder;  
  G4double fSimpleTargetLength;
  G4double fSimpleTargetRALLength;
  G4double fRALTargetRing;
  G4double fRALTargetRadius;
  G4double fThicknessBafflet;
  G4double fSimpleTargetRadius; // not used if box. 
  G4double fSimpleTargetHeight; // not used if cylinder 
  G4double fSimpleTargetWidth; // not used if cylinder 
  G4double fTotalLengthUpstreamAssembly;
  G4double fTotalLengthTargetAndHorn1Hall;
//Quynh, August 2014 
  G4bool fUseMultiSphereTarget;  
  G4double fMultiSphereTargetLength; 
  G4double fMultiSphereTargetRadius;
// October 2015, 
//
  bool fRemoveTargetAlltogether;
  //
  // Horn1, excluding the target elements in side the Horn1. 
  //
  bool fFillHornsWithArgon; // Introduced on June 18 2015. default is false, 
                           // for sake of consistency with LBNF CD1-refresh
                           // Likely to change to true, or we will fill with Helium.. 
  G4int fHorn1RadialRescaleCnt; // A counter to avoid calling the Rescale method twice in a give job .
                                // Amit B., Paul L. March 2015. 
  G4int fHorn1LongRescaleCnt;                           
  //
  // First, a rescaling factor with respect to current (NUMI based) design
  //
  G4double fHorn1RadialRescale;
  G4double fHorn1LongRescale;
  G4double fHorn1RadialSafetyMargin;
  G4double fHorn1RMinAllBG; // 1.2 MW upgrade, insterting the target fully into the horn. 
  G4double fHorn1RMaxAllBG; // 1.2 MW upgrade, insterting the target fully into the horn. 
  bool fHorn1RadiusBigEnough; // 1p2 MW design and optimization: set the inner conductor radius sufficiently large such that 
  // it does not interfere with the Target helium Container tube. 
  
  G4double fHorn1IOTransLength; // Transition Inner to Outer conductors. A container volume (TUBS)
  G4double fHorn1IOTransInnerRad; // Surveyable!. But physically attachached to the top level section. 
  G4double fHorn1IOTransOuterRad;
  
  std::vector<G4double> fHorn1UpstrInnerRadsUpstr;
  std::vector<G4double> fHorn1UpstrInnerRadsDownstr; 
  std::vector<G4double> fHorn1UpstrInnerRadsOuterUpstr;
  std::vector<G4double> fHorn1UpstrInnerRadsOuterDownstr; 
  std::vector<G4double> fHorn1UpstrLengths;
  std::vector<G4double> fHorn1UpstrZPositions;

  std::vector<G4double> fHorn1UpstrOuterIOTransInnerRads; 
  std::vector<G4double> fHorn1UpstrOuterIOTransThicks; 
  std::vector<G4double> fHorn1UpstrOuterIOTransLengths; 
  std::vector<G4double> fHorn1UpstrOuterIOTransPositions; 

  G4double fHorn1TopUpstrLength; // Upstream part of the inner conductor, container volume (TUBS), Surveyed. 
  G4double fHorn1TopUpstrInnerRad; // This volume envelopes the target. 
  G4double fHorn1TopUpstrOuterRad;
  G4double fZHorn1ACRNT1Shift;  // Z coordinate shift from the beginning of Horn1TopLevelUpstr and Z=0., drawing coordinate. 
  
  G4double fHorn1TopDownstrLength; // Do part of the inner conductor, container volume (TUBS), Surveyed. 
  G4double fHorn1TopDownstrOuterRad;
  G4double fHorn1NeckLength;
  G4double fHorn1NeckOuterRadius;
  G4double fHorn1NeckInnerRadius;
  G4double fHorn1ZDEndNeckRegion;
  G4double fHorn1NeckZPosition; // from the start of Horn1TopLevelUpstr
  G4double fHorn1ZEndIC; // Z coordinate of the end of the inner conductor, rescaled is need be.
                                              
  // The outer tube
  
  G4double fHorn1OuterTubeInnerRad; 
  G4double fHorn1OuterTubeOuterRad; 
  std::vector<double> fHornsOuterTubeOuterRad;
  G4double fHorn1OuterConnectorRad;  // rescaled radially as well. 
  G4double fHorn1OuterConnectorThick;
  G4double fHorn1OuterConnectorLength;
  G4double fHorn1OuterConnectorPosition;

  G4double fHorn1InnerConnectorRad; // dwonstream end connectors 
  G4double fHorn1InnerConnectorThick;
  G4double fHorn1InnerConnectorLength;
  G4double fHorn1InnerConnectorPosition;
  
  G4String fHorn1InnerCondMat; // so that we can study the relevance of thinning the conductor. 
  G4String fHorn1AllCondMat; // so that we can study the relevance of thinning the conductor. 
  
  std::vector<LBNEHornRadialEquation> fHorn1Equations;
  //
  // For the Nova-like  option, different volume hierarchy. 
  // 
  G4VPhysicalVolume* fTargetNoSplitM1;
  G4VPhysicalVolume* fTargetHorn1HallPhysPtr;
  G4PVPlacement* fHorn1HallPhysPtr;
  //
  // ==========================================================
  // 
  // Horn2 
  //
  G4int fHorn2RadialRescaleCnt; // A counter to avoid calling the Rescale method twice in a give job .
                                // Amit B., Paul L. March 2015. 
  G4int fHorn2LongRescaleCnt;                           
  G4double fHorn2RadialRescale;
  G4double fHorn2RadialRescaleCst;  // Added Dec. 16 2014 
  G4double fHorn2LongRescale;
  G4double fHorn2LongPosition; // with data cards... 
  //
  G4double fHorn2Length; // Top level volume, surveyable. and rescal-able. 
  G4double fHorn2LengthNominal; // As found on drawing 8875.112-MD 363382, Revision E 
  G4double fHorn2Radius;
  G4double fHorn2OffsetIOTr1; // The distance between Z=0 in Horn2 Drawing coordinate and 
                              // the most upstream z location of the Inner Outer transition piece
                              
  // We will subdivide Horn2 along the parts on Drawing 8875.112MD - 363383
  //  
  // Part 1 (index 0 in the array below) : Transition Inner to outer conductor . Drawing 363382
  // Part2.... Up to 7. 
  //
  std::vector<G4double> fHorn2PartsLengths; 
  std::vector<G4double> fHorn2PartsRadii;
  
  G4double fHorn2LengthMargin;   
  //
  // We approximate the upstream inner to outer transition (part 1) as a bunch tubs 
  //
  std::vector<G4double> fHorn2UpstrOuterIOTransRadsOne; 
  std::vector<G4double> fHorn2UpstrOuterIOTransRadsTwo; 
  std::vector<G4double> fHorn2UpstrOuterIOTransLengths; 
  std::vector<G4double> fHorn2UpstrOuterIOTransPositions; // with respect to the start of the mother volume
  //
  // And one mulit-sections cone section, whoe raddi are set the equations..  
  //
  G4double fHorn2InnerIOTransLength;
  
  std::vector<LBNEHornRadialEquation> fHorn2Equations;

  // The outer tube
  
  G4double fHorn2OuterTubeInnerRad; 
  G4double fHorn2OuterTubeOuterRad; 
  G4double fHorn2OuterTubeOuterRadMax; // include downstream flange
  //
  // July 2016: Installation of Conceptual design, Optimized horns. 
  // To be used in the installation of the doswtream parts of the Horn2 current equalizer sections,
  // along with the striplines. 
  //
  G4double fLengthCurrEqICInMotherHorn2, fRadInnerICCurrEqHorn2, fRadOuterICCurrEqHorn2;
  G4double fLengthCurrEqOCInMotherHorn2, fRadInnerOCCurrEqHorn2, fRadOuterOCCurrEqHorn2;
  G4RotationMatrix* fRotHornBStrpLineConnFlatB[4];
  G4RotationMatrix* fRotHornBStrpLineConnFlatC[4];
  G4RotationMatrix* fRotHornBStrpLineRotY;
  
// To be used in the coordinate transform for computing the magnetic field 

  std::vector<G4double> fHorn2ZEqnChanges; // Z Coordinates (Drawing ) where the equation setting the radius changes. 
  G4double fHorn2NeckLength;
  G4double fHorn2NeckOuterRadius;
  G4double fHorn2NeckInnerRadius;
  G4double fHorn2NeckZPosition; // from the start of Horn1TopLevelUpstr
  G4double fHorn2ZEndIC; // Z coordinate of the end of the inner conductor, rescaled is need be.
  G4double fHorn2DeltaZEntranceToZOrigin;
//
  G4String fHorn2InnerCondMat; // so that we can study the relevance of thinning the conductor. 
  G4String fHorn2AllCondMat; // so that we can study the relevance of thinning the conductor. 
  G4String fHorn3InnerCondMat; // so that we can study the relevance of thinning the conductor. 
  G4String fHorn3AllCondMat; // so that we can study the relevance of thinning the conductor. 
  G4double fHorn3ICQLengthIntoHornMother;
  G4double fHorn3OCQLengthIntoHornMother;
  G4double fRadOuterOCCurrEqHornC;
  G4double fRadInnerOCCurrEqHornC;
  G4double fRadOuterICCurrEqHornC;
  G4double fRadInnerICCurrEqHornC;
//
//  Ferburary 7-10 2015: The optimum geometry prefers a longer Horn2, and placed further downstresm
// Extend the chase, optionally, and reduce the decay pipe length  See method ExtendChaseForHorn2 
//
   G4double fExtendChaseLength;
//
// March 10 2015: Implement the magentic field inside the decay pipe.. 
//
 
   G4double fRadiusMilindWire;
   G4double fCurrentMilindWire;

  G4double fWriteGDMLFile;

//
// August Sept 2015:, post CD1-Refresh, LBNF era:
//
   G4double fChaseWidthForLBNF;   
   
//
// ===========================================
//
//
// Decay Pipe Snout Window ( if Helium chosen) 
//
  G4double fDecayPipeWindowZLocation; 
  G4double fDecayPipeWindowRadiusAlum;
  G4double fDecayPipeWindowRadiusBeryl;
  G4double fDecayPipeWindowThickBeryl; // Alreay defined see fDecayPipeUpstrWindowThick
  G4double fDecayPipeWindowThickAlum;
// 
// Other dimensions in PlaceFinalDecayPipeSnout
//
//
// 1.2 MW option, February 2014 to December 2016 
//
   G4bool fUse1p2MW;
   G4bool fUse1p2MWSmallTgt;  // Used in conjunction with the NuMI horns 
   G4bool fUseRALTGTv1;
   // degsign, Feb. 2014 
//
// Improve accuracy of volumes in target, rounded fins, March 2014
//
   G4bool fUseRoundedTargetFins;
// 
// July 2014: a logical to declare the target completely out of Horn1, similar to the NuMI Medium energy 
// setting currently used for Nova. Set when fTargetLengthOutsideHorn is < entire target length. 
//  If true, Valid only for the 1.2 MW option.  
//
   G4bool fUsePseudoNova;
//    
//
// Connectors and flange downstream used only once,  so we declare and rescale them as we go  
  
  bool fUseMarsTargetHorns; // a flag to turn on Mars GDML geometry for target and horns

  G4String fMarsTargetHornsGDMLFilename; 

  G4String fAbsorberGDMLFilename; 
//
// Steel shielding surrounding the horns 
//
  bool fDoInstallShield; // a flag to install or removing these shielding block. 
   
     
  // a flag to check the geometry as it is constructed. 
  
  bool fCheckVolumeOverLapWC;
  
  // Store the mother volume at top of volume hierarchy, for book-keeping/debugging purposes. 
  
  const G4LogicalVolume* fTopLogicalVolume;
  //
  // August 2014: Decide to install the complete Horn1 as a polycone volume to avoid having to split it
  // 
  // But, we'd like to keep the existing code as such, so, we start by placing a flag. 
  bool fHorn1MotherIsPolycone;
  double fArbitraryOffsetHystericalOne;
  std::vector<double> fMotherHorn1AllRads;
  std::vector<double> fMotherHorn1AllLengths; // [0] is the most upstream length. 
  std::vector<double> fMotherHorn1AllThick; 
// Extension to multiple Horns 
  std::vector< std::vector<double> > fMotherHornsAllRads;
  std::vector< std::vector<double> > fMotherHornsAllThick;
  std::vector< std::vector<double> > fMotherHornsAllLengths; // [0] is the most upstream length.  
//
 // October 2014: logical flag to build (or not) the decay Pipe snout, such that we have more room to place 
 // the Horns 
 bool fRemoveDecayPipeSnout;
  bool fUseGDMLFile;
  
    //To calculate the absorption outside target more effecient.....Amit Bashyal
  std::vector<G4String> fHorn1IC;
  std::vector<G4String> fHorn2IC;
  
//
// LBNF era:    
// June 2016: Starting on the detailed representation of the 3 Horns for LBNF, optimized and conceptual engineering. 
 //
  bool fUseLBNFOptimConceptDesignHornA;
  bool fUseLBNFOptimConceptDesignHornB;
  bool fUseLBNFOptimConceptDesignHornC;
  bool fUseCDR2015Optimized;
  double fZShiftConceptHornAStartIC;
  double fZHallHorn1ToHorn1PolyM1;
  bool fInstallBaffle;
  bool fRemoveRALBafflet;
  bool fInstallUpstreamHorizontalTarget;
  bool fInstallRALShortTarget;
  bool fInstallDownstTargetSupport;
  size_t fLBNFOptimConceptDesignHornCNumStepIC[10]; // number of major subsections of of the inner conductor. 
  //
  // This method was found in G4PVPlacement. It is a clone, where we just skip 
  // the error messages.   
  bool CheckOverlaps(const G4PVPlacement *phys, G4int nres, G4double eps, G4bool verbose) const; 
  //
  // More intialization done here (too keep the constructor code of reasonable length.. )
  //
  void DeclareHorn1Dims(); 
  void CheckHorn1InnerConductAndTargetRadii(); // A check prior to the CheckOverlap of Geant4.  In principle, 
                                               // simpler and therefore more exact or reliable. 
                                               // If fail, issues a fatal G4Exception. 
  int GetNumberOfInnerHornSubSections(size_t eqn, double z1, double z2, int nMax) const;
  int GetNumberOfInnerHorn2SubSections(size_t eqn, double z1, double z2, int nMax) const;
   
  void Horn1InstallSpiderHanger(const G4String &name, double zFromStartInnerConduct, double zPos,
                                G4PVPlacement *vMother );                                              
  void Horn2InstallSpiderHanger(const G4String &name, G4PVPlacement *vMother );                                        
  void Horn1PlaceAWeld(const G4String &name, double z, 
                                const LBNEVolumePlacementData *plInfo,  G4PVPlacement *vMother );
                                                                               
  void DeclareHorn2Dims(); 
  // 
  // 1.2 MW upgrade.. 
  // 
  void PlaceFinalUpstrTarget1p2MW(G4PVPlacement *mother);
  void PlaceFinalDownstrTarget1p2MW(G4PVPlacement *mother);
  void PlaceFinalSmallTarget1p2MW(G4PVPlacement *mother);
  void PlaceRALTGTv1(G4PVPlacement *mother);

// 
// Simple target implementation.. 
// 
  void PlaceFinalRALTarget(G4PVPlacement *mother);
  void PlaceFinalUpstrTargetSimpleCylinder(G4PVPlacement *mother);  
  void PlaceFinalUpstrTargetSimpleBox(G4PVPlacement *mother);  
  void declareTargetFinVertCorners(LBNEVolumePlacementData &info);
//Quynh add Sphere target choice----------------------------
  void PlaceFinalUpstrMultiSphereTarget(LBNEVolumePlacementData *plHelium, G4PVPlacement *mother);
  //
  void setMotherVolumeForHorn1(); // Simplification of geometry, August/Sept 2013.  
  void setEntireTargetDims(); // Simplification of geometry, August/Sept 2013.  
  void DumpAllHornsPolyconeParameters(); // for debugging... 
  public: 
  //
  // Transfer of the radial information about the field to the 1p2 MW new design of Horn1 
  //
  inline double GetHorn1RMinAllBG() const {return fHorn1RMinAllBG;} // Big radius of inner conductor, inner radius if 1p2 MW
  inline double GetHorn1RMaxAllBG() const {return fHorn1RMaxAllBG;} 
  //
  inline void SetUsePseudoNova(bool t) {fUsePseudoNova = t;}
  inline bool GetUsePseudoNova() const {return fUsePseudoNova;}
  inline void SetTargetNoSplitM1(G4VPhysicalVolume *p) { fTargetNoSplitM1 = p;}
  inline void SetTargetHorn1HallPhysPtr(G4VPhysicalVolume *p) { fTargetHorn1HallPhysPtr = p;}
  inline void SetHorn1HallPhysPtr(G4PVPlacement *p) { fHorn1HallPhysPtr = p;}
  //
  inline bool GetHorn1MotherIsPolycone() const {return fHorn1MotherIsPolycone;}
  
// July-August 2014: Multi-sphere target (Quynh )

  inline void SetUseMultiSphereTarget(bool t) { fUseMultiSphereTarget = t;} 
  inline void SetMultiSphereTargetLength (double r) {fMultiSphereTargetLength = r;} //Quynh. real target.(2) - July 16 2014
  inline void SetMultiSphereTargetRadius (double r) {fMultiSphereTargetRadius = r;} //Quynh, P.L., August 2014 
  inline bool GetUseMultiSphereTarget() const { return fUseMultiSphereTarget;}
  inline double GetMultiSphereTargetRadius() const {return fMultiSphereTargetRadius;}
  void AdaptForMultiSphereTarget();
  void PlaceFinalMultiSphereTarget(LBNEVolumePlacementData *plHelium, G4PVPlacement *mother); 
   
  inline bool GetRemoveDecayPipeSnout() const {return fRemoveDecayPipeSnout;}
  inline void SetRemoveDecayPipeSnout(bool t) { fRemoveDecayPipeSnout = t;}
  
  inline double GetRadiusMilindWire() const {return fRadiusMilindWire;}
  inline void SetRadiusMilindWire(double r) { fRadiusMilindWire = r;}
  inline double GetCurrentMilindWire() const {return fCurrentMilindWire;}
  inline void SetCurrentMilindWire(double r) { fCurrentMilindWire = r;}

  inline bool GetWriteGDMLFile() const {return fWriteGDMLFile;}
  inline void SetWriteGDMLFile(bool t) { fWriteGDMLFile = t;}

  // August 2015.. 
  inline double GetChaseWidthForLBNF() const { return fChaseWidthForLBNF;}

  // John Back, March 2016, target module options, which includes the SAT
  // Also added mirror image 2nd target module options: Jan 2017
  bool fUseTargetModule;
  inline void SetUseTargetModule(bool t) {fUseTargetModule = t;}
  inline bool GetUseTargetModule() const { return fUseTargetModule;}
  bool fUseTarget2Module;
  inline void SetUseTarget2Module(bool t) {fUseTarget2Module = t;}
  inline bool GetUseTarget2Module() const { return fUseTarget2Module;}

  // The target module type
  enum TargetType {SAT = 0, Cylinder = 1};

  int fTargetModuleType;
  void SetTargetModuleType(int i) {fTargetModuleType = i;}
  inline int GetTargetModuleType() const {return fTargetModuleType;}
  int fTarget2ModuleType;
  void SetTarget2ModuleType(int i) {fTarget2ModuleType = i;}
  inline int GetTarget2ModuleType() const {return fTarget2ModuleType;}

  // Initialise the geometrical parameters for the target module(s)
  void InitTargetModule();
  void InitTarget2Module();

  // Create and place the target modules
  void PlaceTargetModule(int number = 1);

  // Create the individual target module volumes
  LBNEVolumePlacementData* CreateTargetVol(const G4String &volName, int number = 1);

  // Place the outer canister of the target module(s)
  void PlaceTargetOuterCan(int number = 1);

  // Place the inner canister of the target module(s)
  void PlaceTargetInnerCan(int number = 1);

  // Place the inner support rods of the target module(s)
  void PlaceTargetSupport(int number = 1);

  // Place the actual targets, e.g. cylinder or spheres
  void PlaceTargetObject(int number = 1);

  // The radius of the target object(s)
  G4double fTargetRadius;
  inline void SetTargetRadius (double r) {fTargetRadius = r;}
  inline double GetTargetRadius() const {return fTargetRadius;}
  G4double fTarget2Radius;
  inline void SetTarget2Radius (double r) {fTarget2Radius = r;}
  inline double GetTarget2Radius() const {return fTarget2Radius;}

  // The length of the target object
  G4double fTargetLength;
  inline void SetTargetLength (double l) {fTargetLength = l;}
  inline double GetTargetLength() const {return fTargetLength;}    
  G4double fTarget2Length;
  inline void SetTarget2Length (double l) {fTarget2Length = l;}
  inline double GetTarget2Length() const {return fTarget2Length;}    

  // Both target modules will use the same supporting structure dimensions:
  // only the target object(s) radius, length and/or material will differ

  // The diameter thickness of the supporting rods holding the target object
  G4double fTargetSupportD;

  // The total length of the supporting rods
  G4double fTargetSupportL;

  // The thickness of the Ti casings
  G4double fTargetCaseT;
  // The He gas gap between the two Ti casing cylinders
  G4double fTargetHeGap;
  // The inner radius of the outer casing
  G4double fTargetOutCaseInnerR;
  G4double fTarget2OutCaseInnerR;

  // The integer number of target objects (cylinder = 1, spheres = N)
  int fNumTargetObjects;
  int fNumTarget2Objects;

  // The length of the inner canister holding the spheres
  G4double fTargetInCaseL;
  G4double fTarget2InCaseL;

  // The length of the upstream start of the inner target canister
  G4double fTargetInCaseUpL;

  // The length of the downstream end of the inner target canister
  G4double fTargetInCaseDnL;

  // The length separation between the downstream end of the inner target canister
  // and the downstream end of the cylindrical section of the outer target canister
  G4double fTargetCaseDiffL;

  // The length of the outer target canister
  G4double fTargetOutCaseL;
  G4double fTarget2OutCaseL;

  // The total length of the target module, including the end bulb of the outer canister
  G4double fTargetModuleTotL;
  G4double fTarget2ModuleTotL;

  // The fractional length of the first target module outside Horn1. The second module
  // is always placed with respect to the first one
  G4double fTargetFracOutHornL;
  inline void SetTargetFracOutHornL(double l) {fTargetFracOutHornL = l;}
  inline G4double GetTargetFracOutHornL() const {return fTargetFracOutHornL;}

  // The number of interaction lengths required for the target object
  G4double fTargetNLambda;
  inline void SetTargetNLambda(double N) {fTargetNLambda = N;}
  inline G4double GetTargetNLambda() const {return fTargetNLambda;}
  G4double fTarget2NLambda;
  inline void SetTarget2NLambda(double N) {fTarget2NLambda = N;}
  inline G4double GetTarget2NLambda() const {return fTarget2NLambda;}

  // May need to set the extra outside length depending on Horn1 set-up, for example
  // if UseHorn1Polycone = false (default)
  inline void SetTargetLengthOutsideExtra(double l) {fTargetLengthOutsideExtra = l;}
  inline G4double GetTargetLengthOutsideExtra() const {return fTargetLengthOutsideExtra;}

  // Helper function to find the number of spheres in the SAT given 
  // the required number of interaction lengths, taking into account
  // the finite size of the Gaussian beam
  G4double FindNTargetSpheres(int number = 1) const;

  // For the second module target material, which can be different from the first module
  G4double fTarget2Density; // Density of the target
  G4double fTarget2SpecificLambda; // Specific nuclear interaction length of the target material
  G4String fTarget2MaterialName;
  inline double GetTarget2Density() const { return fTarget2Density; }
  inline void SetTarget2Density(double l) { fTarget2Density = l; }

  inline double GetTarget2SpecificLambda() const {return fTarget2SpecificLambda;}
  inline void SetTarget2SpecificLambda(double l) {fTarget2SpecificLambda = l;}

  inline G4String GetTarget2MaterialName() const { return fTarget2MaterialName; }
  inline void SetTarget2MaterialName(G4String &aName) { fTarget2MaterialName = aName; }

  // Rotation matrix for the 2nd module
  G4RotationMatrix* fMirrorRotation;
  // Displacement of the 2nd module along z: depends on length of 1st module
  G4double fZModuleShift;

  //
  // June 2016 : LBNF Optimize, Conceptual Design. 
  //
  inline bool GetUseLBNFOptimConceptDesignHornA() const { return fUseLBNFOptimConceptDesignHornA; }
  inline bool GetUseLBNFOptimConceptDesignHornB() const { return fUseLBNFOptimConceptDesignHornB; }
  inline bool GetUseLBNFOptimConceptDesignHornC() const { return fUseLBNFOptimConceptDesignHornC; }
  inline bool GetUseCDR2015Optimized() const { return fUseCDR2015Optimized; }
  inline double GetZShiftConceptHornAStartIC() { return fZShiftConceptHornAStartIC; } 
  inline double GetZHallHorn1ToHorn1PolyM1() { return fZHallHorn1ToHorn1PolyM1; }
  inline void SetUseLBNFOptimConceptDesignHornA(bool f) { fUseLBNFOptimConceptDesignHornA = f; }
  inline void SetUseLBNFOptimConceptDesignHornB(bool f) { fUseLBNFOptimConceptDesignHornB = f; }
  inline void SetUseLBNFOptimConceptDesignHornC(bool f) { fUseLBNFOptimConceptDesignHornC = f; }
  inline void SetUseCDR2015Optimized(bool f) { fUseCDR2015Optimized = f; }
  inline void SetZHallHorn1ToHorn1PolyM1(double d) { fZHallHorn1ToHorn1PolyM1 = d; }
  void PlaceFinalLBNFConceptHornA(); 
  void PlaceFinalLBNFConceptTgtSupport(); 
  void PlaceFinalLBNFConceptHornB(); 
  void PlaceFinalLBNFConceptStripLinesConnectHornB(); 
  void PlaceFinalLBNFConceptHornC(); 
  void PreparePolyconForConceptHornA(); 
  void PreparePolyconForConceptHornB(); 
  void PreparePolyconForConceptHornC(); 
  void PlaceFinalLBNFConceptStripLinesConnectHornC(); 
  // August 2016: give the option to remove the baffle and the horizontal target. 
  inline bool GetInstallBaffle() const { return fInstallBaffle; } 
  inline bool GetInstallUpstreamHorizontalTarget() const { return fInstallUpstreamHorizontalTarget; }
  inline void SetInstallBaffle(bool f) { fInstallBaffle=f;}
  inline void SetInstallUpstreamHorizontalTarget(bool f) { fInstallUpstreamHorizontalTarget=f;}
  inline bool GetInstallDownstTargetSupport() const { return fInstallDownstTargetSupport; }
  inline void SetInstallDownstTargetSupport(bool t) { fInstallDownstTargetSupport = t; }
  inline bool GetRemoveRALBafflet() const {return fRemoveRALBafflet; }
  inline void SetRemoveRALBafflet(bool f) {fRemoveRALBafflet=f;}
  
  inline bool GetInstallRALShortTarget() const { return fInstallRALShortTarget; } 
  inline void SetInstallRALShortTarget(bool f) { fInstallRALShortTarget=f; }
  
  inline double GetRALSimpleTargetLength()  const { return
  fRALSimpleTargetLength; }
  inline void SetRALSimpleTargetLength(double l) {fRALSimpleTargetLength=l;}
  
};

#endif