IFactory.h

Go to the documentation of this file.

// $Id$
 
// -----------------------------------------------------------------------
// The VGM package of the Virtual Geometry Model
// Copyright (C) 2007, Ivana Hrivnacova
// All rights reserved.
//
// For the licensing terms see vgm/LICENSE.
// Contact: ivana@ipno.in2p3.fr
// -----------------------------------------------------------------------
 
//
 
#ifndef VGM_I_FACTORY_H
#define VGM_I_FACTORY_H
 
#include "VGM/common/Axis.h"
#include "VGM/common/ThreeVector.h"
#include "VGM/common/Transform.h"
#include "VGM/common/TwoVector.h"
 
#include <string>
#include <vector>
 
 
namespace VGM {
 
class ISolid;
class IVolume;
class IPlacement;
class IMaterialFactory;
class IExtrudedSolid;
 
typedef std::vector<ISolid*> SolidStore;
typedef std::vector<IVolume*> VolumeStore;
 
constexpr double kDefaultDummyBoxDimensions = 1.; // in mm
 
class IFactory
{
 public:
  virtual ~IFactory() {}
 
  //
  // solids
  //
 
  virtual ISolid* CreateArb8(const std::string& name, double hz,
    std::vector<VGM::TwoVector> vertices) = 0;
 
  virtual ISolid* CreateBox(
    const std::string& name, double hx, double hy, double hz) = 0;
 
  virtual ISolid* CreateCons(const std::string& name, double rin1, double rout1,
    double rin2, double rout2, double hz, double sphi, double dphi) = 0;
 
  virtual ISolid* CreateCtubs(const std::string& name, double rin, double rout,
    double hz, double sphi, double dphi, double nxlow, double nylow,
    double nzlow, double nxhigh, double nyhigh, double nzhigh) = 0;
 
  virtual ISolid* CreateEllipsoid(const std::string& name, double dx, double dy,
    double dz, double zBottomCut, double zTopCut) = 0;
 
  virtual ISolid* CreateEllipticalTube(
    const std::string& name, double dx, double dy, double hz) = 0;
 
  virtual ISolid* CreateExtrudedSolid(const std::string& name,
    std::vector<TwoVector> polygon,
    std::vector<std::vector<double> > zsections) = 0;
 
  virtual ISolid* CreateHype(const std::string& name, double r1, double r2,
    double stereo1, double stereo2, double hz) = 0;
 
  virtual ISolid* CreatePara(const std::string& name, double hx, double hy,
    double hz, double alpha, double theta, double phi) = 0;
 
  virtual ISolid* CreateParaboloid(
    const std::string& name, double r1, double r2, double hz) = 0;
 
  virtual ISolid* CreatePolycone(const std::string& name, double sphi,
    double dphi, int nofZplanes, double* z, double* rin, double* rout) = 0;
 
  virtual ISolid* CreatePolyhedra(const std::string& name, double sphi,
    double dphi, int nofSides, int nofZplanes, double* z, double* rin,
    double* rout) = 0;
 
  virtual ISolid* CreateSphere(const std::string& name, double rin, double rout,
    double sphi, double dphi, double stheta, double dtheta) = 0;
 
  virtual ISolid* CreateTessellatedSolid(const std::string& name,
    std::vector<std::vector<VGM::ThreeVector> > facets) = 0;
 
  virtual ISolid* CreateTorus(const std::string& name, double rin, double rout,
    double rax, double sphi, double dphi) = 0;
 
  virtual ISolid* CreateTrap(const std::string& name, double hz, double theta,
    double phi, double dy1, double dx1, double dx2, double alpha1, double dy2,
    double dx3, double dx4, double alpha2) = 0;
 
  virtual ISolid* CreateTrd(const std::string& name, double hx1, double hx2,
    double hy1, double hy2, double hz) = 0;
 
  virtual ISolid* CreateTubs(const std::string& name, double rin, double rout,
    double hz, double sphi, double dphi) = 0;
 
  //
  // Boolean solids
  //
 
  virtual ISolid* CreateIntersectionSolid(const std::string& name,
    VGM::ISolid* solidA, VGM::ISolid* solidB,
    const VGM::Transform& transform) = 0;
 
  virtual ISolid* CreateSubtractionSolid(const std::string& name,
    VGM::ISolid* solidA, VGM::ISolid* solidB,
    const VGM::Transform& transform) = 0;
 
  virtual ISolid* CreateUnionSolid(const std::string& name, VGM::ISolid* solidA,
    VGM::ISolid* solidB, const VGM::Transform& transform) = 0;
 
  virtual ISolid* CreateDisplacedSolid(const std::string& name,
    VGM::ISolid* solid, const VGM::Transform& transform) = 0;
 
  virtual ISolid* CreateScaledSolid(const std::string& name, VGM::ISolid* solid,
    const VGM::Transform& transform) = 0;
 
  virtual ISolid* CreateMultiUnion(const std::string& name,
    std::vector<VGM::ISolid*> constituents,
    std::vector<VGM::Transform> transforms) = 0;
 
  //
  // volumes
  //
 
  virtual IVolume* CreateVolume(const std::string& name, VGM::ISolid* solid,
    const std::string& mediumName) = 0;
 
  //
  // placements
  //
 
  virtual IPlacement* CreatePlacement(const std::string& name, int copyNo,
    VGM::IVolume* volume, VGM::IVolume* motherVolume,
    const VGM::Transform& transform) = 0;
 
  virtual IPlacement* CreateMultiplePlacement(const std::string& name,
    VGM::IVolume* volume, VGM::IVolume* motherVolume, VGM::Axis axis,
    int nofItems, double width, double offset, double halfGap) = 0;
 
  // TO DO: IVolume* volume parameter is redundant;
  // IVolume and ISolid should be created automatically
  // via factory; this is however not available in
  // Geant4 now (it would have to be done on the VGM level)
  // - should be possible with G4Division class, so lets wait
  // for it
 
  virtual VGM::IPlacement* CreateParameterisedPlacement(const std::string& name,
    VGM::IVolume* motherVolume,
    const std::vector<VGM::Transform>& transforms,
    const std::vector<VGM::IVolume*>& volumes) = 0;
 
  // top volume
  //
  virtual IPlacement* Top() const = 0;
  virtual ISolid* SingleSolid() const = 0;
 
  //
  // access
  //
  virtual std::string Name() const = 0;
 
  virtual const SolidStore& Solids() const = 0;
  virtual const VolumeStore& Volumes() const = 0;
  virtual IMaterialFactory* MaterialFactory() const = 0;
 
  //
  // listings
  //
  virtual void PrintSolids() const = 0;
  virtual void PrintVolumes() const = 0;
 
  //
  // export
  //
  virtual bool Export(IFactory* factory) const = 0;
 
  //
  // debug
  //
  virtual void SetDebug(int value) = 0;
  virtual int Debug() const = 0;
 
  //
  // options
  //
  virtual void SetIgnore(
    bool value, double dummyBoxDimensions = kDefaultDummyBoxDimensions) = 0;
  virtual bool Ignore() const = 0;
 
  virtual void SetDummyBoxDimensions(double value) = 0;
  virtual double DummyBoxDimensions() const = 0;
 
  virtual void SetBestMatch(bool value) = 0;
  virtual bool BestMatch() const = 0;
 
  virtual void SetSingleMode(bool value) = 0;
  virtual bool SingleMode() const = 0;
 
  virtual void SetSolid(VGM::ISolid* solid) = 0;
 
 private:
  //
  // import
  //
  virtual bool Import(void* /*topVolume*/) = 0;
  virtual bool ImportSolid(void* /*solid*/) = 0;
};
 
} // namespace VGM
 
#endif // VGM_I_FACTORY_H