//-----------------------------------------------------------------------------
StatusCode RootHistCnv::PersSvc::createRep(DataObject* pObject,
IOpaqueAddress*& refpAddress)
//-----------------------------------------------------------------------------
{
// There are objects in the HDS to be stored
if( m_outputEnabled && undefFileName != m_defFileName ) {
SmartDataPtr<DataObject> top(dataProvider(), stat_dir);
if ( 0 != top ) {
IRegistry* pReg = top->registry();
if ( pReg ) {
if ( top.ptr() == pObject ) {
TDirectory* pDir = m_hfile;
refpAddress = new RootObjAddress( repSvcType(),
CLID_DataObject,
stat_dir,
m_defFileName,
long(pDir),
long(0));
return StatusCode::SUCCESS;
}
else {
StatusCode sc = ConversionSvc::createRep(pObject, refpAddress);
if( sc.isFailure() ) {
MsgStream log( msgSvc(), name() );
log << MSG::ERROR
<< "Error while creating persistent Histogram:"
<< pReg->identifier()
<< endmsg;
}
return sc;
}
}
}
MsgStream err( msgSvc(), name() );
err << MSG::ERROR
<< "Internal error while creating Histogram persistent representations"
<< endmsg;
return StatusCode::FAILURE;
} else {
if (m_outputEnabled && !m_prtWar) {
m_prtWar = true;
MsgStream log( msgSvc(), name() );
log << MSG::WARNING
<< "no ROOT output file name, "
<< "Histograms cannot be persistified" << endmsg;
}
}
return StatusCode::SUCCESS;
}
// ============================================================================
// Initialization
// ============================================================================
StatusCode RecordOutputStream::initialize() {
StatusCode sc = GaudiAlgorithm::initialize(); // must be executed first
if ( sc.isFailure() ) return sc; // error printed already by GaudiAlgorithm
if ( msgLevel(MSG::DEBUG) ) debug() << "==> Initialize" << endmsg;
if (m_streamName.empty()) {
m_streamName = "Deferred:" + name();
debug() << "Using default OutputStreamName: '"
<< m_streamName << "'" << endmsg;
}
m_flagLocation = locationRoot() + "/" + m_streamName;
return StatusCode::SUCCESS;
}
StatusCode NoiseCaloCellsTool::initialize() {
StatusCode sc = GaudiTool::initialize();
if (sc.isFailure()) return sc;
//Initialize random service
if(service( "RndmGenSvc" , m_randSvc ).isFailure()) {
error() << "Couldn't get RndmGenSvc" << endmsg;
return StatusCode::FAILURE;
}
m_gauss.initialize(m_randSvc, Rndm::Gauss(0,m_cellNoise));
info() << "Sigma of the cell noise: " << m_cellNoise << " MeV" << endmsg;
info() << "Filter noise threshold: " << m_filterThreshold << "*sigma" << endmsg;
return sc;
}
// ============================================================================
StatusCode Gaudi::Parsers::parse
( std::vector<Gaudi::StringKey>& result ,
const std::string& input )
{
result.clear() ;
typedef std::vector<std::string> Strings ;
Strings _result ;
StatusCode sc = parse ( _result , input ) ;
if ( sc.isFailure() ) { return sc ; } // RETURN
result.reserve ( _result.size() ) ;
//
std::copy ( _result.begin() ,
_result.end () , std::back_inserter ( result ) ) ;
//
return StatusCode::SUCCESS ;
}
//------------------------------------------------------------------------------
StatusCode MyAlgorithm::initialize() {
//------------------------------------------------------------------------------
MsgStream log(msgSvc(), name());
StatusCode sc;
log << MSG::INFO << "initializing...." << endmsg;
sc = toolSvc()->retrieveTool(m_toolName, m_tool, this );
if( sc.isFailure() ) {
log << MSG::ERROR<< "Error retrieving the tool" << endmsg;
return sc;
}
log << MSG::INFO << "....initialization done" << endmsg;
return StatusCode::SUCCESS;
}
// ============================================================================
Tuples::TupleObj::Char* Tuples::TupleObj::chars
( const std::string& name ,
const char minv ,
const char maxv )
{
Chars::iterator found = m_chars.find( name ) ;
if( m_chars.end() != found ) { return found->second ; }
Char* item = new Char() ;
m_chars[ name ] = item ;
const StatusCode sc = tuple()->addItem( name , *item , minv , maxv );
if( sc.isFailure() )
{ Error ( "chars ('" + name + "'): item is not added", sc ) ; }
if ( !addItem ( name , "I" ) )
{ Error ( "chars ('" + name + "'): item is not unique" ) ; }
return item ;
}
// ============================================================================
Tuples::TupleObj::UInt* Tuples::TupleObj::uints
( const std::string& name ,
const unsigned int minv ,
const unsigned int maxv )
{
UInts::iterator found = m_uints.find( name ) ;
if( m_uints.end() != found ) { return found->second ; }
UInt* item = new UInt() ;
m_uints[ name ] = item ;
const StatusCode sc = tuple()->addItem( name , *item , minv , maxv );
if( sc.isFailure() )
{ Error ( "uints ('" + name + "'): item is not added", sc ) ; }
if ( !addItem ( name , "I" ) )
{ Error ( "uints ('" + name + "'): item is not unique" ) ; }
return item ;
}
// ============================================================================
Tuples::TupleObj::ULongLong* Tuples::TupleObj::ulonglongs
( const std::string& name ,
const unsigned long long minv ,
const unsigned long long maxv )
{
ULongLongs::iterator found = m_ulonglongs.find( name ) ;
if( m_ulonglongs.end() != found ) { return found->second ; }
ULongLong* item = new ULongLong() ;
m_ulonglongs[ name ] = item ;
const StatusCode sc = tuple()->addItem( name , *item , minv , maxv );
if( sc.isFailure() )
{ Error ( "ulonglongs ('" + name + "'): item is not added", sc ) ; }
if ( !addItem ( name , "ULL" ) )
{ Error ( "ulonglongs ('" + name + "'): item is not unique" ) ; }
return item ;
}
//=============================================================================
// Initialization
//=============================================================================
StatusCode TbTracking::initialize() {
// Initialise the base class.
StatusCode sc = TbAlgorithm::initialize();
if (sc.isFailure()) return sc;
// Setup the track fit tool.
m_trackFit = tool<ITbTrackFit>("TbTrackFit", "Fitter", this);
// Set up the cluster finder.
m_clusterFinder =
new TbClusterFinder(m_ClusterFinderSearchAlgorithm, m_nPlanes);
// setup Kalman histos
setup_hists();
return StatusCode::SUCCESS;
}
//=============================================================================
// Initialization
//=============================================================================
StatusCode TbChargeCalib::initialize() {
// Initialise the base class.
StatusCode sc = TbAlgorithm::initialize();
if (sc.isFailure()) return sc;
info() << "Booking histograms for Chargecalib ... " << endmsg;
m_ToTHists.reserve(256*256);
for( unsigned int i = 0 ; i < 256*256; ++i){
const std::string name = "c=" + std::to_string( i/256 ) + ", r=" + std::to_string(i%256);
if( i % 256 == 0 ) info() << "Booked histogram for column " << i << endmsg;
m_ToTHists.push_back(book1D(name, name, 0.5, 200.5, 200));
setAxisLabels(m_ToTHists[i], "ToT", "Entries");
}
info() << "Booked 60000 ish hists" << endmsg;
return StatusCode::SUCCESS;
}
//=============================================================================
// Initialisation
//=============================================================================
StatusCode TbKalmanTrackFit::initialize() {
// Initialise the base class.
StatusCode sc = GaudiTool::initialize();
if (sc.isFailure()) return sc;
// Get the straight-line fit tool (used for seeding the Kalman filter).
m_fitter = tool<ITbTrackFit>("TbTrackFit", "StraightLineFitter", this);
// Get the number of telescope planes.
const auto nPlanes = geomSvc()->modules().size();
// Set the flags whether a plane is masked or not.
m_masked.resize(nPlanes, false);
for (const unsigned int plane : m_maskedPlanes) {
m_masked[plane] = true;
m_fitter->maskPlane(plane);
}
return StatusCode::SUCCESS;
}
// ============================================================================
// retrieve (book on demand) array-items for ntuple (fixed)
// ============================================================================
Tuples::TupleObj::FArray* Tuples::TupleObj::fArray
( const std::string& name ,
const Tuples::TupleObj::MIndex& rows )
{
// existing array ?
FArrays::iterator found = m_arraysf.find( name ) ;
if( m_arraysf.end() != found ) { return found->second ; }
// create new array
FArray* array = new FArray () ;
m_arraysf[ name] = array ;
const StatusCode sc = tuple() -> addItem ( name , rows , *array) ;
if( sc.isFailure() )
{ Error ( "array ('" + name + "'): item is not added", sc ) ; }
if ( !addItem ( name , "FArray" ) )
{ Error ( "array ('" + name + "'): item is not unique" ) ; }
return array ;
}
StatusCode execute() {
info() << "Getting " << m_paths.size() << " objects from " << m_dataSvc << endmsg;
bool missing = false;
for (auto& p: m_paths) {
info() << "Getting '" << p << "'" << endmsg;
DataObject *obj;
StatusCode sc = m_dataProvider->retrieveObject(p, obj);
if (sc.isFailure()) {
warning() << "Cannot retrieve object '" << p << "'" << endmsg;
missing = true;
}
}
return (missing && ! m_ignoreMissing)
? StatusCode::FAILURE
: StatusCode::SUCCESS;
}
// Re-initialize
StatusCode EventSelector::reinitialize() {
if ( FSMState() != Gaudi::StateMachine::INITIALIZED ) {
MsgStream logger(msgSvc(), name());
logger << MSG::ERROR << "Cannot reinitialize: service not in state initialized" << endmsg;
return StatusCode::FAILURE;
}
if( m_streamSpecsLast != m_streamSpecs ) {
StatusCode status = m_streamtool->clear();
if ( status.isFailure() ) return status;
m_streamSpecsLast = m_streamSpecs;
m_reconfigure = true;
return m_streamtool->addStreams(m_streamSpecs);
}
return StatusCode::SUCCESS;
}
//=============================================================================
// Initialize
//=============================================================================
StatusCode HTBlob::initialize()
{
debug() << "Initializing HTBlob..." << endmsg;
StatusCode sc = this->MinervaHistoTool::initialize();
if( sc.isFailure() ) { return Error( "Failed to initialize!", sc ); }
try {
m_mathTool = tool<IMinervaMathTool>("MinervaMathTool");
}
catch( GaudiException& e ) {
error() << "Could not obtain tool: MinervaMathTool!" << endmsg;
return StatusCode::FAILURE;
}
return sc;
}
StatusCode DataOnDemandSvc::i_setAlgHandler(const std::string &name, const Gaudi::Utils::TypeNameString &alg){
Leaf leaf(alg.type(), alg.name());
if (m_init)
{
StatusCode sc = configureHandler(leaf);
if (sc.isFailure()) {
if (m_allowInitFailure) {
// re-store the content of the leaf object to try again to initialize
// the algorithm later (on demand)
leaf = Leaf(alg.type(), alg.name());
}
else
return sc;
}
}
m_algs[name] = leaf;
return StatusCode::SUCCESS;
}
// Use the job options service to set declared properties
StatusCode Service::setProperties() {
const bool CREATEIF(true);
SmartIF<IJobOptionsSvc> jos(serviceLocator()->service("JobOptionsSvc", CREATEIF));
if( !jos.isValid() ) {
throw GaudiException("Service [JobOptionsSvc] not found", name(), StatusCode::FAILURE);
}
// set first generic Properties
StatusCode sc = jos->setMyProperties( getGaudiThreadGenericName(name()), this );
if( sc.isFailure() ) return sc;
// set specific Properties
if (isGaudiThreaded(name())) {
if (jos->setMyProperties( name(), this ).isFailure()) {
return StatusCode::FAILURE;
}
}
return StatusCode::SUCCESS;
}
/// Rewind the dataset
StatusCode EventSelector::rewind(Context& refCtxt) const {
EvtSelectorContext *ctxt = dynamic_cast<EvtSelectorContext*>(&refCtxt);
if ( ctxt ) {
ctxt->set(0, -1, 0, 0);
firstOfNextStream(true, *ctxt);
long nskip = m_firstEvent;
while( --nskip > 0 ) {
StatusCode sc = next(*ctxt);
if ( sc.isFailure() ) {
MsgStream log(msgSvc(), name());
log << MSG::ERROR << "rewind() failed to start with event number "
<< m_firstEvent << endmsg;
return StatusCode::FAILURE;
}
}
return StatusCode::SUCCESS;
}
return StatusCode::FAILURE;
}
StatusCode TubeLayerPhiEtaCaloTool::initialize() {
StatusCode sc = GaudiTool::initialize();
if (sc.isFailure()) return sc;
m_geoSvc = service("GeoSvc");
if (!m_geoSvc) {
error() << "Unable to locate Geometry Service. "
<< "Make sure you have GeoSvc and SimSvc in the right order in the configuration." << endmsg;
return StatusCode::FAILURE;
}
if (m_readoutName != "") {
// Check if readouts exist
info() << "Readout: " << m_readoutName << endmsg;
if (m_geoSvc->lcdd()->readouts().find(m_readoutName) == m_geoSvc->lcdd()->readouts().end()) {
error() << "Readout <<" << m_readoutName << ">> does not exist." << endmsg;
return StatusCode::FAILURE;
}
}
return sc;
}
//=============================================================================
// Initialisation. Check parameters
//=============================================================================
StatusCode ParticleGunAlg::initialize() {
StatusCode sc = GaudiAlgorithm::initialize( ) ; // Initialize base class
if ( sc.isFailure() ) return sc ;
debug() << "==> Initialise" << endmsg ;
// Retrieve generation method tool
if ( "" == m_particleGunToolName )
return Error( "No ParticleGun Generation Tool is defined. This is mandatory" ) ;
m_particleGunTool = tool< IParticleGunTool >( m_particleGunToolName , this ) ;
// Retrieve smearing tool, if required
if ( "" != m_vertexSmearingToolName )
m_vertexSmearTool = tool< IVertexSmearingTool >( m_vertexSmearingToolName , this ) ;
// Retrieve
return StatusCode::SUCCESS;
}
StatusCode MergeHits::initialize() {
info() << "MergeHits initialize" << endmsg;
m_geoSvc = service("GeoSvc");
if (!m_geoSvc) {
error() << "Unable to locate Geometry Service. "
<< "Make sure you have GeoSvc and SimSvc in the right order in the "
"configuration."
<< endmsg;
return StatusCode::FAILURE;
}
StatusCode sc = GaudiAlgorithm::initialize();
if (sc.isFailure())
{
return sc;
}
return sc;
}
// ============================================================================
// retrieve (book on demand) matrix-items for ntuple (fixed)
// ============================================================================
Tuples::TupleObj::FMatrix*
Tuples::TupleObj::fMatrix
( const std::string& name ,
const Tuples::TupleObj::MIndex& rows ,
const Tuples::TupleObj::MIndex& cols )
{
// existing array ?
FMatrices::iterator found = m_matricesf.find( name ) ;
if( m_matricesf.end() != found ) { return found->second ; }
// create new array
FMatrix* matrix = new FMatrix () ;
m_matricesf[ name] = matrix ;
const StatusCode sc =
tuple() -> addItem( name , rows , cols , *matrix ) ;
if( sc.isFailure() )
{ Error ( "matrix ('" + name + "'): item is not added", sc ) ; }
if ( !addItem ( name , "FMatrix" ) )
{ Error ( "matrix ('" + name + "'): item is not unique" ) ; }
return matrix ;
}
StatusCode CreateCaloCells::initialize() {
StatusCode sc = GaudiAlgorithm::initialize();
if (sc.isFailure()) return sc;
info() << "CreateCaloCells initialized" << endmsg;
info() << "doCellCalibration : " << m_doCellCalibration << endmsg;
info() << "addCellNoise : " << m_addCellNoise << endmsg;
info() << "filterCellNoise : " << m_filterCellNoise << endmsg;
//Initialization of various tools
//Merge hits
if (!m_mergeTool.retrieve()) {
error()<<"Unable to retrieve the merge hits to cells tool!!!"<<endmsg;
return StatusCode::FAILURE;
}
//Calibrate Geant4 energy to EM scale tool
if (m_doCellCalibration) {
if (!m_calibTool.retrieve()) {
error()<<"Unable to retrieve the calo cells calibration tool!!!"<<endmsg;
return StatusCode::FAILURE;
}
}
//Cell noise tool
if (m_addCellNoise) {
if (!m_noiseTool.retrieve()) {
error()<<"Unable to retrieve the calo cells noise tool!!!"<<endmsg;
return StatusCode::FAILURE;
}
//Prepare a vector of all cells in calorimeter with their cellID
StatusCode sc_prepareCells = prepareEmptyCells(m_edmHitsNoiseVector);
if (sc_prepareCells.isFailure()) {
error()<<"Unable to create empty cells!!! Check the input for readout"<<endmsg;
return StatusCode::FAILURE;
}
}
return sc;
}
//=============================================================================
// Initialisation
//=============================================================================
StatusCode TbPacketRecycler::initialize() {
// Initialise the base class.
StatusCode sc = TbAlgorithm::initialize();
if (sc.isFailure()) return sc;
IToolSvc* toolsvc = nullptr;
sc = service("ToolSvc", toolsvc);
if (!sc.isSuccess()) {
return Error("Unable to get a handle to the tool service", sc);
}
for (unsigned int i = 0; i < m_nPlanes; ++i) {
TbRawStream* foo = nullptr;
sc = toolSvc()->retrieveTool("TbRawStream/" + std::to_string(i), foo);
if (!sc.isSuccess()) {
return Error("Unable to retrieve TbRawStream for plane " +
std::to_string(i), sc);
}
m_streams.push_back(foo);
}
return StatusCode::SUCCESS;
}
StatusCode FastGaussSmearDigi::initialize() {
info() << "initialize" << endmsg;
m_geoSvc = service("GeoSvc");
StatusCode sc = GaudiAlgorithm::initialize();
if (sc.isFailure()) return sc;
auto lcdd = m_geoSvc->lcdd();
auto readout = lcdd->readout(m_readoutName);
m_decoder = readout.idSpec().decoder();
auto segmentationXZ = dynamic_cast<DD4hep::DDSegmentation::CartesianGridXZ*>(readout.segmentation().segmentation());
if (nullptr == segmentationXZ) {
error() << "Could not retrieve segmentation!" << endmsg;
return StatusCode::FAILURE;
}
m_segGridSizeX = segmentationXZ->gridSizeX();
m_segGridSizeZ = segmentationXZ->gridSizeZ();
m_volman = lcdd->volumeManager();
return sc;
}
StatusCode TupleToolGeometry::initialize()
{
const StatusCode sc = TupleToolBase::initialize();
if ( sc.isFailure() ) return sc;
m_dva = Gaudi::Utils::getIDVAlgorithm ( contextSvc(), this ) ;
if (!m_dva) return Error("Couldn't get parent DVAlgorithm");
m_dist = m_dva->distanceCalculator();
if ( !m_dist )
{
return Error("Unable to retrieve the IDistanceCalculator tool");
}
m_pvReFitter = tool<IPVReFitter>( m_pvReFitterName, this );
if ( !m_pvReFitter )
{
return Error( "Unable to retrieve IPVReFitter instance" );
}
return sc;
}
//=============================================================================
StatusCode IncidentListenerTestAlg::initialize() {
StatusCode sc = GaudiAlgorithm::initialize();
if (sc.isFailure()) return sc;
// get a the incident service
m_incSvc = svc<IIncidentSvc>("IncidentSvc",true);
// instantiate listeners
m_listener[0] =
std::auto_ptr<IncidentListenerTest>(new IncidentListenerTest("Listener 0",serviceLocator()));
m_listener[1] =
std::auto_ptr<IncidentListenerTest>(new IncidentListenerTest("Listener 1",serviceLocator(),3));
m_listener[2] =
std::auto_ptr<IncidentListenerTest>(new IncidentListenerTest("Listener 2",serviceLocator()));
m_listener[3] =
std::auto_ptr<IncidentListenerTest>(new IncidentListenerTest("Listener 3",serviceLocator()));
m_listener[4] =
std::auto_ptr<IncidentListenerTest>(new IncidentListenerTest("EventBoundary",serviceLocator()));
m_listener[5] =
std::auto_ptr<IncidentListenerTest>(new IncidentListenerTest("Generic Listener",serviceLocator()));
info() << "Registering incident listeners" << endmsg;
const bool rethrow = false;
const bool singleShot = true;
const long priority = -10;
m_incSvc->addListener(m_listener[3].get(),incident(),priority,rethrow,singleShot);
m_incSvc->addListener(m_listener[0].get(),incident());
m_incSvc->addListener(m_listener[1].get(),incident());
m_incSvc->addListener(m_listener[2].get(),incident());
m_incSvc->addListener(m_listener[4].get(),IncidentType::BeginEvent);
m_incSvc->addListener(m_listener[4].get(),IncidentType::EndEvent);
m_incSvc->addListener(m_listener[5].get());
return StatusCode::SUCCESS;
}
//--------------------------------------------------------------------
// Initialize
//--------------------------------------------------------------------
StatusCode ReadAlg::initialize() {
StatusCode sc = Algorithm::initialize();
if (sc.isFailure()) return sc;
MsgStream log(msgSvc(), name());
if (outputLevel() <= MSG::DEBUG)
log << MSG::DEBUG << "Reading " << m_addressfile << endmsg;
m_addresses.clear();
std::ifstream input(m_addressfile.c_str());
while (input.good()) {
RootAddressArgs addr;
input >> addr;
if (input.eof()) break;
m_addresses.push_back(addr);
}
if (outputLevel() <= MSG::DEBUG)
log << MSG::DEBUG << "Read " << m_addresses.size() << " addresses" << endmsg;
m_count = 0;
return StatusCode::SUCCESS;
}
//=============================================================================
// Initialisation
//=============================================================================
StatusCode TbClusterFinder::initialize() {
// Initialise the base class.
StatusCode sc = GaudiTool::initialize();
if (sc.isFailure()) return sc;
// Get the number of telescope planes from the geometry service.
ITbGeometrySvc* geomSvc = svc<ITbGeometrySvc>("TbGeometrySvc", true);
if (!geomSvc) {
error() << "Cannot access geometry service" << endmsg;
return StatusCode::FAILURE;
}
const unsigned int nPlanes = geomSvc->modules().size();
m_first.resize(nPlanes);
m_last.resize(nPlanes);
m_end.resize(nPlanes);
m_nClusters.resize(nPlanes);
m_empty.resize(nPlanes);
m_prev_ts.resize(nPlanes);
m_prev.resize(nPlanes);
return StatusCode::SUCCESS;
}
// ============================================================================
// standard finalization method
// ============================================================================
StatusCode GaudiTool::finalize ()
{
if ( msgLevel(MSG::DEBUG) )
debug() << " ==> Finalize the base class GaudiTool " << endmsg;
// clear "explicit services"
m_evtSvc = 0 ;
m_detSvc = 0 ;
m_chronoSvc = 0 ;
m_incSvc = 0 ;
m_histoSvc = 0 ;
// finalize the base class
const StatusCode sc = GaudiCommon<AlgTool>::finalize() ;
if ( sc.isFailure() ) { return sc; }
// Decrement the counter
GaudiToolLocal::s_FinalizeCounter.decrement( m_local ) ;
// return
return sc;
}
