LArBadChanBlobUtils Namespace Reference

Typedefs
typedef std::pair< HWIdentifier, LArBadChannel >	BadChanEntry
typedef std::pair< HWIdentifier, LArBadFeb >	BadFebEntry
typedef std::vector< BadChanEntry >	BadChanVec
typedef std::vector< BadFebEntry >	BadFebVec
typedef Identifier32::value_type	Channel

Enumerations
enum	Endianness { LittleEndian , BigEndian }

Functions
int	machineEndianness ()
template<class T>
void	fillBlob (const std::vector< std::pair< HWIdentifier, T > > &vec, coral::Blob &blob)
	Creates a BLOB of the right size and copies the content of the vector of pair<HWIdentifier, LArBadChannel> into the blob.
void	fillFebBlobV1 (const std::vector< HWIdentifier > &vec, coral::Blob &blob)
template<class T>
std::vector< std::pair< HWIdentifier, T > >	decodeBlob (const coral::Blob *blobp, std::size_t chanSize, std::size_t stateSize, int endian, int version, MsgStream &log)
	Checks BLOB for differences in endian-ness and size of data types with respect to the architecture on which the code is executed and if the checks paass decodes the BLOB data into a vector of pair<HWIdentifier, LArBadChannel>.
std::vector< HWIdentifier >	decodeFebBlobV1 (const coral::Blob *blobp, std::size_t chanSize, int endian, int version, MsgStream &log)
bool	checkBlob (const coral::Blob *blobp, std::size_t chanSize, std::size_t stateSizeInBlob, int endian, int, std::size_t step, std::size_t currentStateSize, MsgStream &log)

Typedef Documentation

BadChanEntry

typedef std::pair<HWIdentifier, LArBadChannel> LArBadChanBlobUtils::BadChanEntry

Definition at line 20 of file LArBadChanBlobUtils.h.

BadChanVec

typedef std::vector<BadChanEntry> LArBadChanBlobUtils::BadChanVec

Definition at line 22 of file LArBadChanBlobUtils.h.

BadFebEntry

typedef std::pair<HWIdentifier, LArBadFeb> LArBadChanBlobUtils::BadFebEntry

Definition at line 21 of file LArBadChanBlobUtils.h.

BadFebVec

typedef std::vector<BadFebEntry> LArBadChanBlobUtils::BadFebVec

Definition at line 23 of file LArBadChanBlobUtils.h.

Channel

typedef Identifier32::value_type LArBadChanBlobUtils::Channel

Definition at line 24 of file LArBadChanBlobUtils.h.

Enumeration Type Documentation

Endianness

enum LArBadChanBlobUtils::Endianness

Enumerator
LittleEndian
BigEndian

Definition at line 26 of file LArBadChanBlobUtils.h.

{ LittleEndian, BigEndian};

Function Documentation

checkBlob()

bool LArBadChanBlobUtils::checkBlob	(	const coral::Blob *	blobp,
		std::size_t	chanSize,
		std::size_t	stateSizeInBlob,
		int	endian,
		int	,
		std::size_t	step,
		std::size_t	currentStateSize,
		MsgStream &	log )

Definition at line 30 of file LArBadChanBlobUtils.cxx.

  {
    if ( endian != machineEndianness()) {
      log << MSG::ERROR << "BLOB endian-ness and computer endian-ness differ."
      << " This version cannot decode such BLOBs" << endmsg;
      return false;
    }
    if ( chanSize != sizeof( Channel)) {
      log << MSG::ERROR << "The word size for HWidentifier in the BLOB (" 
      << chanSize << ") diifers from the HWIdentifier::value_type size "
      << sizeof( Channel) << endmsg;
      log << MSG::ERROR << "This version cannot decode such BLOBs" << endmsg;
      return false;
    }
    if ( stateSizeInBlob != 0 && stateSizeInBlob != currentStateSize) {
      log << MSG::ERROR << "The word size for LArBadChannel or LArBadFeb in the BLOB (" 
      << stateSizeInBlob << ") diifers from the runtime BitWord size "
      << currentStateSize << endmsg;
      log << MSG::ERROR << "This version cannot decode such BLOBs" << endmsg;
      return false;
    }
 
    if (blobp->size() % step != 0) {
      log << MSG::ERROR << "BLOB size (" << blobp->size() 
      << ") is not an exact multiple of content size " 
      << step << endmsg;
      log << MSG::ERROR << "The BLOB is probably corrupted." << endmsg;
      return false;
    }
 
    // FIXME: add version check
 
   return true;
  }

decodeBlob()

template<class T>

std::vector< std::pair< HWIdentifier, T > > LArBadChanBlobUtils::decodeBlob	(	const coral::Blob *	blobp,
		std::size_t	chanSize,
		std::size_t	stateSize,
		int	endian,
		int	version,
		MsgStream &	log )

Checks BLOB for differences in endian-ness and size of data types with respect to the architecture on which the code is executed and if the checks paass decodes the BLOB data into a vector of pair<HWIdentifier, LArBadChannel>.

If the checks fail returns an empty vector, and writes diagnostics on the MsgStream passed as an argument. The arguments chanSize, stateSize and endian must come from the database that provides the BLOB, and must be filled by the machine that created the BLOB.

decodeFebBlobV1()

std::vector< HWIdentifier > LArBadChanBlobUtils::decodeFebBlobV1	(	const coral::Blob *	blobp,
		std::size_t	chanSize,
		int	endian,
		int	version,
		MsgStream &	log )

Definition at line 72 of file LArBadChanBlobUtils.cxx.

  {
    std::vector<HWIdentifier> result;
    std::size_t step; 
    if (version == 1) step = sizeof( Channel) ;
    else              step = sizeof( Channel) + sizeof( LArBadFeb::BitWord);
 
    if (!checkBlob( blobp, chanSize, 0, endian, version, step, 0, log)) {
      return result;
    }
    std::size_t vecSize = blobp->size() / step;
    result.reserve( vecSize);
    const void* adr = blobp->startingAddress();
    for (std::size_t i=0; i< vecSize; i++) {
      const Channel* ch = static_cast<const Channel*>( adr);
      adr = static_cast<const void*>(ch+1);
      result.emplace_back(Identifier32(*ch));
    }
    return result;
  }

fillBlob()

template<class T>

void LArBadChanBlobUtils::fillBlob	(	const std::vector< std::pair< HWIdentifier, T > > &	vec,
		coral::Blob &	blob )

Creates a BLOB of the right size and copies the content of the vector of pair<HWIdentifier, LArBadChannel> into the blob.

Returns a pointer to the new blob, which has to be managed (and eventually released) by the caller

fillFebBlobV1()

void LArBadChanBlobUtils::fillFebBlobV1	(	const std::vector< HWIdentifier > &	vec,
		coral::Blob &	blob )

Definition at line 17 of file LArBadChanBlobUtils.cxx.

  {
    std::size_t nbytes = vec.size() * sizeof( Channel);
    blob.resize(nbytes);
    void* adr = blob.startingAddress();
    for ( std::vector<HWIdentifier>::const_iterator i=vec.begin();
      i != vec.end(); ++i) {
      Channel* ch = static_cast<Channel*>( adr);
      *ch = i->get_identifier32().get_compact(); // assign channel
      adr = static_cast<void*>(ch+1); //  points just after channel
    }
  }

machineEndianness()

int LArBadChanBlobUtils::machineEndianness

(

)

Definition at line 9 of file LArBadChanBlobUtils.cxx.

  {
    int i = 1;
    char *p = reinterpret_cast<char *>(&i);
    if (p[0] == 1) return LittleEndian; // Lowest address contains the least significant byte
    else return BigEndian;
  }