---

InitRootHandlers.cc File Reference

#include "FWCore/Services/src/InitRootHandlers.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/MessageLogger/interface/ELseverityLevel.h"
#include "FWCore/Utilities/interface/EDMException.h"
#include "FWCore/RootAutoLibraryLoader/interface/RootAutoLibraryLoader.h"
#include "DataFormats/Provenance/interface/TransientStreamer.h"
#include "DataFormats/Common/interface/CacheStreamers.h"
#include "DataFormats/Common/interface/RefCoreStreamer.h"
#include <string.h>
#include <sstream>
#include "TSystem.h"
#include "TError.h"
#include "TTree.h"
#include "Cintex/Cintex.h"
#include "TH1.h"
#include "G__ci.h"

Go to the source code of this file.

Namespaces
namespace	edm
namespace	edm::service
Functions
void	RootErrorHandler (int level, bool die, char const *location, char const *message)

---

Function Documentation

void @7687::RootErrorHandler	(	int	level,
		bool	die,
		char const *	location,
		char const *	message
	)			[static]

Definition at line 23 of file InitRootHandlers.cc.

References edm::ELseverityLevel::ELsev_error, edm::ELseverityLevel::ELsev_fatal, edm::ELseverityLevel::ELsev_info, edm::ELseverityLevel::ELsev_severe, edm::ELseverityLevel::ELsev_warning, except, and edm::errors::FatalRootError.

Referenced by edm::service::InitRootHandlers::enableErrorHandler_(), and edm::service::InitRootHandlers::InitRootHandlers().

{
 
// Translate ROOT severity level to MessageLogger severity level

  edm::ELseverityLevel el_severity = edm::ELseverityLevel::ELsev_info;

  if (level >= kFatal) {
    el_severity = edm::ELseverityLevel::ELsev_fatal;
  }
  else if (level >= kSysError) {
    el_severity = edm::ELseverityLevel::ELsev_severe;
  }
  else if (level >= kError) {
    el_severity = edm::ELseverityLevel::ELsev_error;
  }
  else if (level >= kWarning) {
    el_severity = edm::ELseverityLevel::ELsev_warning;
  }

// Adapt C-strings to std::strings
// Arrange to report the error location as furnished by Root

  std::string el_location = "@SUB=?";
  if (location != 0) el_location = std::string("@SUB=")+std::string(location);

  std::string el_message  = "?";
  if (message != 0)  el_message  = message;

// Try to create a meaningful id string using knowledge of ROOT error messages
//
// id ==     "ROOT-ClassName" where ClassName is the affected class
//      else "ROOT/ClassName" where ClassName is the error-declaring class
//      else "ROOT"

  std::string el_identifier = "ROOT";

  std::string precursor("class ");
  size_t index1 = el_message.find(precursor);
  if (index1 != std::string::npos) {
    size_t index2 = index1 + precursor.length();
    size_t index3 = el_message.find_first_of(" :", index2);
    if (index3 != std::string::npos) {
      size_t substrlen = index3-index2;
      el_identifier += "-";
      el_identifier += el_message.substr(index2,substrlen);
    }
  } else {
    index1 = el_location.find("::");
    if (index1 != std::string::npos) {
      el_identifier += "/";
      el_identifier += el_location.substr(0, index1);
    }
  }

// Intercept some messages and upgrade the severity

    if ((el_location.find("TBranchElement::Fill") != std::string::npos)
     && (el_message.find("fill branch") != std::string::npos)
     && (el_message.find("address") != std::string::npos)
     && (el_message.find("not set") != std::string::npos)) {
      el_severity = edm::ELseverityLevel::ELsev_fatal;
    }

    if ((el_message.find("Tree branches") != std::string::npos)
     && (el_message.find("different numbers of entries") != std::string::npos)) {
      el_severity = edm::ELseverityLevel::ELsev_fatal;
    }


// Intercept some messages and downgrade the severity

    if ((el_message.find("dictionary") != std::string::npos) ||
        (el_message.find("already in TClassTable") != std::string::npos) ||
        (el_message.find("matrix not positive definite") != std::string::npos) ||
        (el_location.find("Fit") != std::string::npos) ||
        (el_location.find("TDecompChol::Solve") != std::string::npos) ||
        (el_location.find("THistPainter::PaintInit") != std::string::npos)) {
      el_severity = edm::ELseverityLevel::ELsev_info;
    }

    
  if (el_severity == edm::ELseverityLevel::ELsev_info) {
    // Don't throw if the message is just informational.
    die = false;
  } else {
    die = true;
  }

// Feed the message to the MessageLogger and let it choose to suppress or not.

// Root has declared a fatal error.  Throw an EDMException unless the
// message corresponds to a pending signal. In that case, do not throw
// but let the OS deal with the signal in the usual way.
  if (die && (location != std::string("TUnixSystem::DispatchSignals"))) {
     std::ostringstream sstr;
     sstr << "Fatal Root Error: " << el_location << "\n" << el_message << '\n';
     edm::Exception except(edm::errors::FatalRootError, sstr.str());
     throw except;
  }
 
  // Currently we get here only for informational messages,
  // but we leave the other code in just in case we change
  // the criteria for throwing.
  if (el_severity == edm::ELseverityLevel::ELsev_fatal) {
    edm::LogError("Root_Fatal") << el_location << el_message;
  }
  else if (el_severity == edm::ELseverityLevel::ELsev_severe) {
    edm::LogError("Root_Severe") << el_location << el_message;
  }
  else if (el_severity == edm::ELseverityLevel::ELsev_error) {
    edm::LogError("Root_Error") << el_location << el_message;
  }
  else if (el_severity == edm::ELseverityLevel::ELsev_warning) {
    edm::LogWarning("Root_Warning") << el_location << el_message ;
  }
  else if (el_severity == edm::ELseverityLevel::ELsev_info) {
    edm::LogInfo("Root_Information") << el_location << el_message ;
  }

}

---