Athena service for constructing the AtlasField object. More...

#include <StandardFieldSvc.h>

Inheritance diagram for StandardFieldSvc:

Collaboration diagram for StandardFieldSvc:

Public Member Functions
	StandardFieldSvc (const std::string &name, ISvcLocator *pSvcLocator)
	Standard constructor. More...

	~StandardFieldSvc ()=default
	Empty destructor. More...

StatusCode	initialize () override final
	Athena method. called at initialization time, being customized here. More...

G4MagneticField *	getField () override final
	Retrieve a G4 magnetic field object. More...

Protected Member Functions
G4MagneticField *	makeField () override final
	Create/retrieve the AtlasField object. More...

Protected Attributes
thread_utils::ThreadLocalOwner< G4MagneticField >	m_fieldHolder
	Thread-local field object. More...

Private Member Functions
StatusCode	createFieldMap ()

bool	solenoidOn ()

bool	toroidOn ()

Private Attributes
Gaudi::Property< bool >	m_useMagFieldSvc

ServiceHandle< MagField::IMagFieldSvc >	m_magFieldSvc {this, "MagneticFieldSvc", ""}
	Handle to the the Forward ATLAS magnetic field service. More...

Gaudi::Property< std::string >	m_fullMapFilename
	map file names More...

Gaudi::Property< std::string >	m_soleMapFilename

Gaudi::Property< std::string >	m_toroMapFilename

Gaudi::Property< double >	m_mapSoleCurrent
	nominal current for the maps More...

Gaudi::Property< double >	m_mapToroCurrent

Gaudi::Property< double >	m_useSoleCurrent
	configurable current for map scaling More...

Gaudi::Property< double >	m_useToroCurrent

std::unique_ptr< MagField::AtlasFieldMap >	m_fieldMap

Detailed Description

Athena service for constructing the AtlasField object.

Definition at line 67 of file StandardFieldSvc.h.

Constructor & Destructor Documentation

◆ StandardFieldSvc()

StandardFieldSvc::StandardFieldSvc	(	const std::string &	name,
		ISvcLocator *	pSvcLocator
	)

Standard constructor.

Definition at line 23 of file StandardFieldSvc.cxx.

25 : G4MagFieldSvcBase(name, pSvcLocator)

26 {}

◆ ~StandardFieldSvc()

StandardFieldSvc::~StandardFieldSvc ( )

default

Empty destructor.

Member Function Documentation

◆ createFieldMap()

StatusCode StandardFieldSvc::createFieldMap ( )

private

Definition at line 76 of file StandardFieldSvc.cxx.

 {
   ATH_MSG_INFO( "StandardFieldSvc::createFieldMap" );
  
  
     // Select map file according to the value of the currents which indicate which map is 'on'
  
     // determine the map to load
     std::string mapFile;
     if ( solenoidOn() && toroidOn() ) mapFile = m_fullMapFilename;
     else if ( solenoidOn() )          mapFile = m_soleMapFilename;
     else if ( toroidOn() )            mapFile = m_toroMapFilename;
     else {
         // all magnets OFF. no need to read map
         return StatusCode::SUCCESS;
     }
  
     ATH_MSG_INFO ( "StandardFieldSvc::createFieldMap: Set map currents from FieldSvc: solenoid/toroid " 
                 <<  m_useSoleCurrent  << "," << m_useToroCurrent );
     ATH_MSG_INFO ( "StandardFieldSvc::createFieldMap: Use map file " << mapFile);
         
     // find the path to the map file
     std::string resolvedMapFile = PathResolver::find_file( mapFile, "DATAPATH" );
     if ( resolvedMapFile.empty() ) {
         ATH_MSG_ERROR( "StandardFieldSvc::createFieldMap: Field map file " << mapFile << " not found" );
         return StatusCode::FAILURE;
     }
     // Do checks and extract root file to initialize the map
     if ( resolvedMapFile.find(".root") == std::string::npos ) {
         ATH_MSG_ERROR("StandardFieldSvc::createFieldMap: input file name '" << resolvedMapFile << "' does not end with .root");
         return StatusCode::FAILURE;
     } 
  
     std::unique_ptr<TFile> rootfile = std::make_unique<TFile>(resolvedMapFile.c_str(), "OLD");
     if ( ! rootfile.get() ) {
         ATH_MSG_ERROR("StandardFieldSvc::createFieldMap: failed to open " << resolvedMapFile);
         return StatusCode::FAILURE;
     }
     if ( !rootfile->cd() ) {
         // could not make it current directory
         ATH_MSG_ERROR("StandardFieldSvc::createFieldMap: unable to cd() into the ROOT field map TFile");
         rootfile->Close();
         return StatusCode::FAILURE; 
     }
     // open the tree
     TTree* tree = (TTree*)rootfile->Get("BFieldMap");
     if ( tree == nullptr ) {
         // no tree
         ATH_MSG_ERROR("StandardFieldSvc::createFieldMap: TTree 'BFieldMap' does not exist in ROOT field map");
         rootfile->Close();
         return StatusCode::FAILURE;
     }
  
     // create map
     m_fieldMap = std::make_unique<MagField::AtlasFieldMap>();
  
     // initialize map
     if (!m_fieldMap->initializeMap( rootfile.get(), m_useSoleCurrent , m_useToroCurrent) ) {
         // failed to initialize the map
         ATH_MSG_ERROR("StandardFieldSvc::createFieldMap: unable to initialize the map for AtlasFieldMap for file " << resolvedMapFile);
         rootfile->Close();
         return StatusCode::FAILURE;
     }
     
     rootfile->Close();
  
     ATH_MSG_INFO( "StandardFieldSvc::createFieldMap: Initialized the field map from " << resolvedMapFile );
   return StatusCode::SUCCESS;
 }

◆ getField()

G4MagneticField * G4MagFieldSvcBase::getField ( )

finaloverrideinherited

Retrieve a G4 magnetic field object.

If one doesn't yet exist in the current thread, it will be created.

Definition at line 29 of file G4MagFieldSvcBase.cxx.

 {
   ATH_MSG_DEBUG("G4MagFieldSvcBase::getField");
  
   // Check if we already have a field setup for current thread
   auto field = m_fieldHolder.get();
   // If not, we create one
   if(!field) {
     field = makeField();
     m_fieldHolder.set(field);
   }
  
   return field;
 }

◆ initialize()

StatusCode StandardFieldSvc::initialize ( )

finaloverride

Athena method. called at initialization time, being customized here.

Definition at line 32 of file StandardFieldSvc.cxx.

 {
   ATH_MSG_INFO( "Initializing " << name() );
  
   // Either initialize the field map - used for solenoid and toroid, or the field service for the forward field
   if (m_useMagFieldSvc) {
       ATH_CHECK( m_magFieldSvc.retrieve() );
       ATH_MSG_INFO( "initialize: using field service  " << m_magFieldSvc.name() );
   }
   else {
       // Create field map
       ATH_CHECK( createFieldMap() );
       ATH_MSG_INFO( "initialize: using created map for field cache  ");
   }
  
   return StatusCode::SUCCESS;
 }

◆ makeField()

G4MagneticField * StandardFieldSvc::makeField ( )

finaloverrideprotectedvirtual

Create/retrieve the AtlasField object.

Implements G4MagFieldSvcBase.

Definition at line 53 of file StandardFieldSvc.cxx.

 {
   ATH_MSG_INFO( "StandardFieldSvc::makeField" );
  
   AtlasField* af{nullptr};
   
   // Either initialize the field map - used for solenoid and toroid, or the field service for the forward field
   if (m_useMagFieldSvc) {
     af = new AtlasField( &*m_magFieldSvc );
   }
   else {
     const double scaleSolenoid = m_mapSoleCurrent>0 ? m_useSoleCurrent / m_mapSoleCurrent : 1. ;
     const double scaleToroid    = m_mapToroCurrent>0 ? m_useToroCurrent / m_mapToroCurrent : 1. ;
     af = new AtlasField(scaleSolenoid, scaleToroid, m_fieldMap.get());
   }
   
   return (af);
 }

◆ solenoidOn()

bool StandardFieldSvc::solenoidOn ( )

inlineprivate

Definition at line 104 of file StandardFieldSvc.h.

104 { return (m_mapSoleCurrent > 0.0); }

◆ toroidOn()

bool StandardFieldSvc::toroidOn ( )

inlineprivate

Definition at line 105 of file StandardFieldSvc.h.

105 { return (m_mapToroCurrent > 0.0); }

Member Data Documentation

◆ m_fieldHolder

thread_utils::ThreadLocalOwner<G4MagneticField> G4MagFieldSvcBase::m_fieldHolder

protectedinherited

Thread-local field object.

Definition at line 48 of file G4MagFieldSvcBase.h.

◆ m_fieldMap

std::unique_ptr<MagField::AtlasFieldMap> StandardFieldSvc::m_fieldMap

private

Definition at line 129 of file StandardFieldSvc.h.

◆ m_fullMapFilename

Gaudi::Property<std::string> StandardFieldSvc::m_fullMapFilename

private

Initial value:

{this,
            "FullMapFile", "MagneticFieldMaps/bfieldmap_7730_20400_14m.root",
            "File storing the full magnetic field map"}

map file names

Definition at line 108 of file StandardFieldSvc.h.

◆ m_magFieldSvc

ServiceHandle<MagField::IMagFieldSvc> StandardFieldSvc::m_magFieldSvc {this, "MagneticFieldSvc", ""}

private

Handle to the the Forward ATLAS magnetic field service.

Definition at line 99 of file StandardFieldSvc.h.

◆ m_mapSoleCurrent

Gaudi::Property<double> StandardFieldSvc::m_mapSoleCurrent

private

Initial value:

{this,

"MapSoleCurrent", 7730., "Nominal solenoid current (A)"}

nominal current for the maps

Definition at line 118 of file StandardFieldSvc.h.

◆ m_mapToroCurrent

Gaudi::Property<double> StandardFieldSvc::m_mapToroCurrent

private

Initial value:

{this,

"MapToroCurrent", 20400., "Nominal toroid current (A)"}

Definition at line 120 of file StandardFieldSvc.h.

◆ m_soleMapFilename

Gaudi::Property<std::string> StandardFieldSvc::m_soleMapFilename

private

Initial value:

{this,
                                                    "SoleMapFile", "MagneticFieldMaps/bfieldmap_7730_0_14m.root",
                                                    "File storing the solenoid-only magnetic field map"}

Definition at line 111 of file StandardFieldSvc.h.

◆ m_toroMapFilename

Gaudi::Property<std::string> StandardFieldSvc::m_toroMapFilename

private

Initial value:

{this,
                                                    "ToroMapFile", "MagneticFieldMaps/bfieldmap_0_20400_14m.root",
                                                    "File storing the toroid-only magnetic field map"}

Definition at line 114 of file StandardFieldSvc.h.

◆ m_useMagFieldSvc

Gaudi::Property<bool> StandardFieldSvc::m_useMagFieldSvc

private

Initial value:

{this,

"UseMagFieldSvc", false, "Use magnetic field service - Should ONLY be used for ForwardRegionFieldSvc"}

Definition at line 95 of file StandardFieldSvc.h.

◆ m_useSoleCurrent

Gaudi::Property<double> StandardFieldSvc::m_useSoleCurrent

private

Initial value:

{this,

"UseSoleCurrent", 7730., "Configured solenoid current (A)"}

configurable current for map scaling

Definition at line 123 of file StandardFieldSvc.h.

◆ m_useToroCurrent

Gaudi::Property<double> StandardFieldSvc::m_useToroCurrent

private

Initial value:

{this,

"UseToroCurrent", 20400., "Configured toroid current (A)"}

Definition at line 125 of file StandardFieldSvc.h.

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

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ StandardFieldSvc()

◆ ~StandardFieldSvc()

Member Function Documentation

◆ createFieldMap()

◆ getField()

◆ initialize()

◆ makeField()

◆ solenoidOn()

◆ toroidOn()

Member Data Documentation

◆ m_fieldHolder

◆ m_fieldMap

◆ m_fullMapFilename

◆ m_magFieldSvc

◆ m_mapSoleCurrent

◆ m_mapToroCurrent

◆ m_soleMapFilename

◆ m_toroMapFilename

◆ m_useMagFieldSvc

◆ m_useSoleCurrent

◆ m_useToroCurrent