GlobalEventDataMaker.cxx

Go to the documentation of this file.

// ================================================
// GlobalEventDataMaker class Implementation Singleton version 
// ================================================
//
// THIS TEXT TO BE REPLACED BY ATLAS STANDARD FORMAT
//
// Namespace Atlfast
//
#include "AtlfastAlgs/GlobalEventDataMaker.h"
#include "AtlfastAlgs/GlobalEventData.h"
#include "AtlfastEvent/MagField.h"

#include "AtlfastEvent/ParticleCodes.h"

#include "AtlfastUtils/HeaderPrinter.h"

// Gaudi includes
#include "GaudiKernel/DataSvc.h"
#include "GaudiKernel/MsgStream.h"
#include <algorithm>

namespace Atlfast {
  using std::sort;
  using std::unique;
  //--------------------------------
  // Constructor 
  //--------------------------------
  GlobalEventDataMaker::GlobalEventDataMaker ( 
      const std::string& name, 
      ISvcLocator* pSvcLocator 
      )
    : Algorithm( name, pSvcLocator )
  {
    // Set the parameter defaults.
    m_lumi              = 1;
    m_fieldOn           = true;
    m_fieldStrength     = -999.9;
    m_barrelForwardEta  = 3.2;
    m_randSeed          = 12345;
    m_mcLocation        = "GEN_EVENT";
    m_justHardScatter   = true;

    m_invisibles.push_back(12);
    m_invisibles.push_back(14);
    m_invisibles.push_back(16);
    m_invisibles.push_back(1000022);

    // Declare the parameters to Gaudi so that
    // they can be over-written via the job options file
    declareProperty( "Luminosity",       m_lumi );
    declareProperty( "Invisibles",       m_invisibles );
    declareProperty( "BFieldOn",         m_fieldOn ) ;
    declareProperty( "BFieldStrength",   m_fieldStrength ) ;
    declareProperty( "RandomSeed",       m_randSeed ) ;
    declareProperty( "BarrelForwardEta", m_barrelForwardEta ) ;
    declareProperty( "McLocation",       m_mcLocation ) ;
    declareProperty( "MonopoleIDs",      m_monopoleIDs );
    declareProperty( "JustHardScatter",  m_justHardScatter );
    
  }
  
  //--------------------
  // Destructor
  //--------------------
  
  GlobalEventDataMaker::~GlobalEventDataMaker() {
    MsgStream log( messageService(), name() ) ;
    log << MSG::INFO << "destructor, Global Event Data" << endreq;
  }

  //---------------------------------
  // initialise() 
  //---------------------------------
  
  StatusCode GlobalEventDataMaker::initialize()
  {
    MsgStream log( messageService(), name() ) ;
    log << MSG::DEBUG << "Initialising" << endreq; 
    log << MSG::DEBUG << "Making Invisibles" << endreq; 
    m_invisibles.push_back(ParticleCodes::NU_E);
    m_invisibles.push_back(ParticleCodes::NU_MU);
    m_invisibles.push_back(ParticleCodes::NU_TAU);
    std::vector<int>::iterator ibe = m_invisibles.begin();
    std::vector<int>::iterator originalEnd = m_invisibles.end();
    std::vector<int>::iterator ien;
    sort(ibe, originalEnd);
    ien=unique(ibe, originalEnd);
    m_invisibles.erase(ien, originalEnd);
    
    // Monopole IDs
    std::vector<int>::iterator mbe = m_monopoleIDs.begin();
    std::vector<int>::iterator mOriginalEnd = m_monopoleIDs.end();
    std::vector<int>::iterator men;
    sort(mbe, mOriginalEnd);
    men=unique(mbe, mOriginalEnd);
    m_monopoleIDs.erase(men, mOriginalEnd);
    
    if(m_lumi != 1 && m_lumi != 2){
      log << MSG::WARNING << "Luminosity set to unknown value: " << m_lumi << endreq; 
      log << MSG::WARNING << "Luminosity reset to Low-Lumi == 1" << endreq;
      m_lumi = 1;
    }
    log << MSG::DEBUG << "Making Header" << endreq; 
    HeaderPrinter hp("Atlfast GlobalEventData Maker:", log);
    hp.add("Invisibles (Neutrinos hardwired invisible): ", ibe, ien);
    hp.add("Luminosity:                                 ", m_lumi);
    hp.add("Initial Random Number Seed:                 ", m_randSeed);
    hp.add("B-field On:                                 ", m_fieldOn);
    hp.add("B-field Strength:                           ", m_fieldStrength);
    hp.add("Barrel Forward Eta:                         ", m_barrelForwardEta);
    hp.add("McLocation:                                 ", m_mcLocation);
    hp.add("Monopole IDs:                               ", mbe, men);
    hp.add("Just Hard Scatter?:                         ", m_justHardScatter);
    hp.print();
    log << MSG::DEBUG << "Calling ged instance" << endreq; 

    //set values of GlobalEventVariables

    GlobalEventData* ged;

    try{
      ged = GlobalEventData::Instance();
    }catch(std::string errMsg){
      log << MSG::DEBUG << "Error making a GlobalEventData"<< errMsg <<endreq; 
      return StatusCode::FAILURE;
    }catch(...){
      log << MSG::DEBUG << "Unknown Error making a GlobalEventData"<<endreq; 
      return StatusCode::FAILURE;
    }

    log << MSG::DEBUG << "Calling ged setValues" << endreq; 
    ged->setValues(m_lumi,
                   m_fieldOn,
                   m_barrelForwardEta,
                   m_randSeed,
                   m_invisibles,
                   m_mcLocation,
                   m_monopoleIDs,
                   m_justHardScatter) ;

    
    log << MSG::DEBUG << "Creating MagField singleton" << endreq; 
    if ( m_fieldStrength == -999.9 ){
      if ( m_fieldOn )
        MagField::Instance(2.0);
      else
        MagField::Instance();
    } else {
      MagField::Instance(m_fieldStrength);
    }

    log << MSG::DEBUG << "Everything Completed" << endreq;
    return StatusCode::SUCCESS ;
  }
  
  //---------------------------------
  // finalise() 
  //---------------------------------
 
  StatusCode GlobalEventDataMaker::finalize()
  {
    
    MsgStream log( messageService(), name() ) ;
    log << MSG::INFO << "Finalizing" << endreq;  
    return StatusCode::SUCCESS ;
  }
  
  
  //----------------------------------------------
  // execute() method called once per event
  //----------------------------------------------
  
  StatusCode GlobalEventDataMaker::execute( ){
    // do nothing in execute
    return StatusCode::SUCCESS;
  }
  
} // end namespace bracket

---