CrackDMConstruction Class Reference

#include <CrackDMConstruction.h>

Inheritance diagram for CrackDMConstruction:

Collaboration diagram for CrackDMConstruction:

Public Member Functions
	CrackDMConstruction ()=delete
	CrackDMConstruction (IRDBAccessSvc *rdbAccess, IGeoModelSvc *geoModel, StoredMaterialManager *materialManager, bool activateFT)
void	create (GeoFullPhysVol *envelope)
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Private Member Functions
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
IRDBAccessSvc *	m_rdbAccess {nullptr}
IGeoModelSvc *	m_geoModel {nullptr}
StoredMaterialManager *	m_materialManager {nullptr}
bool	m_activateFT {false}
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels).
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging).

Detailed Description

Definition at line 15 of file CrackDMConstruction.h.

Constructor & Destructor Documentation

CrackDMConstruction() [1/2]

CrackDMConstruction::CrackDMConstruction ( )

delete

CrackDMConstruction() [2/2]

CrackDMConstruction::CrackDMConstruction	(	IRDBAccessSvc *	rdbAccess,
		IGeoModelSvc *	geoModel,
		StoredMaterialManager *	materialManager,
		bool	activateFT )

Definition at line 848 of file CrackDMConstruction.cxx.

  : AthMessaging("CrackDMConstruction")
  , m_rdbAccess(rdbAccess)
  , m_geoModel(geoModel)
  , m_materialManager(materialManager)
  , m_activateFT(activateFT)
{
}

Member Function Documentation

create()

void CrackDMConstruction::create

(

GeoFullPhysVol *

envelope

)

Definition at line 860 of file CrackDMConstruction.cxx.

{
  createFromDB(envelope
           , m_rdbAccess
           , m_geoModel
           , m_materialManager);
 
  if(m_activateFT){
    std::string name = "LAr::Barrel::SignalFT::";
    ATH_MSG_DEBUG("creating " << name << " volumes");
 
    const GeoMaterial* iron = m_materialManager->getMaterial("std::Iron");
 
    const double wflange_height = 37.*Gaudi::Units::mm;
    const double wflange_R = 0.5*360.*Gaudi::Units::mm;
    const GeoMaterial* wflange_mat = m_materialManager->getMaterial("LAr::FT::WarmFlange");
 
    GeoShape* wflange = new GeoTube(0., wflange_R, wflange_height/2);
    GeoLogVol* wflangeLV = new GeoLogVol(name + "WarmFlange", wflange, wflange_mat);
    GeoPhysVol* wflangePV = new GeoPhysVol(wflangeLV);
 
    const double bellow_height = 225.*Gaudi::Units::mm;
    const double bellow_Router = 0.5*299.*Gaudi::Units::mm; // this also to be cut in warm wall
    const double bellow_wall = 15.*Gaudi::Units::mm;
    const GeoMaterial* bellow_mat = m_materialManager->getMaterial("LAr::FT::Bellow");
 
    const double bellow_Rinner = bellow_Router - bellow_wall;
    GeoShape* bellow = new GeoTube(bellow_Rinner, bellow_Router, bellow_height/2);
    GeoLogVol* bellowLV = new GeoLogVol(name + "Bellow", bellow, bellow_mat);
    GeoPhysVol* bellowPV = new GeoPhysVol(bellowLV);
 
    const GeoMaterial* vcables_mat = m_materialManager->getMaterial("LAr::FT::VacuumCables");
 
    GeoShape* vcables = new GeoTube(0., bellow_Rinner, bellow_height/2);
    GeoLogVol* vcablesLV = new GeoLogVol(name + "VacuumCables", vcables, vcables_mat);
    GeoPhysVol* vcablesPV = new GeoPhysVol(vcablesLV);
 
    const double cflange_height = 35.*Gaudi::Units::mm;
    const double cflange_Router = 0.5*283.*Gaudi::Units::mm;
    const GeoMaterial* cflange_mat = m_materialManager->getMaterial("LAr::FT::ColdFlange");
    GeoShape* cflange = new GeoTube(0., cflange_Router, cflange_height/2);
    GeoLogVol* cflangeLV = new GeoLogVol(name + "ColdFlange", cflange, cflange_mat);
    GeoPhysVol* cflangePV = new GeoPhysVol(cflangeLV);
 
    const double coldbox1_Router = cflange_Router;
    const double coldbox1_wall = 0.134*2.54*Gaudi::Units::cm;
    const double coldbox1_height = 90.*Gaudi::Units::mm;
    const double coldbox2_height = 16.*Gaudi::Units::mm;
    const double hole_r = 0.5*133.*Gaudi::Units::mm;
    const double hole_shift = -31.*Gaudi::Units::mm;
    const double coldbox3_Router = 0.5*140.*Gaudi::Units::mm; // this also to be cut in cold wall
    const double barrel_dist_from_outer_warm_wall_to_inner_cold_wall =
        500.*Gaudi::Units::mm;
    const double coldbox3_height = // adjust to match dist between cryo walls
        barrel_dist_from_outer_warm_wall_to_inner_cold_wall
        - bellow_height - coldbox1_height - coldbox2_height;
    ATH_MSG_DEBUG("funnel tube len = " << coldbox3_height / Gaudi::Units::mm << " mm ");
    const GeoMaterial* coldbox_mat = iron;
    GeoShape* coldbox1 = new GeoTube(coldbox1_Router - coldbox1_wall, coldbox1_Router, coldbox1_height/2); // wide part
    GeoLogVol* coldbox1LV = new GeoLogVol(name + "ColdBox1", coldbox1, coldbox_mat);
    GeoPhysVol* coldbox1PV = new GeoPhysVol(coldbox1LV);
    GeoShape* coldbox21 = new GeoTube(0., coldbox1_Router, coldbox2_height/2); // plate
    GeoShape* coldbox22 = new GeoTube(0., hole_r, coldbox2_height); // hole in the plate
    const GeoShape& coldbox2 = coldbox21->subtract((*coldbox22) << GeoTrf::TranslateY3D(hole_shift));
    GeoLogVol* coldbox2LV = new GeoLogVol(name + "ColdBox2", &coldbox2, coldbox_mat);
    GeoPhysVol* coldbox2PV = new GeoPhysVol(coldbox2LV);
    GeoShape* coldbox3 = new GeoTube(hole_r, coldbox3_Router, coldbox3_height/2); // narrow part
    GeoShape* coldbox31 = new GeoTube(0., coldbox3_Router, coldbox3_height/2); // narrow part for FTenvelope
    GeoLogVol* coldbox3LV = new GeoLogVol(name + "ColdBox3", coldbox3, coldbox_mat);
    GeoPhysVol* coldbox3PV = new GeoPhysVol(coldbox3LV);
 
    GeoTrf::TranslateZ3D bellow_pos(-wflange_height/2 - bellow_height/2);
    GeoTrf::TranslateZ3D cflange_pos(-wflange_height/2 - bellow_height - cflange_height/2);
    GeoTrf::TranslateZ3D coldbox1_pos(-wflange_height/2 - bellow_height - cflange_height - coldbox1_height/2);
    GeoTrf::TranslateZ3D coldbox2_pos(-wflange_height/2 - bellow_height - cflange_height - coldbox1_height - coldbox2_height/2);
    GeoTrf::Translate3D coldbox2hole_pos(
        0., hole_shift,
        -wflange_height/2 - bellow_height - cflange_height - coldbox1_height - coldbox2_height/2
    );
    GeoTrf::Translate3D coldbox3_pos(
        0., hole_shift,
        -wflange_height/2 - bellow_height - cflange_height - coldbox1_height - coldbox2_height - coldbox3_height/2
    );
 
    // The SignalFT air envelope is built as one coaxial polycone, plus one
    // boolean union with the non-coaxial ColdBox3 tube below.  From negative
    // to positive z, the polycone covers these coaxial envelope sections:
    // - z_min to the bellow: ColdBox2 plate, ColdBox1 and ColdFlange,
    //   all enclosed at coldbox1_Router;
    // - bellow: Bellow and VacuumCables, enclosed at bellow_Router;
    // - warm end: WarmFlange, enclosed at wflange_R.
    // Repeated z planes below encode the radius steps between these sections.
    GeoPcon* coaxialEnvelope = new GeoPcon(0., 360.*Gaudi::Units::deg);
    coaxialEnvelope->addPlane(
        -wflange_height/2 - bellow_height - cflange_height - coldbox1_height - coldbox2_height,
        0., coldbox1_Router
    );
    coaxialEnvelope->addPlane(
        -wflange_height/2 - bellow_height,
        0., coldbox1_Router
    );
    coaxialEnvelope->addPlane(
        -wflange_height/2 - bellow_height,
        0., bellow_Router
    );
    coaxialEnvelope->addPlane(
        -wflange_height/2,
        0., bellow_Router
    );
    coaxialEnvelope->addPlane(
        -wflange_height/2,
        0., wflange_R
    );
    coaxialEnvelope->addPlane(
        wflange_height/2,
        0., wflange_R
    );
 
    const GeoShape& FTenvelope = coaxialEnvelope->add((*coldbox31) << coldbox3_pos);
 
    GeoLogVol* FTLV = new GeoLogVol(name + "Envelope",
        &FTenvelope,
        m_materialManager->getMaterial("std::Air")
    );
    GeoPhysVol* FTPV = new GeoPhysVol(FTLV);
 
    FTPV->add(wflangePV);
    GeoTransform *bellow_trf = new GeoTransform(bellow_pos);
    FTPV->add(bellow_trf);
    FTPV->add(bellowPV);
    FTPV->add(bellow_trf);
    FTPV->add(vcablesPV);
    GeoTransform *cflange_trf = new GeoTransform(cflange_pos);
    FTPV->add(cflange_trf);
    FTPV->add(cflangePV);
    GeoTransform *coldbox1_trf = new GeoTransform(coldbox1_pos);
    FTPV->add(coldbox1_trf);
    FTPV->add(coldbox1PV);
    GeoTransform *coldbox2_trf = new GeoTransform(coldbox2_pos);
    FTPV->add(coldbox2_trf);
    FTPV->add(coldbox2PV);
    GeoTransform *coldbox3_trf = new GeoTransform(coldbox3_pos);
    FTPV->add(coldbox3_trf);
    FTPV->add(coldbox3PV);
 
    const GeoMaterial* lar_mat = m_materialManager->getMaterial("std::LiquidArgon");
    GeoShape* lar1 = new GeoTube(0., coldbox1_Router - coldbox1_wall, coldbox1_height/2);
    GeoShape* lar2 = new GeoTube(0., hole_r, coldbox1_height);
    const GeoShape& lar = lar1->subtract((*lar2) << GeoTrf::TranslateY3D(hole_shift));
    GeoLogVol* larLV = new GeoLogVol(name + "LAr", &lar, lar_mat);
    GeoPhysVol* larPV = new GeoPhysVol(larLV);
    FTPV->add(coldbox1_trf);
    FTPV->add(larPV);
 
    const GeoMaterial *pigtail_mat = m_materialManager->getMaterial("LAr::FT::Pigtail");
 
    const double pth = (coldbox1_height + coldbox2_height + coldbox3_height) / 2;
    GeoTransform *pigtail_trf = new GeoTransform(
        GeoTrf::Translate3D(0, hole_shift,
        -wflange_height/2 - bellow_height - cflange_height - pth
    ));
    GeoShape* pigtail = new GeoTube(0., hole_r, pth);
    GeoLogVol* pigtailLV = new GeoLogVol(name + "Pigtail", pigtail, pigtail_mat);
    GeoPhysVol* pigtailPV = new GeoPhysVol(pigtailLV);
    FTPV->add(pigtail_trf);
    FTPV->add(pigtailPV);
 
    // total lenght should be 28.5 cm
    const double ocable_len = 10.*Gaudi::Units::cm;
    const double ocable_R = (1.1/2)*sqrt(1920*2.85)*Gaudi::Units::mm;
    const GeoMaterial* ocable_mat = m_materialManager->getMaterial("LAr::FT::Cable");
    GeoShape* ocable = new GeoTube(0., ocable_R, ocable_len / 2);
    GeoLogVol* ocableLV = new GeoLogVol("LAr::Barrel::FTCables", ocable, ocable_mat);
    GeoPhysVol* ocablePV = new GeoPhysVol(ocableLV);
 
    // todo: take cryostat parameters from DB
    const double r0 = 277.5*Gaudi::Units::cm // cryo warm wall outer radius
                    + wflange_height/2; // warm flange is abobe the wall
    const double r2 = r0 + wflange_height/2 + ocable_len/2;
    const double z_pos = 3170.*Gaudi::Units::mm;
    const int NCrates = 16;
    const double dphi = 4.*Gaudi::Units::deg;
 
    auto put1 = [&envelope](GeoPhysVol *object, double r, double phi, double z)
    {
        envelope->add(new GeoTransform(
            GeoTrf::Translate3D(r*cos(phi), r*sin(phi), z) *
            GeoTrf::RotateX3D(90.*Gaudi::Units::deg) *
            GeoTrf::RotateY3D(phi + 90.*Gaudi::Units::deg)
        ));
        if(z < 0){
            envelope->add(new GeoTransform(GeoTrf::RotateZ3D(180.*Gaudi::Units::deg)));
        }
        envelope->add(object);
    };
 
    auto put = [&put1, &FTPV, &ocablePV, r0, r2](double phi, double z)
    {
        put1(FTPV, r0, phi, z);
        put1(ocablePV, r2, phi, z);
    };
 
    for(int i = 0; i < 16; ++ i){
        const double phi = 360.*Gaudi::Units::deg / NCrates * i;
        put(phi - dphi, z_pos);
        put(phi + dphi, z_pos);
        put(phi - dphi, -z_pos);
        put(phi + dphi, -z_pos);
    }
  }
 
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 167 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 182 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  // If user did not set explicit message level we have to initialize
  // the messaging and retrieve the default via the MessageSvc.
  if (m_lvl==MSG::NIL && !m_initialized.test_and_set()) initMessaging();
 
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging).

Definition at line 141 of file AthMessaging.h.

m_activateFT

bool CrackDMConstruction::m_activateFT {false}

private

Definition at line 30 of file CrackDMConstruction.h.

{false};

m_geoModel

IGeoModelSvc* CrackDMConstruction::m_geoModel {nullptr}

private

Definition at line 28 of file CrackDMConstruction.h.

{nullptr};

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_materialManager

StoredMaterialManager* CrackDMConstruction::m_materialManager {nullptr}

private

Definition at line 29 of file CrackDMConstruction.h.

{nullptr};

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels).

Definition at line 132 of file AthMessaging.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_rdbAccess

IRDBAccessSvc* CrackDMConstruction::m_rdbAccess {nullptr}

private

Definition at line 27 of file CrackDMConstruction.h.

{nullptr};

---

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

• CrackDMConstruction.h
• CrackDMConstruction.cxx