ForwardRegionGeoModelFactory Class Reference

#include <ForwardRegionGeoModelFactory.h>

Inheritance diagram for ForwardRegionGeoModelFactory:

Collaboration diagram for ForwardRegionGeoModelFactory:

Public Member Functions
	ForwardRegionGeoModelFactory (StoreGateSvc *pDetStore, const PFWD_CONFIGURATION pConfig)
	~ForwardRegionGeoModelFactory ()
virtual void	create (GeoPhysVol *world)
virtual const ForwardRegionGeoModelManager *	getDetectorManager () const

Private Member Functions
void	DefineMaterials ()
void	constructElements (GeoPhysVol *fwrPhys, std::vector< std::vector< std::string > > loadedDataFile, int beam)
GeoPhysVol *	insertMagnetEnvelope (const std::string &name, double x, double y, double z, double rotationAngle, double diameter, double halfL, double dL, GeoPhysVol *fwrPhys)
void	insertCircularElement (const std::string &name, double x, double y, double z, double rotationAngle, double xAperture, double yAperture, double halfL, double dL, double tubeThickness, GeoPhysVol *fwrPhys)
void	insertEllipticalElement (const std::string &name, double x, double y, double z, double rotationAngle, double xAperture, double yAperture, double halfL, double dL, double tubeThickness, GeoPhysVol *fwrPhys)
void	insertXRecticircularElement (const std::string &name, double x, double y, double z, double rotationAngle, double xAperture, double yAperture, double halfL, double dL, double tubeThickness, GeoPhysVol *fwrPhys)
void	insertYRecticircularElement (const std::string &name, double x, double y, double z, double rotationAngle, double xAperture, double yAperture, double halfL, double dL, double tubeThickness, GeoPhysVol *fwrPhys)
void	insertTrousersElement (const std::string &name, double x, double y, double z, double rotationAngle, GeoPhysVol *fwrPhys)
void	insertTCLElement (const std::string &name, double x, double y, double z, GeoPhysVol *fwrPhys, double TCLJawDistO, double TCLJawDistI, bool tungstenInsteadOfCopper=false)
std::vector< std::vector< std::string > >	loadDataFile (const std::string &fileName, int cols)
template<class T>
std::string	num2str (T)
template<typename T>
int	sgn (T val)
const ForwardRegionGeoModelFactory &	operator= (const ForwardRegionGeoModelFactory &right)
	ForwardRegionGeoModelFactory (const ForwardRegionGeoModelFactory &right)

Private Attributes
StoreGateSvc *	m_detectorStore
std::map< std::string, const GeoMaterial * >	m_MapMaterials
FWD_CONFIGURATION	m_Config
FWDMg_CONFIGURATION	m_MagConfig
ToolHandle< IForwardRegionProperties >	m_properties
ForwardRegionGeoModelManager *	m_detectorManager

Detailed Description

Definition at line 49 of file ForwardRegionGeoModelFactory.h.

Constructor & Destructor Documentation

ForwardRegionGeoModelFactory() [1/2]

ForwardRegionGeoModelFactory::ForwardRegionGeoModelFactory	(	StoreGateSvc *	pDetStore,
		const PFWD_CONFIGURATION	pConfig )

Definition at line 61 of file ForwardRegionGeoModelFactory.cxx.

  :m_detectorStore(detStore),
   m_properties("ForwardRegionProperties")
{
    m_detectorManager = NULL;
    MsgStream LogStream(Athena::getMessageSvc(), "ForwardRegionGeoModel::ForwardRegionGeoModel()");
 
    m_Config = *pConfig;
 
    if(m_properties.retrieve().isFailure()){
        LogStream << MSG::ERROR << ": Failed to load magnet properties" << endmsg;
        return;
    }
 
    m_MagConfig = *(m_properties->getConf());
}

~ForwardRegionGeoModelFactory()

ForwardRegionGeoModelFactory::~ForwardRegionGeoModelFactory

(

)

Definition at line 79 of file ForwardRegionGeoModelFactory.cxx.

{
 
}

ForwardRegionGeoModelFactory() [2/2]

ForwardRegionGeoModelFactory::ForwardRegionGeoModelFactory ( const ForwardRegionGeoModelFactory & right )

private

Member Function Documentation

constructElements()

void ForwardRegionGeoModelFactory::constructElements ( GeoPhysVol * fwrPhys, std::vector< std::vector< std::string > > loadedDataFile, int beam )

private

Definition at line 211 of file ForwardRegionGeoModelFactory.cxx.

{
    //-------------------------------------------------------------------------------------
    // Construction of geometry from geometry file
 
    // indexes
    int name, zStart, zEnd, type, xAperture, yAperture, xStart, xEnd, yStart, yEnd, tubeThickness;
    name = 0;
    type = 1;
    zStart = 4;
    zEnd = 5;
    xAperture = 2;
    yAperture = 3;
    xStart = 6;
    xEnd = 7;
    yStart = 8;
    yEnd = 9;
    tubeThickness = 10;
 
    int lDFSize = loadedDataFile.size();
 
    // apply shifts of magnets defined by magnets properties in JO
    for(int i=0; i < lDFSize; i++)
    {
        // get start and end points defined in JO
        HepGeom::Point3D<double> pointMagStart;
        HepGeom::Point3D<double> pointMagEnd;
        if(m_properties.retrieve().isSuccess()) m_properties->getMagTransforms(loadedDataFile[i][name],beam,pointMagStart,pointMagEnd);
 
        // are points defined (non-zero)? If not, shifts will not apply
        bool pointsDefined = !(pointMagStart.distance2() == 0 || pointMagEnd.distance2() == 0);
 
        if(pointsDefined)
        {
 
            // overlap correction for x rotation
            double startZ = pointMagStart[2];
            double endZ   = pointMagEnd[2];
            double startX = pointMagStart[0];
            double endX   = pointMagEnd[0];
            double rotationAngle = atan2(endX - startX,endZ - startZ);
            double r = atof(loadedDataFile[i][xAperture].c_str())*Gaudi::Units::mm/2;
            double dL = abs(r*tan(rotationAngle))+0.2*Gaudi::Units::mm;
 
 
            // move start and end points of the magnet element and neighbour elemens accordingly
            // move (resize) neighbours only in z (needed to avoid overlaps)
            loadedDataFile[i][xStart] = num2str(pointMagStart[0]/1000);
            loadedDataFile[i][yStart] = num2str(pointMagStart[1]/1000);
            loadedDataFile[i][zStart] = num2str(pointMagStart[2]/1000);
            loadedDataFile[i-1][zEnd] = num2str(sgn(pointMagStart[2])*(abs(pointMagStart[2])-dL)/1000);
 
            loadedDataFile[i][xEnd] = num2str(pointMagEnd[0]/1000);
            loadedDataFile[i][yEnd] = num2str(pointMagEnd[1]/1000);
            loadedDataFile[i+1][zStart] = num2str(sgn(pointMagEnd[2])*(abs(pointMagEnd[2])+dL)/1000);
            loadedDataFile[i][zEnd] = num2str(pointMagEnd[2]/1000);
 
        }
    }
 
    double x,y,z,halfL,rotationAngle,r,dL,startZ,endZ,startX,endX,startY,endY;
 
    // ################ ELEMENTS ############################
 
    // --------------- elements cycle -----------------
    for(int i=0; i < lDFSize; i++)
    {
        startZ = atof(loadedDataFile[i][zStart].c_str())*Gaudi::Units::m;
        endZ   = atof(loadedDataFile[i][zEnd].c_str())*Gaudi::Units::m;
        startX = atof(loadedDataFile[i][xStart].c_str())*Gaudi::Units::m;
        endX   = atof(loadedDataFile[i][xEnd].c_str())*Gaudi::Units::m;
        startY = atof(loadedDataFile[i][yStart].c_str())*Gaudi::Units::m;
        endY   = atof(loadedDataFile[i][yEnd].c_str())*Gaudi::Units::m;
 
        // translation of element
        x = (startX + endX)/2;
        y = (startY + endY)/2;
        z = (startZ + endZ)/2;
 
        // absolute rotation of element
        //rotationAngle_old = rotationAngle;
        rotationAngle = atan2(endX - startX,endZ - startZ);
 
        // half-length of element
        halfL = sqrt((endX - startX)*(endX - startX) + (endZ - startZ)*(endZ - startZ))/2;
 
        r = atof(loadedDataFile[i][xAperture].c_str())*Gaudi::Units::mm/2;
 
        // overlap correction
        dL = abs(r*tan(rotationAngle))+0.2*Gaudi::Units::mm;
 
        // do not shorten magnetic volumes
        if(loadedDataFile[i][name].find("Mag") != std::string::npos)
            dL = 0;
 
        // construction of element
 
        // circular aperture
        if(atoi(loadedDataFile[i][type].c_str()) == 0){
            // envelope to allow tracking with G4TrackAction
            if(loadedDataFile[i][name] == "VCDBP.7R1.B"){
                GeoPhysVol* trackEnv = insertMagnetEnvelope(loadedDataFile[i][name], x, y, z, rotationAngle, 100*Gaudi::Units::mm, halfL, dL, fwrPhys);
                insertCircularElement(loadedDataFile[i][name], x, y, z, rotationAngle, atof(loadedDataFile[i][xAperture].c_str()), atof(loadedDataFile[i][yAperture].c_str()), halfL, dL, atof(loadedDataFile[i][tubeThickness].c_str()), trackEnv);
            }
            else
              insertCircularElement(loadedDataFile[i][name], x, y, z, rotationAngle, atof(loadedDataFile[i][xAperture].c_str()), atof(loadedDataFile[i][yAperture].c_str()), halfL, dL, atof(loadedDataFile[i][tubeThickness].c_str()), fwrPhys);
        }
 
        // special volumes
        if(atoi(loadedDataFile[i][type].c_str()) == 4){
            if(loadedDataFile[i][name] == "VCTYF.A4R1.X") // Trousers -- transition from 1 to 2 beampipes
                insertTrousersElement(loadedDataFile[i][name], x, y, z, rotationAngle, fwrPhys);
            else if(loadedDataFile[i][name] == "TCL.5R1.B1") // TCL5 collimator
                insertTCLElement(loadedDataFile[i][name], x, y, z, fwrPhys, (beam == 1 ? m_Config.TCL5JawDistB1O : m_Config.TCL5JawDistB2O), (beam == 1 ? m_Config.TCL5JawDistB1I : m_Config.TCL5JawDistB2I));
            else if(m_Config.buildTCL4 && loadedDataFile[i][name] == "VCDSS.4R1.B") // TCL4 collimator
                insertTCLElement(loadedDataFile[i][name], x, y, z, fwrPhys, (beam == 1 ? m_Config.TCL4JawDistB1O : m_Config.TCL4JawDistB2O), (beam == 1 ? m_Config.TCL4JawDistB1I : m_Config.TCL4JawDistB2I));
            else if(m_Config.buildTCL6 && loadedDataFile[i][name] == "TCL6") // TCL6 collimator
                insertTCLElement(loadedDataFile[i][name], x, y, z, fwrPhys, (beam == 1 ? m_Config.TCL6JawDistB1O : m_Config.TCL6JawDistB2O), (beam == 1 ? m_Config.TCL6JawDistB1I : m_Config.TCL6JawDistB2I), true);
 
            // aproximate rest by circular apperture
            else
                insertCircularElement(loadedDataFile[i][name], x, y, z, rotationAngle, atof(loadedDataFile[i][xAperture].c_str()), atof(loadedDataFile[i][yAperture].c_str()), halfL, dL, atof(loadedDataFile[i][tubeThickness].c_str()), fwrPhys);
        }
 
        GeoPhysVol* magEnv;
 
        // elliptical aperture
        if(atoi(loadedDataFile[i][type].c_str()) == 1) {
            magEnv = insertMagnetEnvelope(loadedDataFile[i][name], x, y, z, rotationAngle, 20*Gaudi::Units::cm, halfL, dL, fwrPhys);
            insertEllipticalElement(loadedDataFile[i][name], x, y, z, rotationAngle, atof(loadedDataFile[i][xAperture].c_str()), atof(loadedDataFile[i][yAperture].c_str()), halfL, dL, atof(loadedDataFile[i][tubeThickness].c_str()), magEnv);
        }
 
 
        double magDiam = 19.4*Gaudi::Units::cm;
        if(loadedDataFile[i][name].find("Mag") != std::string::npos)
            magDiam= 19.4*Gaudi::Units::cm;
        if(loadedDataFile[i][name] == "LQXAA.1R1MagQ1" || loadedDataFile[i][name] == "LQXAG.3R1MagQ3")
            magDiam = 48*Gaudi::Units::cm;
        if(loadedDataFile[i][name] == "LQXBA.2R1MagQ2a" || loadedDataFile[i][name] == "LQXBA.2R1MagQ2b")
            magDiam = 52*Gaudi::Units::cm;
        //else magDiam = std::max(atof(loadedDataFile[i][xAperture].c_str()), atof(loadedDataFile[i][yAperture].c_str()))+2*atof(loadedDataFile[i][tubeThickness].c_str());
        //else magDiam = 19.4*Gaudi::Units::cm;
 
        // rectcircular aperture with flats in x
        if(atoi(loadedDataFile[i][type].c_str()) == 2) {
            magEnv = insertMagnetEnvelope(loadedDataFile[i][name], x, y, z, rotationAngle, magDiam, halfL, dL, fwrPhys);
            insertXRecticircularElement(loadedDataFile[i][name], x, y, z, rotationAngle, atof(loadedDataFile[i][xAperture].c_str()), atof(loadedDataFile[i][yAperture].c_str()), halfL, dL, atof(loadedDataFile[i][tubeThickness].c_str()), magEnv);
        }
 
        // rectcircular aperture with flats in y
        if(atoi(loadedDataFile[i][type].c_str()) == 3) {
            magEnv = insertMagnetEnvelope(loadedDataFile[i][name], x, y, z, rotationAngle, magDiam, halfL, dL, fwrPhys);
            insertYRecticircularElement(loadedDataFile[i][name], x, y, z, rotationAngle, atof(loadedDataFile[i][xAperture].c_str()), atof(loadedDataFile[i][yAperture].c_str()), halfL, dL, atof(loadedDataFile[i][tubeThickness].c_str()), magEnv);
        }
    }
    // ################ ELEMENTS - end ########################
}

create()

void ForwardRegionGeoModelFactory::create ( GeoPhysVol * world )

virtual

Definition at line 370 of file ForwardRegionGeoModelFactory.cxx.

{
  m_detectorManager=new ForwardRegionGeoModelManager();
 
  MsgStream LogStream(Athena::getMessageSvc(), "ForwardRegionGeoModel::create()");
 
  LogStream << MSG::INFO << "Constructing forward region model" << endmsg;
 
  DefineMaterials();
 
  // Load "geometry" files
  std::vector<std::vector<std::string> > loadedDataFileR = this->loadDataFile("ForwardRegionGeoModel/LSS1Rout.csv",11);
  std::vector<std::vector<std::string> > loadedDataFileL = this->loadDataFile("ForwardRegionGeoModel/LSS1Lout.csv",11);
 
  double startZ,endZ;
 
  if(m_Config.vp1Compatibility) startZ = 19.0*Gaudi::Units::m;
  else startZ = 22.0*Gaudi::Units::m;
  endZ = 268.904*Gaudi::Units::m;
 
  //rotationAngle_old = 0;
 
  // mother volume -- union of tubes, one for each side
  //const GeoBox      *fwrBox    = new GeoBox(2*Gaudi::Units::m,0.5*Gaudi::Units::m,(endZ-startZ)/2);
  const GeoTube     *fwrTubeL    = new GeoTube(0,2*Gaudi::Units::m,(endZ-startZ)/2);
  GeoTube     *fwrTubeR    = new GeoTube(0,2*Gaudi::Units::m,(endZ-startZ)/2);
  GeoTrf::Transform3D shiftL = GeoTrf::Translate3D(0,0,(endZ+startZ)/2);
  GeoTrf::Transform3D shiftR = GeoTrf::Translate3D(0,0,-(endZ+startZ)/2);
 
  const GeoShapeShift& fwrTube0 = (*fwrTubeL)<<shiftL;
  const GeoShapeUnion& fwrTube1 = fwrTube0.add((*fwrTubeR)<<shiftR);
 
  // cut out slots for ALFA
  const GeoTube     *alfa    = new GeoTube(0, 2*Gaudi::Units::m, 500*Gaudi::Units::mm);
  GeoTrf::Transform3D shiftAlfaL1 = GeoTrf::Translate3D(0,0,237388*Gaudi::Units::mm);
  GeoTrf::Transform3D shiftAlfaR1 = GeoTrf::Translate3D(0,0,-237408*Gaudi::Units::mm);
  GeoTrf::Transform3D shiftAlfaL2 = GeoTrf::Translate3D(0,0,(m_Config.ALFAInNewPosition ? m_Config.newPosB7L1 : 241528*Gaudi::Units::mm));
  GeoTrf::Transform3D shiftAlfaR2 = GeoTrf::Translate3D(0,0,(m_Config.ALFAInNewPosition ? m_Config.newPosB7R1 :-241548*Gaudi::Units::mm));
  const GeoShapeSubtraction& fwrTube2 = fwrTube1.subtract((*alfa)<<shiftAlfaL1).subtract((*alfa)<<shiftAlfaL2).subtract((*alfa)<<shiftAlfaR1).subtract((*alfa)<<shiftAlfaR2);
 
  // cut out slots for AFP
  const GeoTube     *afp    = new GeoTube(0, 2.5*Gaudi::Units::m, 280*Gaudi::Units::mm);
  const GeoTube     *afp2    = new GeoTube(0, 2.5*Gaudi::Units::m, 580*Gaudi::Units::mm);
  GeoTrf::Transform3D shiftAfpL1 = GeoTrf::Translate3D(0,0,m_Config.posAFPL1);
  GeoTrf::Transform3D shiftAfpR1 = GeoTrf::Translate3D(0,0,m_Config.posAFPR1);
  GeoTrf::Transform3D shiftAfpL2 = GeoTrf::Translate3D(0,0,m_Config.posAFPL2);
  GeoTrf::Transform3D shiftAfpR2 = GeoTrf::Translate3D(0,0,m_Config.posAFPR2);
  const GeoShapeSubtraction& fwrTube3 = fwrTube2.subtract((*afp)<<shiftAfpL1).subtract((*afp)<<shiftAfpR1).subtract((*afp2)<<shiftAfpL2).subtract((*afp2)<<shiftAfpR2);
 
  // cut out slots for ZDC
  const GeoBox     *zdc    = new GeoBox( 9.1*Gaudi::Units::cm/2.0 ,18.1*Gaudi::Units::cm/2.0  , 94.4*Gaudi::Units::cm/2.0);
  GeoTrf::Transform3D shiftZdcL1 = GeoTrf::Translate3D(0,0, m_Config.posZDC1);
  GeoTrf::Transform3D shiftZdcR1 = GeoTrf::Translate3D(0,0, m_Config.posZDC2);
  const GeoShapeSubtraction& fwrTube = fwrTube3.subtract((*zdc)<<shiftZdcL1).subtract((*zdc)<<shiftZdcR1);
 
 
  const GeoLogVol   *fwrLog    = new GeoLogVol("ForwardRegionGeoModel", &fwrTube, m_MapMaterials[std::string("std::Vacuum")]);
  GeoPhysVol        *fwrPhys   = new GeoPhysVol(fwrLog);
  GeoNameTag *tag = new GeoNameTag("ForwardRegionGeoModel");
  world->add(tag);
  world->add(fwrPhys);
  m_detectorManager->addTreeTop(fwrPhys);
 
  constructElements(fwrPhys,std::move(loadedDataFileR),1);
  constructElements(fwrPhys,std::move(loadedDataFileL),2);
 
  LogStream << MSG::INFO << "Forward region model succesfully constructed." << endmsg;
}

DefineMaterials()

void ForwardRegionGeoModelFactory::DefineMaterials ( )

private

Definition at line 85 of file ForwardRegionGeoModelFactory.cxx.

{
    std::string matName;
 
    StoredMaterialManager* materialManager = nullptr;
    if (StatusCode::SUCCESS != m_detectorStore->retrieve(materialManager, std::string("MATERIALS"))) {
      return;
    }
 
 
    //-----------------------------------------------------------------------------------//
    // Get the materials that we shall use.                                              //
    // ----------------------------------------------------------------------------------//
 
    // vacuum
    matName = "std::Vacuum";
    const GeoMaterial *vacuum = materialManager->getMaterial(matName);
    m_MapMaterials.emplace(matName,vacuum);
 
    // water
    matName = "water";
    GeoMaterial *water = new GeoMaterial("H20", 1.0*GeoModelKernelUnits::gram/Gaudi::Units::cm3);
    GeoElement *hydrogen = new GeoElement("Hydrogen","H",1.0, 1.010);
    GeoElement *oxygen   = new GeoElement("Oxygen",  "O", 8.0, 16.0);
    water->add(hydrogen,0.11);
    water->add(oxygen,0.89);
    water->lock();
    m_MapMaterials.emplace(matName,water);
 
    // elements
    const GeoElement* C  = materialManager->getElement("Carbon");
    const GeoElement* N  = materialManager->getElement("Nitrogen");
    const GeoElement* Si = materialManager->getElement("Silicon");
    const GeoElement* P  = materialManager->getElement("Phosphorus");
    const GeoElement* S  = materialManager->getElement("Sulfur");
    const GeoElement* Cr = materialManager->getElement("Chromium");
    const GeoElement* Mn = materialManager->getElement("Manganese");
    const GeoElement* Fe = materialManager->getElement("Iron");
    const GeoElement* Ni = materialManager->getElement("Nickel");
    const GeoElement* Mo = materialManager->getElement("Molybdenum");
    const GeoElement* Cu = materialManager->getElement("Copper");
 
 
    const GeoElement* Al  = materialManager->getElement("Aluminium");
    const GeoElement* B  = materialManager->getElement("Boron");
    const GeoElement* O  = materialManager->getElement("Oxygen");
 
    // Copper for beam screens
    matName = "Copper";
    GeoMaterial *copper = new GeoMaterial("Copper", 8.94*GeoModelKernelUnits::g/Gaudi::Units::cm3);
    copper->add(const_cast<GeoElement*> (Cu),1.0);
    copper->lock();
    m_MapMaterials.insert(std::pair<std::string,GeoMaterial*>(matName,copper));
 
    // Tungsten for TCL6
    matName = "Tungsten";
    const GeoElement* W = materialManager->getElement("Wolfram");
    GeoMaterial *tungsten = new GeoMaterial("Tungsten", 19.25*GeoModelKernelUnits::g/Gaudi::Units::cm3);
    tungsten->add(const_cast<GeoElement*> (W),1.0);
    tungsten->lock();
    m_MapMaterials.insert(std::pair<std::string,GeoMaterial*>(matName,tungsten));
 
    // GlidCop AL15 copper -- aproximate composition (trace impurities (< 0.01 wt. %) not included)
    // source: http://www-ferp.ucsd.edu/LIB/PROPS/compcu15.html
    matName = "GlidCopAL15";
    GeoMaterial *glidcop=new GeoMaterial("GlidCopAL15", 8.90*GeoModelKernelUnits::g/Gaudi::Units::cm3);
 
    double aCu, aAl, aO, aB, aTot;
 
    aCu=99.7*Cu->getA()/(GeoModelKernelUnits::g/Gaudi::Units::mole);
    aAl=0.15*Al->getA()/(GeoModelKernelUnits::g/Gaudi::Units::mole);
    aO=0.13*O->getA()/(GeoModelKernelUnits::g/Gaudi::Units::mole);
    aB=0.02*B->getA()/(GeoModelKernelUnits::g/Gaudi::Units::mole);
    aTot=aCu+aAl+aO+aB;
 
    glidcop->add(const_cast<GeoElement*> (Cu), aCu/aTot);
    glidcop->add(const_cast<GeoElement*> (Al),  aAl/aTot);
    glidcop->add(const_cast<GeoElement*> (O), aO/aTot);
    glidcop->add(const_cast<GeoElement*> (B), aB/aTot);
    glidcop->lock();
    m_MapMaterials.insert(std::pair<std::string,GeoMaterial*>(matName,glidcop));
 
    // Steel Grade 316L (Roman Pot)
    matName = "Steel";
    GeoMaterial *steel=new GeoMaterial("Steel", 8*GeoModelKernelUnits::g/Gaudi::Units::cm3);
 
    double aC,aN,aSi,aP,aS,aCr,aMn,aFe,aNi,aMo,Atot;
 
    aFe=62.045*Fe->getA()/(GeoModelKernelUnits::g/Gaudi::Units::mole);
    aC =0.03*C ->getA()/(GeoModelKernelUnits::g/Gaudi::Units::mole);
    aMn=2.0*Mn ->getA()/(GeoModelKernelUnits::g/Gaudi::Units::mole);
    aSi=0.75*Si->getA()/(GeoModelKernelUnits::g/Gaudi::Units::mole);
    aP =0.045*P->getA()/(GeoModelKernelUnits::g/Gaudi::Units::mole);
    aS =0.03*S ->getA()/(GeoModelKernelUnits::g/Gaudi::Units::mole);
    aCr=18.0*Cr->getA()/(GeoModelKernelUnits::g/Gaudi::Units::mole);
    aMo=3.0*Mo ->getA()/(GeoModelKernelUnits::g/Gaudi::Units::mole);
    aNi=14.0*Ni->getA()/(GeoModelKernelUnits::g/Gaudi::Units::mole);
    aN =0.10*N ->getA()/(GeoModelKernelUnits::g/Gaudi::Units::mole);
    Atot=aFe+aC+aMn+aSi+aP+aS+aCr+aMo+aNi+aN;
 
    steel->add(const_cast<GeoElement*> (Fe),aFe/Atot);
    steel->add(const_cast<GeoElement*> (C),  aC/Atot);
    steel->add(const_cast<GeoElement*> (Mn),aMn/Atot);
    steel->add(const_cast<GeoElement*> (Si),aSi/Atot);
    steel->add(const_cast<GeoElement*> (P),  aP/Atot);
    steel->add(const_cast<GeoElement*> (S),  aS/Atot);
    steel->add(const_cast<GeoElement*> (Cr),aCr/Atot);
    steel->add(const_cast<GeoElement*> (Mo),aMo/Atot);
    steel->add(const_cast<GeoElement*> (Ni),aNi/Atot);
    steel->add(const_cast<GeoElement*> (N),  aN/Atot);
    steel->lock();
    m_MapMaterials.insert(std::pair<std::string,GeoMaterial*>(matName,steel));
}

getDetectorManager()

const ForwardRegionGeoModelManager * ForwardRegionGeoModelFactory::getDetectorManager ( ) const

virtual

Definition at line 439 of file ForwardRegionGeoModelFactory.cxx.

{
  return m_detectorManager;
}

insertCircularElement()

void ForwardRegionGeoModelFactory::insertCircularElement ( const std::string & name, double x, double y, double z, double rotationAngle, double xAperture, double yAperture, double halfL, double dL, double tubeThickness, GeoPhysVol * fwrPhys )

private

Definition at line 49 of file ForwardRegionGeoModelElements.cxx.

{
    double r0 = std::max(xAperture,yAperture)*Gaudi::Units::mm/2;
 
    const GeoTube     *ringTube  = new GeoTube(r0, r0+tubeThickness, halfL-dL);
 
    const GeoLogVol   *ringLog  = new  GeoLogVol(name+"Log", ringTube, m_MapMaterials[std::string("Steel")]);
 
    GeoPhysVol        *ringPhys = new GeoPhysVol(ringLog);
 
    //create rotation and traslation and add them to the tree of volumes of the world (move and rotate the volume)
    GeoTransform *move           = new GeoTransform(GeoTrf::Translate3D(x,y,z));
    fwrPhys->add(move);
    GeoTransform *rotate         = new GeoTransform(GeoTrf::RotateY3D(rotationAngle));
    fwrPhys->add(rotate);
 
    GeoNameTag *tag = new GeoNameTag(name);
    fwrPhys->add(tag);
 
    fwrPhys->add(ringPhys);
 
//    // The other side of the forward region may be obtained by rotation
//    GeoTransform *rotateX180  = new GeoTransform(GeoTrf::RotateX3D(180*Gaudi::Units::deg));
 
//    // the other side
//    fwrPhys->add(rotateX180);
//    fwrPhys->add(move);
//    fwrPhys->add(rotate);
//    tag = new GeoNameTag(name+"_L");
//    fwrPhys->add(tag);
//    fwrPhys->add(ringPhys);
}

insertEllipticalElement()

void ForwardRegionGeoModelFactory::insertEllipticalElement ( const std::string & name, double x, double y, double z, double rotationAngle, double xAperture, double yAperture, double halfL, double dL, double tubeThickness, GeoPhysVol * fwrPhys )

private

Definition at line 82 of file ForwardRegionGeoModelElements.cxx.

{
    const GeoShape * ringTube0;
    GeoShape * ringTube2;
 
    // GeoEllipticalTube causes VP1 to fall, so for visualization GeoBox is used
    if(!m_Config.vp1Compatibility) {
        ringTube0  = new GeoEllipticalTube(xAperture*Gaudi::Units::mm/2+tubeThickness, yAperture*Gaudi::Units::mm/2+tubeThickness, halfL-dL);
        ringTube2  = new GeoEllipticalTube(xAperture*Gaudi::Units::mm/2, yAperture*Gaudi::Units::mm/2, halfL-dL);
    }
    else {
        ringTube0  = new GeoBox(xAperture*Gaudi::Units::mm/2+tubeThickness, yAperture*Gaudi::Units::mm/2+tubeThickness, halfL-dL);
        ringTube2  = new GeoBox(xAperture*Gaudi::Units::mm/2, yAperture*Gaudi::Units::mm/2, halfL-dL);
    }
    GeoShapeSubtraction * ringTube = new GeoShapeSubtraction(ringTube0, ringTube2);
 
    const GeoLogVol   *ringLog  = new  GeoLogVol(name+"Log", ringTube, m_MapMaterials[std::string("Steel")]);
 
    GeoPhysVol        *ringPhys = new GeoPhysVol(ringLog);
 
    //create rotation and traslation and add them to the tree of volumes of the world (move and rotate the volume)
    GeoTransform *move           = new GeoTransform(GeoTrf::Translate3D(x,y,z));
    fwrPhys->add(move);
    GeoTransform *rotate         = new GeoTransform(GeoTrf::RotateY3D(rotationAngle));
    fwrPhys->add(rotate);
 
    GeoNameTag *tag = new GeoNameTag(name);
    fwrPhys->add(tag);
 
    fwrPhys->add(ringPhys);
 
//    // The other side of the forward region may be obtained by rotation
//    GeoTransform *rotateX180  = new GeoTransform(GeoTrf::RotateX3D(180*Gaudi::Units::deg));
 
//    // the other side
//    fwrPhys->add(rotateX180);
//    fwrPhys->add(move);
//    fwrPhys->add(rotate);
//    tag = new GeoNameTag(name+"_L");
//    fwrPhys->add(tag);
//    fwrPhys->add(ringPhys);
}

insertMagnetEnvelope()

GeoPhysVol * ForwardRegionGeoModelFactory::insertMagnetEnvelope ( const std::string & name, double x, double y, double z, double rotationAngle, double diameter, double halfL, double dL, GeoPhysVol * fwrPhys )

private

Definition at line 26 of file ForwardRegionGeoModelElements.cxx.

{
    const GeoTube     *tube  = new GeoTube(0, diameter/2, halfL-dL);
 
    GeoTrf::Transform3D shift = GeoTrf::Translate3D(x,y,z);
    GeoTrf::Transform3D rotate = GeoTrf::RotateY3D(rotationAngle);
//    Transform3D rotateX180 = GeoTrf::RotateX3D(180*Gaudi::Units::deg);
 
    const GeoShapeShift& magTube0 = (*tube)<<rotate<<shift;
//    const GeoShapeUnion& magTube = magTube0.add((*tube)<<rotate<<shift<<rotateX180);
 
    const GeoLogVol   *tubeLog  = new  GeoLogVol(name, &magTube0, m_MapMaterials[std::string("std::Vacuum")]);
 
    GeoPhysVol        *tubePhys = new GeoPhysVol(tubeLog);
 
    GeoNameTag *tag = new GeoNameTag(name);
    fwrPhys->add(tag);
 
    fwrPhys->add(tubePhys);
 
    return tubePhys;
}

insertTCLElement()

void ForwardRegionGeoModelFactory::insertTCLElement ( const std::string & name, double x, double y, double z, GeoPhysVol * fwrPhys, double TCLJawDistO, double TCLJawDistI, bool tungstenInsteadOfCopper = false )

private

Definition at line 393 of file ForwardRegionGeoModelElements.cxx.

{
    // Constants
    double TCL_BOX_halflength, TCL_BOX_halfwidth, TCL_BOX_halfheight, TCL_BOX_sideThickness, TCL_BOX_topBottomThickness, TCL_BOX_endThickness, TCL_TUBE_halflength, TCL_TUBE_halfapperture, TCL_TUBE_thickness;
    TCL_BOX_sideThickness = 6*Gaudi::Units::mm;
    TCL_BOX_topBottomThickness = 18*Gaudi::Units::mm;
    TCL_BOX_endThickness = 18*Gaudi::Units::mm;
 
    TCL_BOX_halflength = 621*Gaudi::Units::mm;
    TCL_BOX_halfwidth = 132*Gaudi::Units::mm;
    TCL_BOX_halfheight = 60+TCL_BOX_topBottomThickness;
 
    TCL_TUBE_halflength = 59.5*Gaudi::Units::mm;
    TCL_TUBE_halfapperture = 53*Gaudi::Units::mm;
    TCL_TUBE_thickness = 2*Gaudi::Units::mm;
 
    double TCL_CuBlock_halflength, TCL_CuBlock_halfwidth, TCL_CuBlock_halfheight, TCL_CuBlockCylCut_zDepth, TCL_CuBlockCylCut_angle, TCL_CuBlockCylCut_cylR, TCL_CuBlockCylCut_cylHalflength, TCL_CuBlockCylCut_xDepth, TCL_CuBlockCylCut_xShift;
    TCL_CuBlock_halflength = 597*Gaudi::Units::mm;
    TCL_CuBlock_halfwidth = 14.5*Gaudi::Units::mm;
    TCL_CuBlock_halfheight = 40*Gaudi::Units::mm;
 
    TCL_CuBlockCylCut_zDepth = 90*Gaudi::Units::mm;
    TCL_CuBlockCylCut_angle = 12*Gaudi::Units::deg;
    TCL_CuBlockCylCut_cylR = 40*Gaudi::Units::mm;
 
    TCL_CuBlockCylCut_cylHalflength = TCL_CuBlockCylCut_zDepth/cos(TCL_CuBlockCylCut_angle);
    TCL_CuBlockCylCut_xDepth = TCL_CuBlockCylCut_zDepth*tan(TCL_CuBlockCylCut_angle);
    TCL_CuBlockCylCut_xShift = -TCL_CuBlock_halfwidth-TCL_CuBlockCylCut_cylR/cos(TCL_CuBlockCylCut_angle)+TCL_CuBlockCylCut_xDepth;
 
    double TCL_CuBeam_halflength, TCL_CuBeam_halfwidth, TCL_CuBeam_halfheight, TCL_Cooling_width;
    TCL_CuBeam_halflength = 530*Gaudi::Units::mm;
    TCL_CuBeam_halfwidth = 15*Gaudi::Units::mm;
    TCL_CuBeam_halfheight = 40*Gaudi::Units::mm;
 
    TCL_Cooling_width = 9*Gaudi::Units::mm;
 
 
 
    // rotate by 180 deg around X and Y
    GeoTrf::Transform3D rotateX180 = GeoTrf::RotateX3D(180*Gaudi::Units::deg);
    GeoTrf::Transform3D rotateY180 = GeoTrf::RotateY3D(180*Gaudi::Units::deg);
 
    // inner vacuum volume solid
    const GeoBox * boxIn = new GeoBox(TCL_BOX_halfwidth-TCL_BOX_sideThickness, TCL_BOX_halfheight-TCL_BOX_topBottomThickness, TCL_BOX_halflength-TCL_BOX_endThickness);
    const GeoTube * tubeIn = new GeoTube(0, TCL_TUBE_halfapperture, TCL_TUBE_halflength+0.5*TCL_BOX_endThickness);
    GeoTrf::Transform3D moveTubeIn = GeoTrf::Translate3D(0, 0, TCL_BOX_halflength+TCL_TUBE_halflength-0.5*TCL_BOX_endThickness);
    const GeoShapeShift& tubeIn1 = (*tubeIn)<<moveTubeIn;
    const GeoShapeShift& tubeIn2 = (*tubeIn)<<moveTubeIn<<rotateY180;
    const GeoShapeUnion * innerVac0 = new GeoShapeUnion(boxIn,&tubeIn1);
    GeoShapeUnion * innerVac = new GeoShapeUnion(innerVac0,&tubeIn2);
 
    // outer steel case solid
    const GeoBox * boxFull = new GeoBox(TCL_BOX_halfwidth, TCL_BOX_halfheight, TCL_BOX_halflength);
    const GeoTube * tubeOut = new GeoTube(TCL_TUBE_halfapperture, TCL_TUBE_halfapperture+TCL_TUBE_thickness, TCL_TUBE_halflength);
    GeoTrf::Transform3D moveTubeOut = GeoTrf::Translate3D(0, 0, TCL_BOX_halflength+TCL_TUBE_halflength);
    const GeoShapeShift& tubeOut1 = (*tubeOut)<<moveTubeOut;
    const GeoShapeShift& tubeOut2 = (*tubeOut)<<moveTubeOut<<rotateY180;
    const GeoShapeUnion * outerSteelFull0 = new GeoShapeUnion(boxFull,&tubeOut1);
    const GeoShapeUnion * outerSteelFull = new GeoShapeUnion(outerSteelFull0,&tubeOut2);
    GeoShapeSubtraction * outerSteel = new GeoShapeSubtraction(outerSteelFull,innerVac);
 
    // Copper block solid
    const GeoBox * cuBoxFull = new GeoBox(TCL_CuBlock_halfwidth, TCL_CuBlock_halfheight, TCL_CuBlock_halflength);
    const GeoTube * cylCut0 = new GeoTube(0, TCL_CuBlockCylCut_cylR, TCL_CuBlockCylCut_cylHalflength);
    GeoTrf::Transform3D rotateCylCut = GeoTrf::RotateY3D(TCL_CuBlockCylCut_angle);
    GeoTrf::Transform3D moveCylCut = GeoTrf::Translate3D(TCL_CuBlockCylCut_xShift, 0, TCL_CuBlock_halflength);
    const GeoShapeShift& cylCut1 = (*cylCut0)<<rotateCylCut<<moveCylCut;
    const GeoShapeShift& cylCut2 = (*cylCut0)<<rotateCylCut<<moveCylCut<<rotateX180;
    const GeoShapeSubtraction * cuBox0 = new GeoShapeSubtraction(cuBoxFull, &cylCut1);
    const GeoShapeSubtraction * cuBox1 = new GeoShapeSubtraction(cuBox0, &cylCut2);
    GeoTrf::Transform3D moveCuBoxI = GeoTrf::Translate3D(TCLJawDistI+TCL_CuBlock_halfwidth, 0, 0);
    const GeoShapeShift& cuBoxI = (*cuBox1)<<moveCuBoxI;
    GeoTrf::Transform3D moveCuBoxO = GeoTrf::Translate3D(+TCLJawDistO+TCL_CuBlock_halfwidth, 0, 0);
    const GeoShapeShift& cuBoxO = (*cuBox1)<<moveCuBoxO<<rotateY180;
 
    // Copper beam solid
    const GeoBox * cuBeamFull = new GeoBox(TCL_CuBeam_halfwidth, TCL_CuBeam_halfheight, TCL_CuBeam_halflength);
    GeoTrf::Transform3D moveCuBeamI = GeoTrf::Translate3D(TCLJawDistI+2*TCL_CuBlock_halfwidth+TCL_Cooling_width+TCL_CuBeam_halfwidth, 0, 0);
    const GeoShapeShift& cuBeamI = (*cuBeamFull)<<moveCuBeamI;
    GeoTrf::Transform3D moveCuBeamO = GeoTrf::Translate3D(+TCLJawDistO+2*TCL_CuBlock_halfwidth+TCL_Cooling_width+TCL_CuBeam_halfwidth, 0, 0);
    const GeoShapeShift& cuBeamO = (*cuBeamFull)<<moveCuBeamO<<rotateY180;
 
    // Watter cooling in first aproximation (water box)
    const GeoBox * waterBox = new GeoBox(0.5*TCL_Cooling_width, TCL_CuBlock_halfheight, TCL_CuBlock_halflength);
    GeoTrf::Transform3D moveWaterBoxI = GeoTrf::Translate3D(TCLJawDistI+2*TCL_CuBlock_halfwidth+0.5*TCL_Cooling_width, 0, 0);
    const GeoShapeShift& waterBoxI = (*waterBox)<<moveWaterBoxI;
    GeoTrf::Transform3D moveWaterBoxO = GeoTrf::Translate3D(+TCLJawDistO+2*TCL_CuBlock_halfwidth+0.5*TCL_Cooling_width, 0, 0);
    const GeoShapeShift& waterBoxO = (*waterBox)<<moveWaterBoxO<<rotateY180;
 
 
    // Logical and physical volumes
    const GeoLogVol   *ringLog  = new  GeoLogVol(name+"Log", outerSteel, m_MapMaterials[std::string("Steel")]);
    const GeoLogVol   *ringLog2  = new  GeoLogVol(name+"Fill", innerVac, m_MapMaterials[std::string("std::Vacuum")]);
 
    GeoPhysVol        *ringPhys = new GeoPhysVol(ringLog);
    GeoPhysVol        *ringPhys2 = new GeoPhysVol(ringLog2);
 
    const GeoLogVol   *cuBoxLogI  = new  GeoLogVol(name+"CuBoxI", &cuBoxI, m_MapMaterials[std::string(tungstenInsteadOfCopper ? "Tungsten" : "Copper")]);
    GeoPhysVol        *cuBoxPhysI = new GeoPhysVol(cuBoxLogI);
    const GeoLogVol   *cuBoxLogO  = new  GeoLogVol(name+"CuBoxO", &cuBoxO, m_MapMaterials[std::string(tungstenInsteadOfCopper ? "Tungsten" : "Copper")]);
    GeoPhysVol        *cuBoxPhysO = new GeoPhysVol(cuBoxLogO);
 
    const GeoLogVol   *cuBeamLogI  = new  GeoLogVol(name+"CuBeamI", &cuBeamI, m_MapMaterials[std::string("GlidCopAL15")]);
    GeoPhysVol        *cuBeamPhysI = new GeoPhysVol(cuBeamLogI);
    const GeoLogVol   *cuBeamLogO  = new  GeoLogVol(name+"CuBeamO", &cuBeamO, m_MapMaterials[std::string("GlidCopAL15")]);
    GeoPhysVol        *cuBeamPhysO = new GeoPhysVol(cuBeamLogO);
 
    const GeoLogVol   *waterBoxLogI  = new  GeoLogVol(name+"waterBoxI", &waterBoxI, m_MapMaterials[std::string("water")]);
    GeoPhysVol        *waterBoxPhysI = new GeoPhysVol(waterBoxLogI);
    const GeoLogVol   *waterBoxLogO  = new  GeoLogVol(name+"waterBoxO", &waterBoxO, m_MapMaterials[std::string("water")]);
    GeoPhysVol        *waterBoxPhysO = new GeoPhysVol(waterBoxLogO);
 
    //create rotation and traslation and add them to the tree of volumes of the world (move and rotate the volume)
    GeoTransform *move           = new GeoTransform(GeoTrf::Translate3D(x,y,z));
    fwrPhys->add(move);
 
    GeoNameTag *tag = new GeoNameTag(name);
    fwrPhys->add(tag);
 
    fwrPhys->add(ringPhys);
 
    // add filling (inside of the tube)
    fwrPhys->add(move);
    tag = new GeoNameTag(name+"Fill");
    fwrPhys->add(tag);
    fwrPhys->add(ringPhys2);
 
    // add copper absorbers
    ringPhys2->add(cuBoxPhysI);
    ringPhys2->add(cuBoxPhysO);
 
    ringPhys2->add(cuBeamPhysI);
    ringPhys2->add(cuBeamPhysO);
 
    ringPhys2->add(waterBoxPhysI);
    ringPhys2->add(waterBoxPhysO);
}

insertTrousersElement()

void ForwardRegionGeoModelFactory::insertTrousersElement ( const std::string & name, double x, double y, double z, double rotationAngle, GeoPhysVol * fwrPhys )

private

Definition at line 285 of file ForwardRegionGeoModelElements.cxx.

{
    // "Trousers" -- transition from 1 to 2 beampipes
    // rewritten from Knut Dundas Moraa's AGDD file and modified
 
    // CONSTANTS
    double TAN_A, TAN_B, TAN_C, TAN_Dsmall, TAN_Dbig, TAN_thick1, TAN_xseparation;
    TAN_A = 700*Gaudi::Units::mm;
    TAN_B = 500*Gaudi::Units::mm;
    TAN_C = 3700*Gaudi::Units::mm;
    TAN_Dsmall = 52*Gaudi::Units::mm;
    TAN_Dbig = 212*Gaudi::Units::mm;
    TAN_thick1 = 4.5*Gaudi::Units::mm;
    TAN_xseparation = 80*Gaudi::Units::mm;
 
    // Derived constants
    double TAN_Rsmall, TAN_Rbig, TAN_coneZh, TAN_coneR, TAN_coneXh;//, TAN_halflength;
    TAN_Rsmall = 0.5*TAN_Dsmall;
    TAN_Rbig = 0.5*TAN_Dbig;
    TAN_coneZh = TAN_B*cos(5*M_PI/180);
    TAN_coneR = 2*TAN_B*sin(5*M_PI/180)+TAN_Rsmall;
    TAN_coneXh = TAN_Rbig-TAN_B*sin(5*M_PI/180)-TAN_Rsmall;
    //TAN_halflength = 0.5*(TAN_A+TAN_B+TAN_C);
 
    // volume construction
 
    // inner part
    GeoPcon *TANi_cone0 = new GeoPcon(0,360*Gaudi::Units::deg);
    TANi_cone0->addPlane(2*TAN_coneZh, TAN_Rsmall, 2*TAN_Rbig);
    TANi_cone0->addPlane(TAN_coneZh, TAN_Rsmall, 2*TAN_Rbig);
    TANi_cone0->addPlane(-TAN_coneZh, TAN_coneR, 2*TAN_Rbig);
    GeoTrf::Transform3D TAN_moveCone = GeoTrf::Translate3D(TAN_coneXh,0,0.5*(TAN_A-TAN_B));
    GeoTrf::Transform3D TAN_rotateCone = GeoTrf::RotateY3D(5*Gaudi::Units::deg);
    const GeoShapeShift& TANi_cone = (*TANi_cone0)<<TAN_rotateCone<<TAN_moveCone;
 
    const GeoBox *TAN_box0 = new GeoBox(2*TAN_Rbig,2*TAN_Rbig,TAN_A+TAN_B);
    GeoTrf::Transform3D TAN_moveBox = GeoTrf::Translate3D(-2*TAN_Rbig,0,0);
    const GeoShapeShift& TAN_box = (*TAN_box0)<<TAN_moveBox;
 
    const GeoTube *TANi_bigtube  = new GeoTube(0, TAN_Rbig, 0.5*(TAN_A+TAN_B));
 
    GeoShapeSubtraction *TANi_hcyl = new GeoShapeSubtraction(TANi_bigtube, &TAN_box);
 
    GeoShapeSubtraction *TANi_h = new GeoShapeSubtraction(TANi_hcyl, &TANi_cone);
    GeoTrf::Transform3D TAN_moveH = GeoTrf::Translate3D(0,0,-0.5*TAN_C);
    GeoTrf::Transform3D TAN_rotateH = GeoTrf::RotateZ3D(180*Gaudi::Units::deg);
 
    GeoTrf::Transform3D TAN_moveTube1 = GeoTrf::Translate3D(TAN_xseparation,0,0.5*(TAN_A+TAN_B));
    GeoTrf::Transform3D TAN_moveTube2 = GeoTrf::Translate3D(-TAN_xseparation,0,0.5*(TAN_A+TAN_B));
 
    // outer part
    GeoPcon *TANo_cone0 = new GeoPcon(0,360*Gaudi::Units::deg);
    TANo_cone0->addPlane(2*TAN_coneZh, TAN_Rsmall+TAN_thick1, 2*TAN_Rbig);
    TANo_cone0->addPlane(TAN_coneZh, TAN_Rsmall+TAN_thick1, 2*TAN_Rbig);
    TANo_cone0->addPlane(-TAN_coneZh, TAN_coneR+TAN_thick1, 2*TAN_Rbig);
    const GeoShapeShift& TANo_cone = (*TANo_cone0)<<TAN_rotateCone<<TAN_moveCone;
 
    const GeoTube *TANo_bigtube  = new GeoTube(0, TAN_Rbig+TAN_thick1, 0.5*(TAN_A+TAN_B));
 
    GeoShapeSubtraction *TANo_hcyl = new GeoShapeSubtraction(TANo_bigtube, &TAN_box);
 
    GeoShapeSubtraction *TANo_h = new GeoShapeSubtraction(TANo_hcyl, &TANo_cone);
 
    const GeoTube *TAN_antiblock0  = new GeoTube(0, TAN_Rsmall, 0.5*(TAN_A+2*TAN_B)); // antiblock tube -- just in case..
    GeoTrf::Transform3D TAN_moveAntiblock = GeoTrf::Translate3D(TAN_xseparation,0,0);
    const GeoShapeShift& TAN_antiblock = (*TAN_antiblock0)<<TAN_moveAntiblock;
 
    GeoShapeSubtraction *TAN_shape0 = new GeoShapeSubtraction(TANo_h, TANi_h);
    GeoShapeSubtraction *TAN_shape = new GeoShapeSubtraction(TAN_shape0, &TAN_antiblock);
    const GeoShapeShift& TAN_shape1 = (*TAN_shape)<<TAN_moveH;
    const GeoShapeShift& TAN_shape2 = (*TAN_shape)<<TAN_moveH<<TAN_rotateH;
 
    const GeoTube *TANo_ftube = new GeoTube(TAN_Rsmall,TAN_Rsmall+TAN_thick1,0.5*TAN_C-0.1*Gaudi::Units::mm);
    const GeoShapeShift& TANo_ftube1 = (*TANo_ftube)<<TAN_moveTube1;
    const GeoShapeShift& TANo_ftube2 = (*TANo_ftube)<<TAN_moveTube2;
 
    GeoShapeUnion *TANo0 = new GeoShapeUnion(&TAN_shape1, &TAN_shape2);
    GeoShapeUnion *TANo1 = new GeoShapeUnion(TANo0, &TANo_ftube1);
    GeoShapeUnion *TANo = new GeoShapeUnion(TANo1, &TANo_ftube2); // complete outer part
 
    // PLACEMENT
    const GeoLogVol   *ringLog  = new  GeoLogVol(name+"Log", TANo, m_MapMaterials[std::string("Steel")]);
 
    GeoPhysVol        *ringPhys = new GeoPhysVol(ringLog);
 
    //create rotation and traslation and add them to the tree of volumes of the world (move and rotate the volume)
    GeoTransform *move           = new GeoTransform(GeoTrf::Translate3D(x,y,z));
    fwrPhys->add(move);
    GeoTransform *rotate         = new GeoTransform(GeoTrf::RotateY3D(rotationAngle));
    fwrPhys->add(rotate);
 
    GeoNameTag *tag = new GeoNameTag(name);
    fwrPhys->add(tag);
 
    fwrPhys->add(ringPhys);
 
//    // The other side of the forward region may be obtained by rotation
//    GeoTransform *rotateX180  = new GeoTransform(GeoTrf::RotateX3D(180*Gaudi::Units::deg));
 
//    // the other side
//    fwrPhys->add(rotateX180);
//    fwrPhys->add(move);
//    fwrPhys->add(rotate);
//    tag = new GeoNameTag(name+"_L");
//    fwrPhys->add(tag);
//    fwrPhys->add(ringPhys);
}

insertXRecticircularElement()

void ForwardRegionGeoModelFactory::insertXRecticircularElement ( const std::string & name, double x, double y, double z, double rotationAngle, double xAperture, double yAperture, double halfL, double dL, double tubeThickness, GeoPhysVol * fwrPhys )

private

Definition at line 125 of file ForwardRegionGeoModelElements.cxx.

{
    double beamScreenSeparation = 1.5*Gaudi::Units::mm;
    double beamScreenCuThick = 0.05*Gaudi::Units::mm;
    double beamScreenSteelThick = 1*Gaudi::Units::mm;
 
    const GeoTube     *ringTube  = new GeoTube(yAperture*Gaudi::Units::mm/2+beamScreenCuThick+beamScreenSteelThick+beamScreenSeparation, yAperture*Gaudi::Units::mm/2+beamScreenCuThick+beamScreenSteelThick+beamScreenSeparation+tubeThickness, halfL-dL);
    const GeoTube     *circ  = new GeoTube(0, yAperture*Gaudi::Units::mm/2, halfL-dL);
    const GeoBox      *rect  = new GeoBox(xAperture*Gaudi::Units::mm/2, yAperture*Gaudi::Units::mm/2, halfL-dL);
    GeoShapeIntersection *innerVac = new GeoShapeIntersection(rect,circ);
 
    const GeoTube     *circ2  = new GeoTube(0, yAperture*Gaudi::Units::mm/2+beamScreenCuThick, halfL-dL);
    const GeoBox      *rect2  = new GeoBox(xAperture*Gaudi::Units::mm/2+beamScreenCuThick, yAperture*Gaudi::Units::mm/2+beamScreenCuThick, halfL-dL);
    GeoShapeIntersection *beamScreenCu0 = new GeoShapeIntersection(rect2,circ2);
    GeoShapeSubtraction *beamScreenCu = new GeoShapeSubtraction(beamScreenCu0, innerVac);
 
    const GeoTube     *circ3  = new GeoTube(0, yAperture*Gaudi::Units::mm/2+beamScreenCuThick+beamScreenSteelThick, halfL-dL);
    const GeoBox      *rect3  = new GeoBox(xAperture*Gaudi::Units::mm/2+beamScreenCuThick+beamScreenSteelThick, yAperture*Gaudi::Units::mm/2+beamScreenCuThick+beamScreenSteelThick, halfL-dL);
    GeoShapeIntersection *beamScreenSteel01 = new GeoShapeIntersection(rect3,circ3);
    GeoShapeSubtraction *beamScreenSteel02 = new GeoShapeSubtraction(beamScreenSteel01, innerVac);
    GeoShapeSubtraction *beamScreenSteel = new GeoShapeSubtraction(beamScreenSteel02, beamScreenCu);
 
    const GeoLogVol   *ringLog  = new  GeoLogVol(name+"BeamPipe", ringTube, m_MapMaterials[std::string("Steel")]);
    const GeoLogVol   *ringLogCu = new  GeoLogVol(name+"BeamScreenCu", beamScreenCu, m_MapMaterials[std::string("Copper")]);
    const GeoLogVol   *ringLogSteel = new  GeoLogVol(name+"BeamScreenSteel", beamScreenSteel, m_MapMaterials[std::string("Steel")]);
 
    GeoPhysVol        *ringPhys = new GeoPhysVol(ringLog);
    GeoPhysVol        *ringPhysCu = new GeoPhysVol(ringLogCu);
    GeoPhysVol        *ringPhysSteel = new GeoPhysVol(ringLogSteel);
 
    //create rotation and traslation and add them to the tree of volumes of the world (move and rotate the volume)
    GeoTransform *move           = new GeoTransform(GeoTrf::Translate3D(x,y,z));
    fwrPhys->add(move);
    GeoTransform *rotate         = new GeoTransform(GeoTrf::RotateY3D(rotationAngle));
    fwrPhys->add(rotate);
 
    GeoNameTag *tag = new GeoNameTag(name+"BeamPipe");
    fwrPhys->add(tag);
 
    fwrPhys->add(ringPhys);
    //detectorManager->addTreeTop(ringPhys);
 
    // add beam scren
    fwrPhys->add(move);
    fwrPhys->add(rotate);
    tag = new GeoNameTag(name+"BeamScreenCu");
    fwrPhys->add(tag);
    fwrPhys->add(ringPhysCu);
    fwrPhys->add(move);
    fwrPhys->add(rotate);
    tag = new GeoNameTag(name+"BeamScreenSteel");
    fwrPhys->add(tag);
    fwrPhys->add(ringPhysSteel);
 
 
//    // The other side of the forward region may be obtain by rotation
//    GeoTransform *rotateX180  = new GeoTransform(GeoTrf::RotateX3D(180*Gaudi::Units::deg));
 
//    // the other side
//    fwrPhys->add(rotateX180);
//    fwrPhys->add(move);
//    fwrPhys->add(rotate);
//    tag = new GeoNameTag(name+"BeamPipe_L");
//    fwrPhys->add(tag);
//    fwrPhys->add(ringPhys);
 
//    fwrPhys->add(rotateX180);
//    fwrPhys->add(move);
//    fwrPhys->add(rotate);
//    tag = new GeoNameTag(name+"BeamScreenCu_L");
//    fwrPhys->add(tag);
//    fwrPhys->add(ringPhysCu);
 
//    fwrPhys->add(rotateX180);
//    fwrPhys->add(move);
//    fwrPhys->add(rotate);
//    tag = new GeoNameTag(name+"BeamScreenSteel_L");
//    fwrPhys->add(tag);
//    fwrPhys->add(ringPhysSteel);
}

insertYRecticircularElement()

void ForwardRegionGeoModelFactory::insertYRecticircularElement ( const std::string & name, double x, double y, double z, double rotationAngle, double xAperture, double yAperture, double halfL, double dL, double tubeThickness, GeoPhysVol * fwrPhys )

private

Definition at line 206 of file ForwardRegionGeoModelElements.cxx.

{
    double beamScreenSeparation = 1.5*Gaudi::Units::mm;
    double beamScreenCuThick = 0.05*Gaudi::Units::mm;
    double beamScreenSteelThick = 1*Gaudi::Units::mm;
 
    const GeoTube     *ringTube  = new GeoTube(xAperture*Gaudi::Units::mm/2+beamScreenCuThick+beamScreenSteelThick+beamScreenSeparation, xAperture*Gaudi::Units::mm/2+beamScreenCuThick+beamScreenSteelThick+beamScreenSeparation+tubeThickness, halfL-dL);
    const GeoTube     *circ  = new GeoTube(0, xAperture*Gaudi::Units::mm/2, halfL-dL);
    const GeoBox      *rect  = new GeoBox(xAperture*Gaudi::Units::mm/2, yAperture*Gaudi::Units::mm/2, halfL-dL);
    GeoShapeIntersection *innerVac = new GeoShapeIntersection(rect,circ);
 
    const GeoTube     *circ2  = new GeoTube(0, xAperture*Gaudi::Units::mm/2+beamScreenCuThick, halfL-dL);
    const GeoBox      *rect2  = new GeoBox(xAperture*Gaudi::Units::mm/2+beamScreenCuThick, yAperture*Gaudi::Units::mm/2+beamScreenCuThick, halfL-dL);
    GeoShapeIntersection *beamScreenCu0 = new GeoShapeIntersection(rect2,circ2);
    GeoShapeSubtraction *beamScreenCu = new GeoShapeSubtraction(beamScreenCu0, innerVac);
 
    const GeoTube     *circ3  = new GeoTube(0, xAperture*Gaudi::Units::mm/2+beamScreenCuThick+beamScreenSteelThick, halfL-dL);
    const GeoBox      *rect3  = new GeoBox(xAperture*Gaudi::Units::mm/2+beamScreenCuThick+beamScreenSteelThick, yAperture*Gaudi::Units::mm/2+beamScreenCuThick+beamScreenSteelThick, halfL-dL);
    GeoShapeIntersection *beamScreenSteel01 = new GeoShapeIntersection(rect3,circ3);
    GeoShapeSubtraction *beamScreenSteel02 = new GeoShapeSubtraction(beamScreenSteel01, innerVac);
    GeoShapeSubtraction *beamScreenSteel = new GeoShapeSubtraction(beamScreenSteel02, beamScreenCu);
 
    const GeoLogVol   *ringLog  = new  GeoLogVol(name+"BeamPipe", ringTube, m_MapMaterials[std::string("Steel")]);
    const GeoLogVol   *ringLogCu = new  GeoLogVol(name+"BeamScreenCu", beamScreenCu, m_MapMaterials[std::string("Copper")]);
    const GeoLogVol   *ringLogSteel = new  GeoLogVol(name+"BeamScreenSteel", beamScreenSteel, m_MapMaterials[std::string("Steel")]);
 
    GeoPhysVol        *ringPhys = new GeoPhysVol(ringLog);
    GeoPhysVol        *ringPhysCu = new GeoPhysVol(ringLogCu);
    GeoPhysVol        *ringPhysSteel = new GeoPhysVol(ringLogSteel);
 
    //create rotation and traslation and add them to the tree of volumes of the world (move and rotate the volume)
    GeoTransform *move           = new GeoTransform(GeoTrf::Translate3D(x,y,z));
    fwrPhys->add(move);
    GeoTransform *rotate         = new GeoTransform(GeoTrf::RotateY3D(rotationAngle));
    fwrPhys->add(rotate);
 
    GeoNameTag *tag = new GeoNameTag(name+"BeamPipe");
    fwrPhys->add(tag);
 
    fwrPhys->add(ringPhys);
 
    // add beam scren
    fwrPhys->add(move);
    fwrPhys->add(rotate);
    tag = new GeoNameTag(name+"BeamScreenCu");
    fwrPhys->add(tag);
    fwrPhys->add(ringPhysCu);
    fwrPhys->add(move);
    fwrPhys->add(rotate);
    tag = new GeoNameTag(name+"BeamScreenSteel");
    fwrPhys->add(tag);
    fwrPhys->add(ringPhysSteel);
 
//    // The other side of the forward region may be obtain by rotation
//    GeoTransform *rotateX180  = new GeoTransform(GeoTrf::RotateX3D(180*Gaudi::Units::deg));
 
//    // the other side
//    fwrPhys->add(rotateX180);
//    fwrPhys->add(move);
//    fwrPhys->add(rotate);
//    tag = new GeoNameTag(name+"BeamPipe_L");
//    fwrPhys->add(tag);
//    fwrPhys->add(ringPhys);
 
//    fwrPhys->add(rotateX180);
//    fwrPhys->add(move);
//    fwrPhys->add(rotate);
//    tag = new GeoNameTag(name+"BeamScreenCu_L");
//    fwrPhys->add(tag);
//    fwrPhys->add(ringPhysCu);
 
//    fwrPhys->add(rotateX180);
//    fwrPhys->add(move);
//    fwrPhys->add(rotate);
//    tag = new GeoNameTag(name+"BeamScreenSteel_L");
//    fwrPhys->add(tag);
//    fwrPhys->add(ringPhysSteel);
}

loadDataFile()

std::vector< std::vector< std::string > > ForwardRegionGeoModelFactory::loadDataFile ( const std::string & fileName, int cols )

private

Definition at line 445 of file ForwardRegionGeoModelFactory.cxx.

{
    std::vector<std::vector<std::string> > loadedData;
 
    MsgStream LogStream(Athena::getMessageSvc(), "ForwardRegionGeoModel::loadDataFile()");
 
    std::ifstream file (fileName);
    if(!file){
        std::string datapath = PathResolverFindDataFile(fileName);
        LogStream << MSG::DEBUG << "File " << fileName << " not found in run directory, trying to load it from DATAPATH" << endmsg;
        file.open(datapath.c_str());
    }
 
    if(!file)
        LogStream << MSG::FATAL << "Unable to load " << fileName << endmsg;
 
    if(file.is_open())
    {
    std::vector<std::string> row (cols);
    char c;
 
        while(file.get(c))
        {
            if(c != '@' && c != '#' && c != '*' && c != '$' && c != '%')
            {
                file.unget();
                for(int i = 0; i<cols; i++) // load desired columns
                {
                    file >> row[i];
                }
                loadedData.push_back(row); //store them
                file.ignore(1024,'\n'); // discard rest of line
            }
            else
              file.ignore(1024, '\n'); // discard commented lines
        }
        LogStream << MSG::INFO << "File " << fileName << " succesfully loaded." << endmsg;
        file.close();
    }
    return loadedData;
}

num2str()

template<class T>

std::string ForwardRegionGeoModelFactory::num2str ( T num )

private

Definition at line 200 of file ForwardRegionGeoModelFactory.cxx.

{
    std::ostringstream strs;
    strs << num;
    return strs.str();
}

operator=()

const ForwardRegionGeoModelFactory & ForwardRegionGeoModelFactory::operator= ( const ForwardRegionGeoModelFactory & right )

private

sgn()

template<typename T>

int ForwardRegionGeoModelFactory::sgn ( T val )

private

Definition at line 207 of file ForwardRegionGeoModelFactory.cxx.

                                                                 {
    return (T(0) < val) - (val < T(0));
}

Member Data Documentation

m_Config

FWD_CONFIGURATION ForwardRegionGeoModelFactory::m_Config

private

Definition at line 73 of file ForwardRegionGeoModelFactory.h.

m_detectorManager

ForwardRegionGeoModelManager* ForwardRegionGeoModelFactory::m_detectorManager

private

Definition at line 108 of file ForwardRegionGeoModelFactory.h.

m_detectorStore

StoreGateSvc* ForwardRegionGeoModelFactory::m_detectorStore

private

Definition at line 67 of file ForwardRegionGeoModelFactory.h.

m_MagConfig

FWDMg_CONFIGURATION ForwardRegionGeoModelFactory::m_MagConfig

private

Definition at line 74 of file ForwardRegionGeoModelFactory.h.

m_MapMaterials

std::map<std::string,const GeoMaterial*> ForwardRegionGeoModelFactory::m_MapMaterials

private

Definition at line 70 of file ForwardRegionGeoModelFactory.h.

m_properties

ToolHandle<IForwardRegionProperties> ForwardRegionGeoModelFactory::m_properties

private

Definition at line 76 of file ForwardRegionGeoModelFactory.h.

---

The documentation for this class was generated from the following files:

• ForwardRegionGeoModelFactory.h
• ForwardRegionGeoModelElements.cxx
• ForwardRegionGeoModelFactory.cxx