StandardFieldSvc Class Reference

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.
	~StandardFieldSvc ()=default
	Empty destructor.
StatusCode	initialize () override final
	Athena method. called at initialization time, being customized here.
G4MagneticField *	getField () override final
	Retrieve a G4 magnetic field object.

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

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.
Gaudi::Property< std::string >	m_fullMapFilename
	map file names
Gaudi::Property< std::string >	m_soleMapFilename
Gaudi::Property< std::string >	m_toroMapFilename
Gaudi::Property< double >	m_mapSoleCurrent
	nominal current for the maps
Gaudi::Property< double >	m_mapToroCurrent
Gaudi::Property< double >	m_useSoleCurrent
	configurable current for map scaling
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.

    : G4MagFieldSvcBase(name, pSvcLocator)     
{}

~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 31 of file G4MagFieldSvcBase.cxx.

{
  ATH_MSG_DEBUG("G4MagFieldSvcBase::getField");
 
  // create a thread-local magnetic field instance
  static thread_local std::unique_ptr<G4MagneticField> field{makeField()};
 
  return field.get();
}

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.

{ return (m_mapSoleCurrent > 0.0); }

toroidOn()

bool StandardFieldSvc::toroidOn ( )

inlineprivate

Definition at line 105 of file StandardFieldSvc.h.

{ return (m_mapToroCurrent > 0.0); }

Member Data Documentation

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.

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

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.

{this, "MagneticFieldSvc", ""};

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

---

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

• StandardFieldSvc.h
• StandardFieldSvc.cxx