---

ParticlePropertySvc.cpp

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/GaudiSvc/src/ParticlePropertySvc/ParticlePropertySvc.cpp,v 1.1.1.2 2001/04/18 18:32:50 tlindner Exp $

//Include files
#include "GaudiKernel/SvcFactory.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/MsgStream.h"

#include "GaudiKernel/ParticleProperty.h"
#include "ParticlePropertySvc.h"

#include "CLHEP/Units/PhysicalConstants.h"

#include <cstdlib>

#ifdef WIN32
#include <fstream>
#else
#include <fstream.h>
#endif


// Instantiation of a static factory class used by clients to create
// instances of this service
static SvcFactory<ParticlePropertySvc> s_factory;
const ISvcFactory& ParticlePropertySvcFactory = s_factory;

// ---------------------------------------------------------------------------
// 
// ParticlePropertySvc Class
//
// Implement a ParticlePropertySvc 
// Author     : I. Last
// Modify by  : G.Corti 09/11/1999 to read file from LHCBDBASE and
//              introduce find/eraseByStdHepID methods
//
// ---------------------------------------------------------------------------
// Routine: Constructor.
// Purpose: Create service and set default ParticlePropertiesFile
// ---------------------------------------------------------------------------
//

ParticlePropertySvc::ParticlePropertySvc( const std::string& name, ISvcLocator* svc )
 : Service( name, svc ) {
  declareProperty( "ParticlePropertiesFile", m_filename );

  if(getenv("LHCBDBASE") != NULL) {
    m_filename = std::string(getenv( "LHCBDBASE" )) + std::string( "/cdf/particle.cdf");
  }
  else {
    m_filename = std::string( "particle.cdf" );
  }
}

// ---------------------------------------------------------------------------
// Routine: Destructor.
// Purpose:
// ---------------------------------------------------------------------------
//

ParticlePropertySvc::~ParticlePropertySvc() {
  for ( MapName::iterator i = m_namemap.begin(); i != m_namemap.end(); i++ ) {
    if ( (*i).second ) delete (*i).second; 
  }
}

// ---------------------------------------------------------------------------
// Routine: type.
// Purpose: Return the service type.
// ---------------------------------------------------------------------------
//

const IID& ParticlePropertySvc::type() const { 
  return IID_IParticlePropertySvc; 
}

// ---------------------------------------------------------------------------
// Routine: begin
// Purpose: Get an iterator to the beginning of the container (the name map).
// ---------------------------------------------------------------------------
//

ParticlePropertySvc::const_iterator ParticlePropertySvc::begin() const { 
  return m_vectpp.begin();
}


// ---------------------------------------------------------------------------
// Routine: end
// Purpose: Get an iterator to the end of the container (the name map)
// ---------------------------------------------------------------------------
//

ParticlePropertySvc::const_iterator ParticlePropertySvc::end() const { 
  return m_vectpp.end();
}


// ---------------------------------------------------------------------------
// Routine: size
// Purpose: Get the size of the container.
// ---------------------------------------------------------------------------
//

int ParticlePropertySvc::size() const { 
  return m_vectpp.size();
}

// ---------------------------------------------------------------------------
// Routine: initialize
// Purpose: initialize the service and setProperties (check if properties set in
//          jobOptions),
// ---------------------------------------------------------------------------
//

StatusCode ParticlePropertySvc::initialize() {

  StatusCode status = Service::initialize();
  
  setProperties();  

  MsgStream log( msgSvc(), name() );

  if ( status.isSuccess() ) {
    status = parseFile();
    if ( status.isSuccess() ) {
      log << MSG::DEBUG << "ParticleProperties parsed successfully" << endreq;
      log << MSG::DEBUG << "Access properties" << endreq;
      // For debugging purposes print out the size of the internal maps  
      // particle name as key: all particles in database are present here
      log << MSG::DEBUG << "NameMap size =" << m_namemap.size() << endreq;
      // Geant3 ID as key: all particles in database are present here
      log << MSG::DEBUG << "GeantID Map size =" << m_idmap.size() << endreq;
      // StdHep ID as key: some particles have no valid StdHep ID 
      log << MSG::DEBUG << "StdHepID Map size =" << m_stdhepidmap.size() << endreq;
    }
    else log << MSG::INFO << "Could not initialise service" << endreq;
  }
  else
    log << MSG::INFO << "Could not initialise service" << endreq;

  return status;
}

// ---------------------------------------------------------------------------
// Routine: finalize
// Purpose:
// ---------------------------------------------------------------------------
//

StatusCode ParticlePropertySvc::finalize() {

  MsgStream log( msgSvc(), name() );
  StatusCode status = Service::finalize();

  if ( status.isSuccess() )
    log << MSG::INFO << "Service finalised successfully" << endreq;
  
  return status;
}

// ---------------------------------------------------------------------------
// Routine: queryInterface.
// Purpose: standard routine.
// ---------------------------------------------------------------------------
//

StatusCode ParticlePropertySvc::queryInterface( const IID& riid, 
                                                void** ppvInterface ) {
  StatusCode sc = StatusCode::FAILURE;
  if ( ppvInterface ) {
    *ppvInterface = 0;
    
    if ( riid == IID_IParticlePropertySvc ) {
      *ppvInterface = static_cast<IParticlePropertySvc*>(this);
      sc = StatusCode::SUCCESS;
      addRef();
    }
    else
      sc = Service::queryInterface( riid, ppvInterface );    
  }
  return sc;
}

// ---------------------------------------------------------------------------
// Routine: push_back
// Purpose: Create a particle property and insert it in the maps
// ---------------------------------------------------------------------------
//

StatusCode ParticlePropertySvc::push_back( const std::string& particle,
                                           int geantId, int jetsetId, 
                                           int type, double charge, 
                                           double mass, double tlife ) {

  StatusCode status = StatusCode::FAILURE;
  mapped_type pp = new ParticleProperty( particle, geantId, jetsetId, 
                                         type, charge, mass, tlife );
  if ( pp ) {
    status = push_back( pp );
    if ( status.isFailure() ) delete pp;
  }
  return status;
}

// ---------------------------------------------------------------------------
// Routine: push_back
// Purpose: Add a particle property.
// ---------------------------------------------------------------------------
//

StatusCode ParticlePropertySvc::push_back( ParticleProperty* pp ) {

  StatusCode status = StatusCode::FAILURE;
  if ( pp ) {
    // adding into the vector of all particle properties
    m_vectpp.push_back( pp );

    // adding into maps, when not successfull remove from maps where
    // previously inserted
    std::pair<MapID::iterator,bool> result1 =
         m_idmap.insert( MapID::value_type( pp->geantID(), pp ));

    if ( result1.second ) {
      std::pair<MapName::iterator,bool> result2 =
        m_namemap.insert( MapName::value_type( pp->particle(), pp ));
      
      // add to StdHep map only if StdHep ID different from zero and if
      // not Cerenkov (StdHep ID = gamma)
      if ( result2.second ) {
        if ( (pp->jetsetID() != 0) && ( pp->particle().compare("Tcherenkov")) ) {
          std::pair<MapStdHepID::iterator,bool> result3 = 
            m_stdhepidmap.insert( MapStdHepID::value_type( pp->jetsetID(), pp ));
          if ( result3.second ) {
            status = StatusCode::SUCCESS;
          }
          else {
            m_vectpp.pop_back();
            m_namemap.erase( pp->particle() );
            m_idmap.erase( pp->geantID() );
          }
        }
        else 
          status = StatusCode::SUCCESS;
      }
      else {
        m_vectpp.pop_back();
        m_idmap.erase( pp->geantID() );
      }
    }
  }
  return status;
}

// ---------------------------------------------------------------------------
// Routine: find
// Purpose: find a particle by geant id.
// ---------------------------------------------------------------------------
//

ParticlePropertySvc::mapped_type ParticlePropertySvc::find( int geantID ) {

  mapped_type obj = 0;
  MapID::const_iterator i = m_idmap.find( geantID );
  if ( i != m_idmap.end() ) obj = (*i).second;
  return obj;
}

// ---------------------------------------------------------------------------
// Routine: find
// Purpose: find a particle by name.
// ---------------------------------------------------------------------------
//

ParticlePropertySvc::mapped_type ParticlePropertySvc::find( const std::string& name ) {

  mapped_type obj = 0;
  MapName::const_iterator i = m_namemap.find( name );
  if ( i != m_namemap.end() ) obj = (*i).second;
  return obj;
}

// ---------------------------------------------------------------------------
// Routine: findByStdHepID
// Purpose: find a particle StdHepID (Jetset ID)
// ---------------------------------------------------------------------------
//

ParticlePropertySvc::mapped_type ParticlePropertySvc::findByStdHepID( int stdHepID ) {

  mapped_type obj = 0;
  MapStdHepID:: const_iterator i = m_stdhepidmap.find( stdHepID );
  if ( i != m_stdhepidmap.end() ) obj = (*i).second;
  return obj;

}

// ---------------------------------------------------------------------------
// Routine: erase
// Purpose: Erase a particle given by its geant id 
// ---------------------------------------------------------------------------
//

StatusCode ParticlePropertySvc::erase( int geantId ) {

  StatusCode status = StatusCode::FAILURE;

  MapID::iterator i_id = m_idmap.find( geantId );
  if ( i_id != m_idmap.end() ) {
    status = StatusCode::SUCCESS;
    m_idmap.erase( i_id );
    mapped_type pp = (*i_id).second;

    if ( pp ) {
      // remove the particle from all containers : name map
      MapName::iterator i_name = m_namemap.find( pp->particle() );
      if ( i_name != m_namemap.end() ) m_namemap.erase( i_name );
      // from StdHep ID map
      MapStdHepID::iterator i_stdhepid = m_stdhepidmap.find( pp->jetsetID() );
      if ( i_stdhepid != m_stdhepidmap.end() ) m_stdhepidmap.erase( i_stdhepid );
      // erase from vector
      iterator it;
      for ( it = m_vectpp.begin(); it != m_vectpp.end(); it++ ) {
        if( *(it) == pp ) {
          m_vectpp.erase(it);
          break;
        }
      }
      if( it != m_vectpp.end() ) delete pp;
    }    
  }

  return status;
}

// ---------------------------------------------------------------------------
// Routine: erase
// Purpose: Erase a particle given by its name.
// ---------------------------------------------------------------------------
//

StatusCode ParticlePropertySvc::erase( const std::string& name ) {
  StatusCode status = StatusCode::FAILURE;

  MapName::iterator i_name = m_namemap.find( name );
  if ( i_name != m_namemap.end() ) {
    status = StatusCode::SUCCESS;
    m_namemap.erase( i_name );
    mapped_type pp = (*i_name).second;

    if ( pp ) {
      // remove the particle from all containers : Geant3 ID map
      MapID::iterator i_id = m_idmap.find( pp->geantID() );
      if ( i_id != m_idmap.end() ) m_idmap.erase( i_id );
      // from StdHep ID map
      MapStdHepID::iterator i_stdhepid = m_stdhepidmap.find( pp->jetsetID() );
      if ( i_stdhepid != m_stdhepidmap.end() ) m_stdhepidmap.erase( i_stdhepid );
      // erase from vector
      iterator it;
      for ( it = m_vectpp.begin(); it != m_vectpp.end(); it++ ) {
        if( *(it) == pp ) {
          m_vectpp.erase(it);
          break;
        }
      }
      if( it != m_vectpp.end() ) delete pp;
    }    
  }

  return status;
}

// ---------------------------------------------------------------------------
// Routine: eraseByStdHepID
// Purpose: erase a particle given by its StdHepID (Jetset ID)
// ---------------------------------------------------------------------------
//
// test new function 

StatusCode ParticlePropertySvc::eraseByStdHepID( int stdHepID ) {

  StatusCode status = StatusCode::FAILURE;

  MapStdHepID::iterator i_stdhepid = m_stdhepidmap.find( stdHepID );
  if ( i_stdhepid != m_stdhepidmap.end() ) {
    status = StatusCode::SUCCESS;
    m_stdhepidmap.erase( i_stdhepid );
    mapped_type pp = (*i_stdhepid).second;

    if ( pp ) {
      // remove the particle from all containers : name map
      MapName::iterator i_name = m_namemap.find( pp->particle() );
      if ( i_name != m_namemap.end() ) m_namemap.erase( i_name );
      // from Geant3 ID map
      MapID::iterator i_id = m_idmap.find( pp->geantID() );
      if ( i_id != m_idmap.end() ) m_idmap.erase( i_id );
      // erase from vector
      iterator it;
      for ( it = m_vectpp.begin(); it != m_vectpp.end(); it++ ) {
        if( *(it) == pp ) {
          m_vectpp.erase(it);
          break;
        }
      }
      if( it != m_vectpp.end() ) delete pp;
    }    
  }

  return status;
}

// ---------------------------------------------------------------------------
// Routine: parseFile
// Purpose: Parses the file and fill all the maps
// ---------------------------------------------------------------------------
//

StatusCode ParticlePropertySvc::parseFile() {
  StatusCode sc = StatusCode::FAILURE;

  MsgStream log( msgSvc(), name() );
  char line[ 255 ];
  std::ifstream infile( m_filename.c_str() );

  if ( infile ) {
          sc = StatusCode::SUCCESS;
    log << MSG::INFO << "Opened particle properties file : " << m_filename
              << endreq;

        while( infile ) {
      // parse each line of the file (comment lines begin with # in the cdf
      // file,
            infile.getline( line, 255 );
            if ( line[0] == '#' ) continue;
                        
            std::string par, gid, jid, typ, chg, mas, lif; 
            char* token = strtok( line, " " );
            if ( token ) { par = token; token = strtok( NULL, " " );} else continue;
          if ( token ) { gid = token; token = strtok( NULL, " " );} else continue;
          if ( token ) { jid = token; token = strtok( NULL, " " );} else continue;
            if ( token ) { typ = token; token = strtok( NULL, " " );} else continue;
            if ( token ) { chg = token; token = strtok( NULL, " " );} else continue;
            if ( token ) { mas = token; token = strtok( NULL, " " );} else continue;
            if ( token ) { lif = token; token = strtok( NULL, " " );} else continue;
            if ( token != NULL ) continue;

      // In SICb cdf file mass and lifetime units are GeV and sec, specify it so
      // that they are converted to Gaudi units (MeV and ns)
      double mass = atof( mas.c_str() ) * GeV;
      double tlife = atof( lif.c_str() ) * s;

      // add a particle property
      push_back( par, atoi( gid.c_str() ), atoi( jid.c_str() ), 
                                atoi( typ.c_str() ), atof( chg.c_str() ), mass, tlife );
          }
        infile.close();
  }
  else
        log << MSG::ERROR << "Unable to open properties file : " << m_filename << endreq;

  return sc;
}

---