/scratch0/jsnuveri/BDSIM/BDSIMgit/bdsim/include/BDSAcceleratorComponent.hh

#ifndef __BDSACCELERATORCOMPONENT_H
#define __BDSACCELERATORCOMPONENT_H

#include "G4LogicalVolume.hh"
#include "globals.hh"          // geant4 globals / types

#include "BDSBeamPipeInfo.hh"
#include "BDSGeometryComponent.hh"
#include "BDSGlobalConstants.hh" 
#include "BDSTiltOffset.hh"

#include <vector>

class BDSAcceleratorComponent: public BDSGeometryComponent
{
public:
  BDSAcceleratorComponent(G4String         name,
                          G4double         arcLength,
                          G4double         angle,
                          G4String         type,
                          BDSTiltOffset    tiltOffset      = BDSTiltOffset(),
                          G4int            precisionRegion = 0,
                          BDSBeamPipeInfo* beamPipeInfo    = NULL);
  
  virtual ~BDSAcceleratorComponent();

  G4String GetName() const;

  G4String GetType() const;

  G4int GetPrecisionRegion() const;

  G4double GetAngle() const;

  inline BDSTiltOffset GetTiltOffset() const;
  
  virtual G4double GetArcLength()   const; // note no z length - this is chord length
  virtual G4double GetChordLength() const; // only chord OR arc makes it explicit
  
  inline G4LogicalVolume* GetReadOutLogicalVolume() const;
  
  // in case a mapped field is provided creates a field mesh in global coordinates
  virtual void PrepareField(G4VPhysicalVolume *referenceVolume); 
  
  G4double GetParameterValue      (G4String spec, G4String name) const;
  G4String GetParameterValueString(G4String spec, G4String name) const;

  friend class BDSComponentFactory;
  friend class BDSLine;
  friend class BDSDetectorConstruction;
  
  G4double         GetSPos() const; // maybe not needed due to new beamline
  void             SetSPos(G4double spos);
  void             SetGFlashVolumes(G4LogicalVolume* aLogVol);
  std::vector<G4LogicalVolume*> GetGFlashVolumes() const;
  void             SetMultiplePhysicalVolumes(G4VPhysicalVolume* aPhysVol);
  std::vector<G4VPhysicalVolume*> GetMultiplePhysicalVolumes() const;

protected:
  // can't be in constructor as calls virtual methods
  virtual void Initialise();
  
  virtual void Build();

  virtual void BuildContainerLogicalVolume() = 0;
  
  const G4String   name;
  const G4double   arcLength;
  const G4String   type;
  
  G4double         chordLength;
  G4double         angle;
  BDSTiltOffset    tiltOffset;
  G4int            precisionRegion;
  BDSBeamPipeInfo* beamPipeInfo;

  static G4double    lengthSafety;
  static G4Material* emptyMaterial;
  
private:
  BDSAcceleratorComponent();

  BDSAcceleratorComponent& operator=(const BDSAcceleratorComponent&);
  BDSAcceleratorComponent(BDSAcceleratorComponent&);
  
  G4LogicalVolume* readOutLV; 

  G4double itsSPos;

  std::vector<G4LogicalVolume*> itsGFlashVolumes;
  //A vector containing the physical volumes in the accelerator component- to be used for geometric importance sampling etc.

  // to be moved to geometry component
  std::vector<G4VPhysicalVolume*> itsMultiplePhysicalVolumes;
};

inline G4String BDSAcceleratorComponent::GetName() const
{return name;}

inline G4double BDSAcceleratorComponent::GetChordLength() const
{return chordLength;}

inline G4double BDSAcceleratorComponent::GetArcLength() const
{return arcLength;}

inline G4double BDSAcceleratorComponent::GetAngle() const
{return angle;}

inline G4String BDSAcceleratorComponent::GetType() const
{return type;}

inline G4int BDSAcceleratorComponent::GetPrecisionRegion() const
{return precisionRegion;}

inline BDSTiltOffset BDSAcceleratorComponent::GetTiltOffset() const
{return tiltOffset;}

inline G4double BDSAcceleratorComponent::GetSPos() const
{return itsSPos;}

inline void BDSAcceleratorComponent::SetSPos(G4double spos)
{itsSPos=spos;}

inline void BDSAcceleratorComponent::SetGFlashVolumes(G4LogicalVolume* aLogVol)
{itsGFlashVolumes.push_back(aLogVol);}

inline std::vector<G4LogicalVolume*> BDSAcceleratorComponent::GetGFlashVolumes() const
{return itsGFlashVolumes;}

inline void BDSAcceleratorComponent::SetMultiplePhysicalVolumes(G4VPhysicalVolume* aPhysVol)
{itsMultiplePhysicalVolumes.push_back(aPhysVol);}

inline std::vector<G4VPhysicalVolume*> BDSAcceleratorComponent::GetMultiplePhysicalVolumes() const
{return itsMultiplePhysicalVolumes;}

inline G4LogicalVolume* BDSAcceleratorComponent::GetReadOutLogicalVolume() const
{return readOutLV;}

inline  G4double BDSAcceleratorComponent::GetParameterValue(G4String spec, G4String name) const
{
  G4double value = 0;

  std::string delimiters = "&";
  std::string param = name + "=";

  int pos = spec.find(param);
  if( pos >= 0 )
    {
      int pos2 = spec.find("&",pos);
      int pos3 = spec.length();
      int tend = pos2 < 0 ? pos3 : pos2; 
      int llen = tend - pos - param.length();
      
      std::string val = spec.substr(pos + param.length(), llen);
      
      value = atof(val.c_str());
  }
  return value;
}

inline  G4String BDSAcceleratorComponent::GetParameterValueString(G4String spec, G4String name) const
{
  G4String value = "";

  std::string delimiters = "&";
  std::string param = name + "=";

  int pos = spec.find(param);
  if( pos >= 0 )
    {
      int pos2 = spec.find("&",pos);
      int pos3 = spec.length();
      int tend = pos2 < 0 ? pos3 : pos2; 
      int llen = tend - pos - param.length();
      
      value = spec.substr(pos + param.length(), llen);
    }
  return value;
}

#endif

---