#include <AFP_GeoModelFactory.h>

Inheritance diagram for AFP_GeoModelFactory:

Collaboration diagram for AFP_GeoModelFactory:

Public Member Functions
	AFP_GeoModelFactory (StoreGateSvc pDetStore, AFP_Geometry pGeometry)
	~AFP_GeoModelFactory ()
virtual void	create (GeoPhysVol *world)
virtual const AFP_GeoModelManager *	getDetectorManager () const
void	updatePositions (AFP_BPMCOOLPARAMS *pBpmParams)

Private Member Functions
void	defineMaterials ()
const AFP_GeoModelFactory &	operator= (const AFP_GeoModelFactory &right)
	AFP_GeoModelFactory (const AFP_GeoModelFactory &right)
GeoShape *	createSolidSIDPlate ()
void	addSiDetector (GeoPhysVol pPhysMotherVol, const char pszStationName, HepGeom::Transform3D &TransInMotherVolume)
void	addRomanPot (GeoPhysVol pPhysMotherVol, const char pszStationName, HepGeom::Transform3D &TransInMotherVolume)
void	initializeTDParameters ()
StatusCode	addTimingDetector (const char pszStationName, GeoOpticalPhysVol pPhysMotherVol, HepGeom::Transform3D &TransInMotherVolume, GeoBorderSurfaceContainer *bsContainer)
void	addLQBarSegment (const char pszStationName, const int nQuarticID, const int nLQBarID, AFPTOF_LBARDIMENSIONS &LQBarDims, GeoOpticalPhysVol pPhysMotherVolume, HepGeom::Transform3D &TransInMotherVolume, GeoBorderSurfaceContainer *bsContainer)
void	addSepRadLBar (const char pszStationName, const int nQuarticID, const int nBarID, GeoOpticalPhysVol pPhysMotherVolume, HepGeom::Transform3D &TransInMotherVolume, GeoBorderSurfaceContainer *bsContainer)
HepGeom::Vector3D< double >	getBarShift (AFPTOF_LBARDIMENSIONS &LQBarDims, eLBarType eSpecType=ELBT_UNDEFINED)
void	addHorizontalArm (const char pszStationName, const int nQuarticID, const int nLQBarID, AFPTOF_LBARDIMENSIONS &LQBarDims, GeoOpticalPhysVol pPhysMotherVolume, HepGeom::Transform3D &PartialTransInMotherVolume, GeoBorderSurfaceContainer *bsContainer)
void	addSensor (const char pszStationName, const int nQuarticID, GeoOpticalPhysVol pPhysMotherVolume, HepGeom::Transform3D &TransInMotherVolume, GeoBorderSurfaceContainer *bsContainer)
void	addLBarSensorSeparationWindow (const char pszStationName, const int nQuarticID, GeoOpticalPhysVol pPhysMotherVolume, HepGeom::Transform3D &TransInMotherVolume, GeoBorderSurfaceContainer *bsContainer)
void	getLQBarDimensions (const int nRowID, const int nColID, AFPTOF_LBARDIMENSIONS *pLQBarDims)

Private Attributes
std::map< std::string, GeoRef< const GeoMaterial > >	m_MapMaterials
AFP_GeoModelManager *	m_pDetectorManager {}
StoreGateSvc *	m_pDetectorStore {}
std::map< std::string, const GeoShape * >	m_MapShape
AFP_CONFIGURATION	m_CfgParams
AFP_Geometry *	m_pGeometry {}
const bool	m_addSeparationWindow {}
GeoIntrusivePtr< GeoOpticalSurface >	m_pOpticalSurface {}
GeoIntrusivePtr< GeoOpticalSurface >	m_pReflectionOptSurface {}

Detailed Description

Definition at line 38 of file AFP_GeoModelFactory.h.

Constructor & Destructor Documentation

◆ AFP_GeoModelFactory() [1/2]

AFP_GeoModelFactory::AFP_GeoModelFactory	(	StoreGateSvc *	pDetStore,
		AFP_Geometry *	pGeometry )

Definition at line 40 of file AFP_GeoModelFactory.cxx.

    :m_pDetectorStore(detStore)
{
    pGeometry->getCfgParams(&m_CfgParams);
    m_pGeometry=pGeometry;
 
    initializeTDParameters();
}

◆ ~AFP_GeoModelFactory()

AFP_GeoModelFactory::~AFP_GeoModelFactory ( )

Definition at line 50 of file AFP_GeoModelFactory.cxx.

{
    m_CfgParams.clear();
}

◆ AFP_GeoModelFactory() [2/2]

AFP_GeoModelFactory::AFP_GeoModelFactory ( const AFP_GeoModelFactory & right )

private

Member Function Documentation

◆ addHorizontalArm()

void AFP_GeoModelFactory::addHorizontalArm	(	const char *	pszStationName,
		const int	nQuarticID,
		const int	nLQBarID,
		AFPTOF_LBARDIMENSIONS &	LQBarDims,
		GeoOpticalPhysVol *	pPhysMotherVolume,
		HepGeom::Transform3D &	PartialTransInMotherVolume,
		GeoBorderSurfaceContainer *	bsContainer )

private

◆ addLBarSensorSeparationWindow()

void AFP_GeoModelFactory::addLBarSensorSeparationWindow	(	const char *	pszStationName,
		const int	nQuarticID,
		GeoOpticalPhysVol *	pPhysMotherVolume,
		HepGeom::Transform3D &	TransInMotherVolume,
		GeoBorderSurfaceContainer *	bsContainer )

private

Definition at line 210 of file AFP_GeoModelTD.cxx.

{
    int nPixelID;
    char szlabel[64];
    double fX1Pos_1, fX2Pos_1, fX1Pos_2, fX2Pos_2;
    HepGeom::Transform3D TotTransform;
 
    eAFPStation eStation=m_pGeometry->parseStationName(pszStationName);
    AFP_TDCONFIGURATION TofCfg=m_CfgParams.tdcfg[eStation];
    double fSensor2BarDistance=(TofCfg.bEmulateImmersion)? 0.0:AFP_CONSTANTS::ToF_Sensor2BarDist;
 
    GeoTube* pSolWindow=new GeoTube(0,0.5*AFP_CONSTANTS::ToF_SeparationWindowDiameter,0.5*AFP_CONSTANTS::ToF_SeparationWindowThickness);
    
    nPixelID=10*( TofCfg.nX1PixCnt/2-1 +1)+( TofCfg.nX1PixCnt/2-1 +1);
    m_pGeometry->getPixelLocalPosition(eStation,nPixelID,&fX1Pos_1,&fX2Pos_1);
    nPixelID=10*( TofCfg.nX1PixCnt/2 +1)+( TofCfg.nX1PixCnt/2 +1);
    m_pGeometry->getPixelLocalPosition(eStation,nPixelID,&fX1Pos_2,&fX2Pos_2);
    
    sprintf(szlabel,"%s_Q%i_LogLBarSensorSeparationWindow",pszStationName,nQuarticID);
    TotTransform=TransInMotherVolume*HepGeom::Translate3D(0.5*(fX1Pos_1+fX1Pos_2),-0.5*AFP_CONSTANTS::ToF_SeparationWindowThickness-fSensor2BarDistance,0.5*(fX2Pos_1+fX2Pos_2))*HepGeom::RotateX3D(90.0*CLHEP::deg);
    GeoLogVol* pLogWindow=new GeoLogVol(szlabel,pSolWindow,m_MapMaterials["Quartz"]);
    GeoOpticalPhysVol* pPhysWindow=new GeoOpticalPhysVol(pLogWindow);
    sprintf(szlabel,"%s_Q%i_LBarSensorSeparationWindow",pszStationName,nQuarticID);
    pPhysMotherVolume->add(new GeoNameTag(szlabel));
    pPhysMotherVolume->add(new GeoTransform(Amg::CLHEPTransformToEigen(TotTransform)));
    pPhysMotherVolume->add(pPhysWindow);
    sprintf(szlabel,"%s_Q%i_WindowSurface",pszStationName,nQuarticID);
    bsContainer->push_back(GeoBorderSurface(szlabel, pPhysWindow, pPhysMotherVolume, m_pOpticalSurface));
    
    pPhysWindow=nullptr;
 
}

◆ addLQBarSegment()

void AFP_GeoModelFactory::addLQBarSegment	(	const char *	pszStationName,
		const int	nQuarticID,
		const int	nLQBarID,
		AFPTOF_LBARDIMENSIONS &	LQBarDims,
		GeoOpticalPhysVol *	pPhysMotherVolume,
		HepGeom::Transform3D &	TransInMotherVolume,
		GeoBorderSurfaceContainer *	bsContainer )

private

◆ addRomanPot()

void AFP_GeoModelFactory::addRomanPot	(	GeoPhysVol *	pPhysMotherVol,
		const char *	pszStationName,
		HepGeom::Transform3D &	TransInMotherVolume )

private

Definition at line 60 of file AFP_GeoModelRP.cxx.

{
    const double fMainTubusSteelPartLength=RPOT_MAINTUBUS_LENGTH-RPOT_MAINTUBUS_FLOORPARTLENGTH;
 
    char szLabel[32];
    double fLength,fRMin,fRMax;
    GeoShapeShift* pMoveCut;
    GeoShape* pSolCut;
 
    HepGeom::Transform3D TransRPot=TransInMotherVolume*HepGeom::TranslateX3D(-(0.5*fMainTubusSteelPartLength+RPOT_MAINTUBUS_FLOORPARTLENGTH+RPOT_FLOOR_WNDTHICKNESS));
 
    //Main tubus -------------------------------------------------------------------------------------------------
    fLength=fMainTubusSteelPartLength;
    fRMin=RPOT_MAINTUBUS_INNERRADIUS;
    fRMax=RPOT_MAINTUBUS_INNERRADIUS+RPOT_MAINTUBUS_THICKNESS;
 
    GeoTube* pSolTubus=new GeoTube(fRMin, fRMax, 0.5*fLength);
    sprintf(szLabel,"%s_LogRPMainTubus",pszStationName);
    GeoLogVol* pLogTubus=new GeoLogVol(szLabel,pSolTubus,m_MapMaterials[std::string("Steel_AFP")]);
    sprintf(szLabel,"%s_RPMainTubus",pszStationName);
    GeoFullPhysVol* pPhysTubus=new GeoFullPhysVol(pLogTubus);
    pPhysMotherVol->add(new GeoNameTag(szLabel));
    pPhysMotherVol->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransRPot*HepGeom::RotateY3D(90*CLHEP::deg))));
    pPhysMotherVol->add(pPhysTubus);
 
    //Main tubus - floor (bottom) part ---------------------------------------------------------------------------
    fLength=RPOT_MAINTUBUS_FLOORPARTLENGTH;
    fRMin=RPOT_MAINTUBUS_INNERRADIUS;
    fRMax=RPOT_MAINTUBUS_INNERRADIUS+RPOT_MAINTUBUS_BPTHICKNESS;
 
    sprintf(szLabel,"%s_LogRPMainTubusFloorPart",pszStationName);
    pSolTubus=new GeoTube(fRMin, fRMax, 0.5*fLength);
    sprintf(szLabel,"%s_LogRPMainTubusFloorPart",pszStationName);
    pLogTubus=new GeoLogVol(szLabel,pSolTubus,m_MapMaterials[std::string("Steel_AFP")]); //XXX
    pPhysTubus=new GeoFullPhysVol(pLogTubus);
    sprintf(szLabel,"%s_RPMainTubusFloorPart",pszStationName);
    pPhysMotherVol->add(new GeoNameTag(szLabel));
    pPhysMotherVol->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransRPot*HepGeom::TranslateX3D(0.5*fLength+0.5*fMainTubusSteelPartLength)*HepGeom::RotateY3D(90*CLHEP::deg))));
    pPhysMotherVol->add(pPhysTubus);
 
    //--upper mass
    fLength=RPOT_MAINTUBUS_FLOORPARTLENGTH;
    fRMin=RPOT_MAINTUBUS_INNERRADIUS+RPOT_MAINTUBUS_BPTHICKNESS;
    fRMax=RPOT_MAINTUBUS_INNERRADIUS+RPOT_MAINTUBUS_THICKNESS;
    double fPhi=asin(0.5*RPOT_FLOOR_WNDWIDTH/fRMin);
    double fDPhi=CLHEP::pi-2*fPhi;
    GeoTubs* pSolMass=new GeoTubs(fRMin,fRMax,0.5*fLength,fPhi,fDPhi);
 
    sprintf(szLabel,"%s_LogRPMainTubusUMass",pszStationName);
    pLogTubus=new GeoLogVol(szLabel,pSolMass,m_MapMaterials[std::string("Steel_AFP")]); //XXX
    pPhysTubus=new GeoFullPhysVol(pLogTubus);
    sprintf(szLabel,"%s_LogRPMainTubusUMass",pszStationName);
    pPhysMotherVol->add(new GeoNameTag(szLabel));
    pPhysMotherVol->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransRPot*HepGeom::TranslateX3D(0.5*fLength+0.5*fMainTubusSteelPartLength)*HepGeom::RotateY3D(90*CLHEP::deg))));
    pPhysMotherVol->add(pPhysTubus);
 
    //-lower mass
    fLength=RPOT_MAINTUBUS_FLOORPARTLENGTH;
    fRMin=RPOT_MAINTUBUS_INNERRADIUS+RPOT_MAINTUBUS_BPTHICKNESS;
    fRMax=RPOT_MAINTUBUS_INNERRADIUS+RPOT_MAINTUBUS_THICKNESS;
    double fSPhi=CLHEP::pi+fPhi;
    pSolMass=new GeoTubs(fRMin,fRMax,0.5*fLength,fSPhi,fDPhi);
 
    sprintf(szLabel,"%s_LogRPMainTubusLMass",pszStationName);
    pLogTubus=new GeoLogVol(szLabel,pSolMass,m_MapMaterials[std::string("Steel_AFP")]); //XXX
    pPhysTubus=new GeoFullPhysVol(pLogTubus);
    sprintf(szLabel,"%s_LogRPMainTubusLMass",pszStationName);
    pPhysMotherVol->add(new GeoNameTag(szLabel));
    pPhysMotherVol->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransRPot*HepGeom::TranslateX3D(0.5*fLength+0.5*fMainTubusSteelPartLength)*HepGeom::RotateY3D(90*CLHEP::deg))));
    pPhysMotherVol->add(pPhysTubus);
 
 
    //Floor tubus -------------------------------------------------------------------------------------------------
    fLength=RPOT_FLOOR_THICKNESS;
    fRMin=0.0*CLHEP::mm;
    fRMax=RPOT_MAINTUBUS_INNERRADIUS+RPOT_MAINTUBUS_THICKNESS-RPOT_MAINTUBUS_WNDTHICKNESS;
    pSolTubus=new GeoTube(fRMin, fRMax, 0.5*fLength);
 
    //cut volume
    double fTrdHXLength1=RPOT_MAINTUBUS_INNERRADIUS+RPOT_MAINTUBUS_THICKNESS;
    double fTrdHXLength2=RPOT_MAINTUBUS_INNERRADIUS+RPOT_MAINTUBUS_THICKNESS;
    double fTrdHYLength2=0.5*RPOT_FLOOR_WNDWIDTH;
    double fTrdHYLength1=0.5*RPOT_FLOOR_WNDWIDTH-RPOT_FLOOR_WNDTHICKNESS*tan(RPOT_FLOOR_WNDFACET);
    double fTrdHZLength=0.5*(RPOT_FLOOR_THICKNESS-RPOT_FLOOR_WNDTHICKNESS);
    pSolCut=new GeoTrd(fTrdHXLength1,fTrdHXLength2,fTrdHYLength1,fTrdHYLength2,fTrdHZLength);
    GeoTrf::Transform3D TransCut=GeoTrf::TranslateZ3D(0.5*fLength-fTrdHZLength);
    pMoveCut=new GeoShapeShift(pSolCut, TransCut);
    GeoShapeSubtraction* pSolFloor=new GeoShapeSubtraction(pSolTubus, pMoveCut);
 
    sprintf(szLabel,"%s_LogRPFloorTubus",pszStationName);
    pLogTubus=new GeoLogVol(szLabel,pSolFloor,m_MapMaterials[std::string("Beryllium_AFP")]);
    pPhysTubus=new GeoFullPhysVol(pLogTubus);
    sprintf(szLabel,"%s_RPFloorTubus",pszStationName);
    pPhysMotherVol->add(new GeoNameTag(szLabel));
    pPhysMotherVol->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransRPot*HepGeom::TranslateX3D(0.5*fMainTubusSteelPartLength+RPOT_MAINTUBUS_FLOORPARTLENGTH+0.5*RPOT_FLOOR_THICKNESS)*HepGeom::RotateY3D(90*CLHEP::deg))));
    pPhysMotherVol->add(pPhysTubus);
 
    //Flange tubus -------------------------------------------------------------------------------------------------
    fLength=RPOT_FLANGE_THICKNESS;
    fRMin=RPOT_MAINTUBUS_INNERRADIUS;
    fRMax=RPOT_FLANGE_OUTERRADIUS;
 
    pSolTubus=new GeoTube(fRMin, fRMax, 0.5*fLength);
    sprintf(szLabel,"%s_LogRPFlangeTubus",pszStationName);
    pLogTubus=new GeoLogVol(szLabel,pSolTubus,m_MapMaterials[std::string("Steel_AFP")]);
    pPhysTubus=new GeoFullPhysVol(pLogTubus);
    sprintf(szLabel,"%s_RPFlangeTubus",pszStationName);
    pPhysMotherVol->add(new GeoNameTag(szLabel));
    pPhysMotherVol->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransRPot*HepGeom::TranslateX3D(-0.5*fMainTubusSteelPartLength-0.5*RPOT_FLANGE_THICKNESS)*HepGeom::RotateY3D(90*CLHEP::deg))));
    pPhysMotherVol->add(pPhysTubus);
 
}

◆ addSensor()

void AFP_GeoModelFactory::addSensor	(	const char *	pszStationName,
		const int	nQuarticID,
		GeoOpticalPhysVol *	pPhysMotherVolume,
		HepGeom::Transform3D &	TransInMotherVolume,
		GeoBorderSurfaceContainer *	bsContainer )

private

Definition at line 246 of file AFP_GeoModelTD.cxx.

{
    int i,j,nPixelID;
    char szlabel[64];
    double fX1Pos, fX2Pos;
    HepGeom::Transform3D TotTransform;
 
    eAFPStation eStation=m_pGeometry->parseStationName(pszStationName);
    AFP_TDCONFIGURATION TofCfg=m_CfgParams.tdcfg[eStation];
    double fSensor2BarDistance=(TofCfg.bEmulateImmersion)? 0.0:AFP_CONSTANTS::ToF_Sensor2BarDist;
    if(m_addSeparationWindow)
    {
        fSensor2BarDistance += AFP_CONSTANTS::ToF_SeparationWindowThickness;
    }
 
    GeoBox* pSolSensor=new GeoBox(0.5*TofCfg.fPixelX1Dim,0.5*AFP_CONSTANTS::ToF_SensorThickness,0.5*TofCfg.fPixelX2Dim);
 
    for(i=0;i<TofCfg.nX1PixCnt;i++)
    {
        for(j=0;j<TofCfg.nX2PixCnt;j++)
        {
            nPixelID=10*(i+1)+(j+1);
            m_pGeometry->getPixelLocalPosition(eStation,nPixelID,&fX1Pos,&fX2Pos);
 
            sprintf(szlabel,"%s_Q%i_LogTDSensor[%i]",pszStationName,nQuarticID,nPixelID);
            TotTransform=TransInMotherVolume*HepGeom::Translate3D(fX1Pos,-0.5*AFP_CONSTANTS::ToF_SensorThickness-fSensor2BarDistance,fX2Pos);
            GeoLogVol* pLogSensor=new GeoLogVol(szlabel,pSolSensor,m_MapMaterials["SiliconPMT"]);
            GeoOpticalPhysVol* pPhysSensor=new GeoOpticalPhysVol(pLogSensor);
            sprintf(szlabel,"%s_Q%i_TDSensor[%i]",pszStationName,nQuarticID,nPixelID);
            pPhysMotherVolume->add(new GeoNameTag(szlabel));
            pPhysMotherVolume->add(new GeoTransform(Amg::CLHEPTransformToEigen(TotTransform)));
            pPhysMotherVolume->add(pPhysSensor);
            sprintf(szlabel,"%s_Q%i_SensorSurface[%i]",pszStationName,nQuarticID,nPixelID);
            bsContainer->push_back(GeoBorderSurface(szlabel, pPhysSensor, pPhysMotherVolume, m_pOpticalSurface));
 
            pPhysSensor=nullptr;
        }
    }
 
}

◆ addSepRadLBar()

void AFP_GeoModelFactory::addSepRadLBar	(	const char *	pszStationName,
		const int	nQuarticID,
		const int	nBarID,
		GeoOpticalPhysVol *	pPhysMotherVolume,
		HepGeom::Transform3D &	TransInMotherVolume,
		GeoBorderSurfaceContainer *	bsContainer )

private

Definition at line 91 of file AFP_GeoModelTD.cxx.

{
    double fX1Pos,fX2Pos,falpha,fd;
    HepGeom::Vector3D<double> vecA1, vecA2, vecX;
    CLHEP::Hep3Vector vecCutShift;
    HepGeom::Transform3D TransCut;
    GeoShapeShift* pMoveCut;
    GeoBox* pSolAux;
    char szlabel[64];
 
    CLHEP::HepRotation Rot1,Rot2,Rot3;
 
    eAFPStation eStation=m_pGeometry->parseStationName(pszStationName);
    AFP_TDCONFIGURATION TofCfg=m_CfgParams.tdcfg[eStation];
    AFPTOF_LBARDIMENSIONS BarDims=TofCfg.mapBarDims[nBarID];
 
    double fTaperOffset=TofCfg.mapTrainInfo[BarDims.nTrainID].fTaperOffset;
    m_pGeometry->getPixelLocalPosition(eStation,nBarID,&fX1Pos,&fX2Pos);
 
    fX1Pos+=TofCfg.mapTrainInfo[BarDims.nTrainID].fPerpShiftInPixel;
 
    
    //Light guide
    HepGeom::Transform3D TotTransform=TransInMotherVolume*HepGeom::Translate3D( fX1Pos,
                                                                                0.5*BarDims.fLGuideLength,
                                                                                fX2Pos);
    GeoShape* pSolVolume=new GeoBox(0.5*BarDims.fLGuideWidth,0.5*BarDims.fLGuideLength,0.5*BarDims.fLBarThickness);
 
    if(TofCfg.mapTrainInfo[BarDims.nTrainID].bUseTaper)
    {
        falpha=TofCfg.mapTrainInfo[BarDims.nTrainID].fTaperAngle;
        fd=fTaperOffset/std::sin(falpha);
        vecA1=-fd*std::cos(falpha)*CLHEP::Hep3Vector(0.0,1.0,0.0);
        vecA2=+0.5*fd*std::sqrt(2.0)*(CLHEP::HepRotationZ(+(45*CLHEP::deg-falpha))*CLHEP::Hep3Vector(0.0,1.0,0.0)).unit();
        vecX=vecA1+vecA2;
        vecCutShift=CLHEP::Hep3Vector(-0.5*BarDims.fLGuideWidth,0.5*BarDims.fLGuideLength,0.0)+CLHEP::Hep3Vector(vecX);
        Rot1.rotateZ(-falpha);
 
        pSolAux=new GeoBox(0.5*fd,0.5*fd,0.5*BarDims.fLBarThickness+SLIMCUT);
        TransCut=HepGeom::Transform3D(Rot1,vecCutShift);
        pMoveCut=new GeoShapeShift(pSolAux, Amg::CLHEPTransformToEigen(TransCut));
        pSolVolume=new GeoShapeSubtraction(pSolVolume, pMoveCut);
    }
 
    sprintf(szlabel,"%s_Q%i_LogLGuide[%i]",pszStationName,nQuarticID,nBarID);
    GeoLogVol* pLogLGuide=new GeoLogVol(szlabel,pSolVolume,m_MapMaterials[std::string("Quartz")]);
    GeoOpticalPhysVol* pPhysLGuide=new GeoOpticalPhysVol(pLogLGuide);
    sprintf(szlabel,"%s_Q%i_LGuide[%i]",pszStationName,nQuarticID,nBarID);
    pPhysMotherVolume->add(new GeoNameTag(szlabel));
    pPhysMotherVolume->add(new GeoTransform(Amg::CLHEPTransformToEigen(TotTransform)));
    pPhysMotherVolume->add(pPhysLGuide);
    sprintf(szlabel,"%s_Q%i_LGuideSurface[%i]",pszStationName,nQuarticID,nBarID);
    bsContainer->push_back(GeoBorderSurface(szlabel, pPhysLGuide, pPhysMotherVolume, m_pOpticalSurface));
 
    //Radiator elbow
    double fRadYDim=BarDims.fRadYDim;
    double fElbowXDim=fRadYDim;
    TotTransform=TransInMotherVolume*HepGeom::Translate3D(  fX1Pos-0.5*BarDims.fLGuideWidth+0.5*fElbowXDim+fTaperOffset,
                                                            BarDims.fLGuideLength+0.5*fRadYDim,
                                                            fX2Pos);
    pSolVolume=new GeoBox(0.5*fElbowXDim,0.5*fRadYDim,0.5*BarDims.fLBarThickness);
 
    falpha=45.0*CLHEP::deg;
    fd=fRadYDim/std::sin(falpha);//std::sqrt(2.0)*fRadYDim;
    vecA1=-fd*std::cos(falpha)*CLHEP::Hep3Vector(0.0,1.0,0.0);
    vecA2=+0.5*fd*std::sqrt(2.0)*(CLHEP::HepRotationZ(+(45*CLHEP::deg-falpha))*CLHEP::Hep3Vector(0.0,1.0,0.0)).unit();
    vecX=vecA1+vecA2;
    vecCutShift=CLHEP::Hep3Vector(-0.5*fElbowXDim,0.5*fRadYDim,0.0)+CLHEP::Hep3Vector(vecX);
    Rot2.rotateZ(-falpha);
 
    pSolAux=new GeoBox(0.5*fd,0.5*fd,0.5*BarDims.fLBarThickness+SLIMCUT);
    TransCut=HepGeom::Transform3D(Rot2,vecCutShift);
    pMoveCut=new GeoShapeShift(pSolAux, Amg::CLHEPTransformToEigen(TransCut));
    pSolVolume=new GeoShapeSubtraction(pSolVolume, pMoveCut);
 
    sprintf(szlabel,"%s_Q%i_LogRadiator[%i]",pszStationName,nQuarticID,nBarID);
    GeoLogVol* pLogRadiator=new GeoLogVol(szlabel,pSolVolume,m_MapMaterials[std::string("Quartz")]);
    GeoOpticalPhysVol* pPhysRadiator=new GeoOpticalPhysVol(pLogRadiator);
    sprintf(szlabel,"%s_Q%i_Radiator[%i]",pszStationName,nQuarticID,nBarID);
    pPhysMotherVolume->add(new GeoNameTag(szlabel));
    pPhysMotherVolume->add(new GeoTransform(Amg::CLHEPTransformToEigen(TotTransform)));
    pPhysMotherVolume->add(pPhysRadiator);
    sprintf(szlabel,"%s_Q%i_RadiatorElbowSurface[%i]",pszStationName,nQuarticID,nBarID);
    bsContainer->push_back(GeoBorderSurface(szlabel, pPhysRadiator, pPhysMotherVolume, m_pReflectionOptSurface));
 
    //Radiator
    double fRadLength=BarDims.fRadLength-(BarDims.fLGuideWidth-fTaperOffset);
    TotTransform=TransInMotherVolume*HepGeom::Translate3D(  fX1Pos-0.5*BarDims.fLGuideWidth+fElbowXDim+fTaperOffset+0.5*fRadLength,
                                                            BarDims.fLGuideLength+0.5*fRadYDim,
                                                            fX2Pos);
    pSolVolume=new GeoBox(0.5*fRadLength,0.5*fRadYDim,0.5*BarDims.fLBarThickness);
    
    if(TofCfg.bApplyBottomCut){
        falpha = TofCfg.fAlpha;
        fd = BarDims.fLBarThickness/std::sin(falpha);
        vecA1 = -fd*std::cos(falpha)*CLHEP::Hep3Vector(1.0,0.0,0.0);
        vecA2 = 0.5*fd*std::sqrt(2.0)*(CLHEP::HepRotationY(-(45*CLHEP::deg-falpha))*CLHEP::Hep3Vector(1.0,0.0,0.0)).unit();
        vecX = vecA1 + vecA2;
        vecCutShift = CLHEP::Hep3Vector(0.5*fRadLength,0.0,0.5*BarDims.fLBarThickness) + CLHEP::Hep3Vector(vecX);
        Rot3.rotateY(falpha);
 
        pSolAux=new GeoBox(0.5*fd,0.5*fRadYDim+SLIMCUT,0.5*fd);
        TransCut=HepGeom::Transform3D(Rot3,vecCutShift);
        pMoveCut=new GeoShapeShift(pSolAux, Amg::CLHEPTransformToEigen(TransCut));
        pSolVolume=new GeoShapeSubtraction(pSolVolume, pMoveCut);
    }
 
    sprintf(szlabel,"%s_Q%i_LogRadiator[%i]",pszStationName,nQuarticID,nBarID);
    pLogRadiator=new GeoLogVol(szlabel,pSolVolume,m_MapMaterials[std::string("Quartz")]);
    pPhysRadiator=new GeoOpticalPhysVol(pLogRadiator);
    sprintf(szlabel,"%s_Q%i_Radiator[%i]",pszStationName,nQuarticID,nBarID);
    pPhysMotherVolume->add(new GeoNameTag(szlabel));
    pPhysMotherVolume->add(new GeoTransform(Amg::CLHEPTransformToEigen(TotTransform)));
    pPhysMotherVolume->add(pPhysRadiator);
    sprintf(szlabel,"%s_Q%i_RadiatorSurface[%i]",pszStationName,nQuarticID,nBarID);
    bsContainer->push_back(GeoBorderSurface(szlabel, pPhysRadiator, pPhysMotherVolume, m_pOpticalSurface));
}

◆ addSiDetector()

void AFP_GeoModelFactory::addSiDetector	(	GeoPhysVol *	pPhysMotherVol,
		const char *	pszStationName,
		HepGeom::Transform3D &	TransInMotherVolume )

private

Definition at line 41 of file AFP_GeoModelSID.cxx.

{
    std::string szLabel;
    GeoLogVol* pLogElement=nullptr;
    GeoFullPhysVol* pPhysElement;
    eAFPStation eStation=m_pGeometry->parseStationName(pszStationName);
    AFP_SIDCONFIGURATION sidcfg=m_CfgParams.sidcfg[eStation];
    
    //create (constant) solids
    GeoShape* pSolidSIDPlate=createSolidSIDPlate();
    GeoShape* pSolidSIDSensor=new GeoBox(0.5*AFP_CONSTANTS::SiT_Pixel_length_totx,0.5*AFP_CONSTANTS::SiT_Pixel_length_toty,0.5*AFP_CONSTANTS::SiT_Pixel_thickness);
    GeoShape* pSolidSIDVacuumSensor=new GeoBox(0.5*180.0*CLHEP::mm,0.5*160.0*CLHEP::mm,0.5*AFP_CONSTANTS::Stat_GlobalVacuumSensorThickness);
 
    //add global vacuum sensitive volume (ID=11)
    int nSpecVacSensorID=AFP_CONSTANTS::Stat_GlobalVacuumSensorID;
    szLabel = std::format("{}_LogSIDVacuumSensor[{}]",pszStationName,nSpecVacSensorID);
    GeoLogVol* pLogSIDVacuumSensor=new GeoLogVol(szLabel,pSolidSIDVacuumSensor,m_MapMaterials[std::string("std::Vacuum")]);
    GeoFullPhysVol* pPhysSIDVacuumSensor=new GeoFullPhysVol(pLogSIDVacuumSensor);
    szLabel = std::format("{}_SIDVacuumSensor[{}]",pszStationName,nSpecVacSensorID);
    pPhysMotherVol->add(new GeoNameTag(szLabel));
    pPhysMotherVol->add(new GeoTransform(Amg::CLHEPTransformToEigen(m_pGeometry->getSIDTransform(ESTT_VACUUMSENSOR,pszStationName,nSpecVacSensorID))));
    pPhysMotherVol->add(pPhysSIDVacuumSensor);
    
    
    for(int i=0;i<m_pGeometry->getSIDPlatesCnt(eStation);i++)
    {
        // create SID plate
        szLabel = std::format("{}_LogSIDPlate[{}]",pszStationName,i);
        pLogElement=new GeoLogVol(szLabel,pSolidSIDPlate,m_MapMaterials[std::string("CE7")]);
        pPhysElement=new GeoFullPhysVol(pLogElement);
        szLabel = std::format("{}_SIDPlate[{}]",pszStationName,i);
        pPhysMotherVol->add(new GeoNameTag(szLabel));
        pPhysMotherVol->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransInMotherVolume*m_pGeometry->getSIDTransform(ESTT_PLATE,pszStationName,i))));
        pPhysMotherVol->add(pPhysElement);
 
        // create SID chip
        GeoShape* pSolidFEI4Chip=new GeoBox(0.5*sidcfg.vecChipXLength[i],0.5*sidcfg.vecChipYLength[i],0.5*AFP_CONSTANTS::SiT_Chip_thickness);
        szLabel = std::format("{}_LogSIDChip[{}]",pszStationName,i);
        pLogElement=new GeoLogVol(szLabel,pSolidFEI4Chip,m_MapMaterials[std::string("CE7")]);
        pPhysElement=new GeoFullPhysVol(pLogElement);
        szLabel = std::format("{}_SIDChip[{}]",pszStationName,i);
        pPhysMotherVol->add(new GeoNameTag(szLabel));
        pPhysMotherVol->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransInMotherVolume*m_pGeometry->getSIDTransform(ESTT_FEI4CHIP,pszStationName,i))));
        pPhysMotherVol->add(pPhysElement);
 
        // create SID sensor (pixel area)
        szLabel = std::format("{}_LogSIDSensor[{}]",pszStationName,i);
        pLogElement=new GeoLogVol(szLabel,pSolidSIDSensor,m_MapMaterials[std::string("Silicon")]);
        pPhysElement=new GeoFullPhysVol(pLogElement);
        szLabel = std::format("{}_SIDSensor[{}]",pszStationName,i);
        pPhysMotherVol->add(new GeoNameTag(szLabel));
        pPhysMotherVol->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransInMotherVolume*m_pGeometry->getSIDTransform(ESTT_SENSOR,pszStationName,i))));
        pPhysMotherVol->add(pPhysElement);
        
        if(m_CfgParams.sidcfg[eStation].bAddVacuumSensors)
        {
            // create logic SID Vacuum Layer
            szLabel = std::format("{}_LogSIDVacuumSensor[{}]",pszStationName,i);
            GeoLogVol* pLogSIDVacuumSensor=new GeoLogVol(szLabel,pSolidSIDVacuumSensor,m_MapMaterials[std::string("std::Vacuum")]);
            GeoFullPhysVol* pPhysSIDVacuumSensor=new GeoFullPhysVol(pLogSIDVacuumSensor);
 
            szLabel = std::format("{}_SIDVacuumSensor[{}]",pszStationName,i);
            pPhysMotherVol->add(new GeoNameTag(szLabel));
            pPhysMotherVol->add(new GeoTransform(Amg::CLHEPTransformToEigen(m_pGeometry->getSIDTransform(ESTT_VACUUMSENSOR,pszStationName,i))));
            pPhysMotherVol->add(pPhysSIDVacuumSensor);
        }
    }
}

◆ addTimingDetector()

StatusCode AFP_GeoModelFactory::addTimingDetector	(	const char *	pszStationName,
		GeoOpticalPhysVol *	pPhysMotherVol,
		HepGeom::Transform3D &	TransInMotherVolume,
		GeoBorderSurfaceContainer *	bsContainer )

private

Definition at line 58 of file AFP_GeoModelTD.cxx.

{
    int i,j,nPixelID;
    double fXShift,fYShift,fZShift;
 
    eAFPStation eStation=m_pGeometry->parseStationName(pszStationName);
    
    AFP_TDCONFIGURATION TofCfg=m_CfgParams.tdcfg[eStation];
    AFPTOF_LBARDIMENSIONS BarDims11=TofCfg.mapBarDims[11];
    fXShift=-73.5*CLHEP::mm; //FIXME TODO
    fYShift=(BarDims11.fRadLength+TofCfg.mapTrainInfo[BarDims11.nTrainID].fPerpShiftInPixel-0.5*(BarDims11.fLGuideWidth-TofCfg.mapTrainInfo[BarDims11.nTrainID].fTaperOffset)-0.5*BarDims11.fLBarThickness/std::tan(TofCfg.fAlpha))*std::sin(TofCfg.fAlpha);
    fZShift=std::fabs(fYShift)/std::tan(TofCfg.fAlpha)+0.5*BarDims11.fLBarThickness/std::sin(TofCfg.fAlpha);
    
    HepGeom::Transform3D TofTransform=TransInMotherVolume*HepGeom::Translate3D(fXShift,fYShift,fZShift)*HepGeom::RotateX3D((90.0*CLHEP::deg-TofCfg.fAlpha))*HepGeom::RotateZ3D(-90.0*CLHEP::deg);
 
    for(i=0;i<m_CfgParams.tdcfg[eStation].nX1PixCnt;i++)
    {
        for(j=0;j<m_CfgParams.tdcfg[eStation].nX2PixCnt;j++)
        {
            nPixelID=10*(i+1)+(j+1);
            addSepRadLBar(pszStationName,1,nPixelID,pPhysMotherVol,TofTransform,bsContainer);
        }
    }
 
    if(m_addSeparationWindow)
    {
        addLBarSensorSeparationWindow(pszStationName,1,pPhysMotherVol,TofTransform,bsContainer);
    }
    addSensor(pszStationName,1,pPhysMotherVol,TofTransform,bsContainer);
 
    return StatusCode::SUCCESS;
}

◆ create()

void AFP_GeoModelFactory::create ( GeoPhysVol * world )

virtual

Definition at line 216 of file AFP_GeoModelFactory.cxx.

{
    char szLabel[32];
    StatusCode SCode;
    m_pDetectorManager=new AFP_GeoModelManager();
    HepGeom::Transform3D TransEnvInWorld;
    HepGeom::Transform3D PosElementInEnv;
 
    //define materials
    defineMaterials();
 
    // Initialization of Surface Container for TD Surface(s)
    GeoBorderSurfaceContainer* pBSContainer = new GeoBorderSurfaceContainer();
    pBSContainer->reserve(AFP_CONSTANTS::ToF_TrainsCnt*AFP_CONSTANTS::ToF_ColumnsCnt);
 
    //AFP00 (SIDE A (+z)) ------------------------------------------------------------------------------------------------------------------------------------------------------
 
    //Optical Envelope
    TransEnvInWorld=m_pGeometry->getStationTransform("AFP00");
    const GeoBox* pBoxLongEnv= new GeoBox(150*mm, 150*CLHEP::mm, 280*CLHEP::mm);
    const GeoLogVol* pLogLongEnv = new GeoLogVol("AFP00_LogStationEnv", pBoxLongEnv, m_MapMaterials[std::string("OpticalVacuum")]);
    GeoOpticalPhysVol* pPhysLongEnv   = new GeoOpticalPhysVol(pLogLongEnv);
    sprintf(szLabel,"AFP00_StationEnv");
    world->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransEnvInWorld)));
    world->add(new GeoNameTag(szLabel));
    world->add(pPhysLongEnv);
    m_pDetectorManager->addTreeTop(pPhysLongEnv);
 
    //Roman Pot
    PosElementInEnv=m_pGeometry->getStationElementTransform("AFP00",ESE_RPOT);
    addRomanPot(pPhysLongEnv,"AFP00",PosElementInEnv);
 
    //Timing detector
    PosElementInEnv=m_pGeometry->getStationElementTransform("AFP00",ESE_TOF);
    SCode=addTimingDetector("AFP00",pPhysLongEnv,PosElementInEnv, pBSContainer);
 
    //Silicon detector
    PosElementInEnv=m_pGeometry->getStationElementTransform("AFP00",ESE_SID);
    addSiDetector(pPhysLongEnv,"AFP00",PosElementInEnv);
 
    //AFP01 (SIDE A (+z)) ------------------------------------------------------------------------------------------------------------------------------------------------------
    
    //add envelope -- short beampipe (station A)
    TransEnvInWorld=m_pGeometry->getStationTransform("AFP01");
    const GeoBox* pBoxShortEnv= new GeoBox(150*CLHEP::mm, 150*CLHEP::mm, 280*CLHEP::mm);
    const GeoLogVol* pLogShortEnv = new GeoLogVol("AFP01_LogStationEnv", pBoxShortEnv, m_MapMaterials[std::string("std::Vacuum")]);
    GeoPhysVol* pPhysShortEnv   = new GeoPhysVol(pLogShortEnv);
    sprintf(szLabel,"AFP01_StationEnv");
    world->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransEnvInWorld)));
    world->add(new GeoNameTag(szLabel));
    world->add(pPhysShortEnv);
    m_pDetectorManager->addTreeTop(pPhysShortEnv);
 
    //Roman Pot
    PosElementInEnv=m_pGeometry->getStationElementTransform("AFP01",ESE_RPOT);
    addRomanPot(pPhysShortEnv,"AFP01",PosElementInEnv);
 
    //Silicon detector
    PosElementInEnv=m_pGeometry->getStationElementTransform("AFP01",ESE_SID);
    addSiDetector(pPhysShortEnv,"AFP01",PosElementInEnv);
 
    //AFP02 (SIDE C (-z)) ------------------------------------------------------------------------------------------------------------------------------------------------------
 
    //add  envelope -- short beampipe (station C)
    TransEnvInWorld=m_pGeometry->getStationTransform("AFP02");
    const GeoBox* pBoxShortEnv1= new GeoBox(150*CLHEP::mm, 150*CLHEP::mm, 280*CLHEP::mm);
    const GeoLogVol* pLogShortEnv1 = new GeoLogVol("AFP02_LogStationEnv", pBoxShortEnv1, m_MapMaterials[std::string("std::Vacuum")]);
    GeoPhysVol* pPhysShortEnv1   = new GeoPhysVol(pLogShortEnv1);
    sprintf(szLabel,"AFP02_StationEnv");
    world->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransEnvInWorld)));
    world->add(new GeoNameTag(szLabel));
    world->add(pPhysShortEnv1);
    m_pDetectorManager->addTreeTop(pPhysShortEnv1);
 
    //Roman Pot
    PosElementInEnv=m_pGeometry->getStationElementTransform("AFP02",ESE_RPOT);
    addRomanPot(pPhysShortEnv1,"AFP02",PosElementInEnv);
 
    //Silicon detector
    PosElementInEnv=m_pGeometry->getStationElementTransform("AFP02",ESE_SID);
    addSiDetector(pPhysShortEnv1,"AFP02",PosElementInEnv);
 
    //AFP03 (SIDE C (-z)) ------------------------------------------------------------------------------------------------------------------------------------------------------
 
    // Optical Envelope
    TransEnvInWorld=m_pGeometry->getStationTransform("AFP03");
    const GeoBox* pBoxLongEnv1= new GeoBox(150*mm, 150*CLHEP::mm, 280*CLHEP::mm);
    const GeoLogVol* pLogLongEnv1 = new GeoLogVol("AFP03_LogStationEnv", pBoxLongEnv1, m_MapMaterials[std::string("OpticalVacuum")]);
    GeoOpticalPhysVol* pPhysLongEnv1   = new GeoOpticalPhysVol(pLogLongEnv1);
    sprintf(szLabel,"AFP03_StationEnv");
    world->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransEnvInWorld)));
    world->add(new GeoNameTag(szLabel));
    world->add(pPhysLongEnv1);
    m_pDetectorManager->addTreeTop(pPhysLongEnv1);
 
    //Roman Pot
    PosElementInEnv=m_pGeometry->getStationElementTransform("AFP03",ESE_RPOT);
    addRomanPot( pPhysLongEnv1,"AFP03",PosElementInEnv);
 
    //Timing detector
    PosElementInEnv=m_pGeometry->getStationElementTransform("AFP03",ESE_TOF);
    SCode=addTimingDetector("AFP03",pPhysLongEnv1,PosElementInEnv, pBSContainer);
 
    //Silicon detector
    PosElementInEnv=m_pGeometry->getStationElementTransform("AFP03",ESE_SID);
    addSiDetector(pPhysLongEnv1,"AFP03",PosElementInEnv);
 
 
 
    //---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
    // Register the Surface Container with the Detector Store
    SCode=m_pDetectorStore->record(pBSContainer, "AFP_GeoModel");
    if (SCode.isFailure()){
 
    }
}

◆ createSolidSIDPlate()

GeoShape * AFP_GeoModelFactory::createSolidSIDPlate ( )

private

Definition at line 111 of file AFP_GeoModelSID.cxx.

{
    MsgStream LogStream(Athena::getMessageSvc(), "AFP_GeoModelFactory::CreateSolidSIDPlate");
 
    double fdelta=0.01*CLHEP::mm;//0.01*CLHEP::mm;
 
    GeoBox* pMainPlate=new GeoBox(0.5*AFP_CONSTANTS::SiT_Plate_Main_length_x,0.5*AFP_CONSTANTS::SiT_Plate_Main_length_y,0.5*AFP_CONSTANTS::SiT_Plate_Main_thickness);
 
    //cut side edges
    double fd=std::sqrt(AFP_CONSTANTS::SiT_Plate_CutEdge_length_x*AFP_CONSTANTS::SiT_Plate_CutEdge_length_x+AFP_CONSTANTS::SiT_Plate_CutEdge_length_y*AFP_CONSTANTS::SiT_Plate_CutEdge_length_y);
    double falpha=std::atan(AFP_CONSTANTS::SiT_Plate_CutEdge_length_y/AFP_CONSTANTS::SiT_Plate_CutEdge_length_x);
    double fgamma=45.0*CLHEP::deg-falpha; double fbeta=90.0*CLHEP::deg-falpha;
 
    //--lower cut
    HepGeom::Vector3D<double> vecL=(fd/std::sqrt(2.0))*(HepGeom::RotateZ3D(-fgamma)*HepGeom::Vector3D<double>(1.0,0.0,0.0));
    HepGeom::Vector3D<double> vecB=AFP_CONSTANTS::SiT_Plate_CutEdge_length_x*HepGeom::Vector3D<double>(1.0,0.0,0.0);
    HepGeom::Vector3D<double> vecX=vecL-vecB;
    GeoBox* pPlateCut=new GeoBox(0.5*fd, 0.5*fd,0.5*(AFP_CONSTANTS::SiT_Plate_CutEdge_thickness+fdelta));
    HepGeom::Transform3D TransCut=HepGeom::Translate3D(vecX.x()+0.5*AFP_CONSTANTS::SiT_Plate_Main_length_x,vecX.y()-0.5*AFP_CONSTANTS::SiT_Plate_Main_length_y,0.0)*HepGeom::RotateZ3D(-fbeta);
    GeoShapeShift* pShiftCut=new GeoShapeShift(pPlateCut, Amg::CLHEPTransformToEigen(TransCut));
    GeoShapeSubtraction* pShape1=new GeoShapeSubtraction(pMainPlate, pShiftCut);
 
    //--upper cut
    vecL=(fd/std::sqrt(2.0))*(HepGeom::RotateZ3D(+fgamma)*HepGeom::Vector3D<double>(1.0,0.0,0.0));
    vecX=vecL-vecB;
    pPlateCut=new GeoBox(0.5*fd, 0.5*fd,0.5*(AFP_CONSTANTS::SiT_Plate_CutEdge_thickness+fdelta));
    TransCut=HepGeom::Translate3D(vecX.x()+0.5*AFP_CONSTANTS::SiT_Plate_Main_length_x,vecX.y()+0.5*AFP_CONSTANTS::SiT_Plate_Main_length_y,0.0)*HepGeom::RotateZ3D(+fbeta);
    pShiftCut=new GeoShapeShift(pPlateCut,Amg::CLHEPTransformToEigen(TransCut));
    GeoShapeSubtraction* pShape2=new GeoShapeSubtraction(pShape1, pShiftCut);
 
    //cut sensitive area
    pPlateCut=new GeoBox(0.5*(AFP_CONSTANTS::SiT_Plate_Window_length_x+fdelta),0.5*AFP_CONSTANTS::SiT_Plate_Window_length_y,0.5*AFP_CONSTANTS::SiT_Plate_Window_thickness);
    TransCut=HepGeom::Translate3D(AFP_CONSTANTS::SiT_Plate_Window_x+fdelta,AFP_CONSTANTS::SiT_Plate_Window_y,-(0.5*AFP_CONSTANTS::SiT_Plate_Main_thickness-0.5*AFP_CONSTANTS::SiT_Plate_Window_thickness));
    pShiftCut=new GeoShapeShift(pPlateCut,Amg::CLHEPTransformToEigen(TransCut));
    GeoShapeSubtraction* pShape3=new GeoShapeSubtraction(pShape2, pShiftCut);
 
    return pShape3;
}

◆ defineMaterials()

void AFP_GeoModelFactory::defineMaterials ( )

private

Definition at line 55 of file AFP_GeoModelFactory.cxx.

{
    int i;
    const double fWl2E=1239.85; //nm<->eV
    std::string matName;
    GeoMaterialPropertiesTable *pMPT=nullptr;
 
    StoredMaterialManager * materialManager = nullptr;
    if (StatusCode::SUCCESS != m_pDetectorStore->retrieve(materialManager, std::string("MATERIALS")))
    {
        return;
    }
 
    double aH,aC,aN,aSi,aP,aS,aCr,aMn,aFe,aNi,aMo,aAl,aO,Atot;
    const GeoElement* H  = materialManager->getElement("Hydrogen");
    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* Al = materialManager->getElement("Aluminium");
    const GeoElement* O = materialManager->getElement("Oxygen");
    const GeoElement* Be = materialManager->getElement("Beryllium");
 
    // vacuum
    matName = "std::Vacuum";
    const GeoMaterial *vacuum = materialManager->getMaterial(matName);
    m_MapMaterials.emplace(matName,vacuum);
 
    // optical vacuum
    matName = "OpticalVacuum";
    GeoExtendedMaterial* pMatOptVacuum=new GeoExtendedMaterial(matName, (1E-24)*CLHEP::g/CLHEP::cm3);
    pMatOptVacuum->add(const_cast<GeoElement*> (H), 1);
    double PhotonEnergyOptVac[2] = {0.44*CLHEP::eV, 6.3*CLHEP::eV};
    double RefractiveIndexOptVac[2] = {1.0, 1.0};
    double AbsorptionOptVac[2] ={1E-5*CLHEP::m, 1E-5*CLHEP::m};
 
    pMPT= new GeoMaterialPropertiesTable();
    pMPT->AddProperty("RINDEX", PhotonEnergyOptVac, RefractiveIndexOptVac , 2);
    pMPT->AddProperty("ABSLENGTH", PhotonEnergyOptVac, AbsorptionOptVac, 2);
    pMatOptVacuum->SetMaterialPropertiesTable(pMPT);
    pMatOptVacuum->lock();
    m_MapMaterials.emplace(matName,pMatOptVacuum);
 
    // Steel Grade 316L (Roman Pot)
    matName="Steel_AFP";
    GeoMaterial *steel=new GeoMaterial(matName, 8*g/cm3);
 
    aFe=62.045*Fe->getA()/(CLHEP::g/CLHEP::mole);
    aC =0.03*C ->getA()/(CLHEP::g/CLHEP::mole);
    aMn=2.0*Mn ->getA()/(CLHEP::g/CLHEP::mole);
    aSi=0.75*Si->getA()/(CLHEP::g/CLHEP::mole);
    aP =0.045*P->getA()/(CLHEP::g/CLHEP::mole);
    aS =0.03*S ->getA()/(CLHEP::g/CLHEP::mole);
    aCr=18.0*Cr->getA()/(CLHEP::g/CLHEP::mole);
    aMo=3.0*Mo ->getA()/(CLHEP::g/CLHEP::mole);
    aNi=14.0*Ni->getA()/(CLHEP::g/CLHEP::mole);
    aN =0.10*N ->getA()/(CLHEP::g/CLHEP::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.emplace(matName,steel);
 
    // CE7 70% Si, 30% Al
    matName="CE7";
    GeoMaterial *pMatCE7=new GeoMaterial(matName, 2.4*g/cm3);
    aSi=0.70*Si->getA()/(g/mole);
    aAl=0.30*Al->getA()/(g/mole);
    Atot=aSi+aAl;
    pMatCE7->add(const_cast<GeoElement*> (Si),aSi/Atot);
    pMatCE7->add(const_cast<GeoElement*> (Al),aAl/Atot);
    pMatCE7->lock();
    m_MapMaterials.emplace(matName,pMatCE7);
 
    // Quartz 70% SiO2 for TD Quartic (with refractive index and absorption length)
    matName="Quartz";
    GeoExtendedMaterial *pMatQuartz=new GeoExtendedMaterial(matName, 2.6*g/cm3, stateSolid, CLHEP::STP_Temperature);
    aSi=1.0*Si->getA()/(g/mole);
    aO=2.0*O->getA()/(g/mole);
    Atot=aSi+aO;
    pMatQuartz->add(const_cast<GeoElement*> (Si),aSi/Atot);
    pMatQuartz->add(const_cast<GeoElement*> (O),aO/Atot);
 
    // Defining the refractive index of quartz
    const int nEntriesCnt1=12; // (M.G.Albrow, JINST 2012) + extrapolation to 200.0 nm
    double arrEnergy1[nEntriesCnt1] = { 750.0*nm, 700.0*nm, 650.0*nm, 600.0*nm, 550.0*nm, 500.0*nm, 450.0*nm, 400.0*nm, 350.0*nm, 300.0*nm, 250.0*nm, 200.0*nm };
    double arrQuartzRefIndex[nEntriesCnt1] = { 1.450, 1.455, 1.456, 1.458, 1.460, 1.462, 1.465, 1.470, 1.475, 1.488, 1.510, 1.541 };
    double arrQuartzAbsLength[nEntriesCnt1] = { 130.0*cm, 130.0*cm, 130.0*cm, 130.0*cm, 128.0*cm, 125.0*cm, 122.0*cm, 120.0*cm, 111.0*cm, 104.0*cm, 95.0*cm, 83.3*cm };
    for(i=0;i<nEntriesCnt1;i++) arrEnergy1[i]=(fWl2E/(arrEnergy1[i]/nm))*eV;
 
    pMPT= new GeoMaterialPropertiesTable();
    pMPT->AddProperty("RINDEX", arrEnergy1, arrQuartzRefIndex, nEntriesCnt1);
    pMPT->AddProperty("ABSLENGTH", arrEnergy1, arrQuartzAbsLength, nEntriesCnt1);
    pMatQuartz->SetMaterialPropertiesTable(pMPT);
    pMatQuartz->lock();
    m_MapMaterials.emplace(matName,pMatQuartz);
 
    // Silicon for TD SiPMT (with refractive index)
    matName="SiliconPMT";
    GeoExtendedMaterial *pMatSiliconPMT=new GeoExtendedMaterial(matName, 2.3290*g/cm3, stateSolid, CLHEP::STP_Temperature);
    aSi=1.0*Si->getA()/(g/mole);
    pMatSiliconPMT->add(const_cast<GeoElement*> (Si),1.0);
 
    const int nEntriesCnt2=2;
    double arrEnergy2[nEntriesCnt2] = { 2800.0*nm, 190.0*nm };
    double arrSiliconRefIndex[nEntriesCnt2] = { 4.0, 4.0 };
    double arrSiliconAbsLength[nEntriesCnt2] = { 0.00001*m, 0.00001*m };
    for(i=0;i<nEntriesCnt2;i++) arrEnergy2[i]=(fWl2E/(arrEnergy2[i]/nm))*eV;
 
    pMPT = new GeoMaterialPropertiesTable();
    pMPT->AddProperty("RINDEX", arrEnergy2, arrSiliconRefIndex, nEntriesCnt2);
    pMPT->AddProperty("ABSLENGTH", arrEnergy2, arrSiliconAbsLength, nEntriesCnt2);
    pMatSiliconPMT->SetMaterialPropertiesTable(pMPT);
    pMatSiliconPMT->lock();
    m_MapMaterials.emplace(matName,pMatSiliconPMT);
 
 
    // Silicon
    matName="Silicon";
    GeoMaterial *pMatSilicon=new GeoMaterial(matName, 2.3290*g/cm3);
    aSi=1.0*Si->getA()/(g/mole);
    pMatSilicon->add(const_cast<GeoElement*> (Si),1.0);
    pMatSilicon->lock();
    m_MapMaterials.emplace(matName,pMatSilicon);
 
    // Water
    matName="Water";
    GeoMaterial *pMatWater=new GeoMaterial(matName, 1.0*g/cm3);
    aH=0.11*Si->getA()/(g/mole);
    aO=0.89*Al->getA()/(g/mole);
    Atot=aH+aO;
    pMatWater->add(const_cast<GeoElement*> (H),aH/Atot);
    pMatWater->add(const_cast<GeoElement*> (O),aO/Atot);
    pMatWater->lock();
    m_MapMaterials.emplace(matName,pMatWater);
 
    // Beryllium
    matName="Beryllium_AFP";
    GeoMaterial* pMaterialBe=new GeoMaterial(matName, 1.848*CLHEP::g/CLHEP::cm3);
 
    pMaterialBe->add(const_cast<GeoElement*> (Be), 1);
    pMaterialBe->lock();
    m_MapMaterials.emplace(matName,pMaterialBe);
}

◆ getBarShift()

HepGeom::Vector3D< double > AFP_GeoModelFactory::getBarShift	(	AFPTOF_LBARDIMENSIONS &	LQBarDims,
		eLBarType	eSpecType = ELBT_UNDEFINED )

private

◆ getDetectorManager()

const AFP_GeoModelManager * AFP_GeoModelFactory::getDetectorManager ( ) const

virtual

Definition at line 334 of file AFP_GeoModelFactory.cxx.

{
    return m_pDetectorManager;
}

◆ getLQBarDimensions()

void AFP_GeoModelFactory::getLQBarDimensions	(	const int	nRowID,
		const int	nColID,
		AFPTOF_LBARDIMENSIONS *	pLQBarDims )

private

◆ initializeTDParameters()

void AFP_GeoModelFactory::initializeTDParameters ( )

private

Definition at line 45 of file AFP_GeoModelTD.cxx.

{
    // Surface definition (preliminary)
    m_pOpticalSurface = new GeoOpticalSurface("TDQuarticOpticalSurface", GeoOpticalSurface::unified, GeoOpticalSurface::polished, GeoOpticalSurface::dielectric_dielectric, GeoOpticalSurface::polished);
 
    m_pReflectionOptSurface=new GeoOpticalSurface("AirLightGuideSurface", GeoOpticalSurface::unified, GeoOpticalSurface::polished, GeoOpticalSurface::dielectric_metal, GeoOpticalSurface::polished);
    GeoMaterialPropertiesTable* pMPT=new GeoMaterialPropertiesTable();
    double pfEnergy1[2]={ 1.62*CLHEP::eV, 6.20*CLHEP::eV };
    double pfReflectivity1[2]={ 0.9, 0.9};
    pMPT->AddProperty("REFLECTIVITY",pfEnergy1,pfReflectivity1,2);
    m_pReflectionOptSurface->SetMaterialPropertiesTable(pMPT);
}

◆ operator=()

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

private

◆ updatePositions()

void AFP_GeoModelFactory::updatePositions ( AFP_BPMCOOLPARAMS * pBpmParams )

Definition at line 340 of file AFP_GeoModelFactory.cxx.

{
 
}

Member Data Documentation

◆ m_addSeparationWindow

const bool AFP_GeoModelFactory::m_addSeparationWindow {}

private

Definition at line 69 of file AFP_GeoModelFactory.h.

69{};

◆ m_CfgParams

AFP_CONFIGURATION AFP_GeoModelFactory::m_CfgParams

private

Definition at line 67 of file AFP_GeoModelFactory.h.

◆ m_MapMaterials

std::map<std::string, GeoRef<const GeoMaterial> > AFP_GeoModelFactory::m_MapMaterials

private

Definition at line 53 of file AFP_GeoModelFactory.h.

◆ m_MapShape

std::map<std::string,const GeoShape*> AFP_GeoModelFactory::m_MapShape

private

Definition at line 66 of file AFP_GeoModelFactory.h.

◆ m_pDetectorManager

AFP_GeoModelManager* AFP_GeoModelFactory::m_pDetectorManager {}

private

Definition at line 62 of file AFP_GeoModelFactory.h.

62{};

◆ m_pDetectorStore

StoreGateSvc* AFP_GeoModelFactory::m_pDetectorStore {}

private

Definition at line 63 of file AFP_GeoModelFactory.h.

63{};

◆ m_pGeometry

AFP_Geometry* AFP_GeoModelFactory::m_pGeometry {}

private

Definition at line 68 of file AFP_GeoModelFactory.h.

68{};

◆ m_pOpticalSurface

GeoIntrusivePtr<GeoOpticalSurface> AFP_GeoModelFactory::m_pOpticalSurface {}

private

Definition at line 77 of file AFP_GeoModelFactory.h.

77{};

◆ m_pReflectionOptSurface

GeoIntrusivePtr<GeoOpticalSurface> AFP_GeoModelFactory::m_pReflectionOptSurface {}

private

Definition at line 78 of file AFP_GeoModelFactory.h.

78{};

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ AFP_GeoModelFactory() [1/2]

◆ ~AFP_GeoModelFactory()

◆ AFP_GeoModelFactory() [2/2]

Member Function Documentation

◆ addHorizontalArm()

◆ addLBarSensorSeparationWindow()

◆ addLQBarSegment()

◆ addRomanPot()

◆ addSensor()

◆ addSepRadLBar()

◆ addSiDetector()

◆ addTimingDetector()

◆ create()

◆ createSolidSIDPlate()

◆ defineMaterials()

◆ getBarShift()

◆ getDetectorManager()

◆ getLQBarDimensions()

◆ initializeTDParameters()

◆ operator=()

◆ updatePositions()

Member Data Documentation

◆ m_addSeparationWindow

◆ m_CfgParams

◆ m_MapMaterials

◆ m_MapShape

◆ m_pDetectorManager

◆ m_pDetectorStore

◆ m_pGeometry

◆ m_pOpticalSurface

◆ m_pReflectionOptSurface