JAANET::JMultiHead Struct Reference

Auxiliary data structure to store multiple headers
and bookkeep event-weight normalisations. More...

#include <JMultiHead.hh>

Inheritance diagram for JAANET::JMultiHead:

Public Types
typedef std::map< JUUID, JAANET::JEvtWeightNormalisation >	map_type

Public Member Functions
	JMultiHead ()
	Default constructor. More...
void	merge (const JHead &header)
	Merge the given header into this object. More...
bool	insert (const JHead &header)
	Insert the given header. More...
bool	isMerged (const JUUID &UUID) const
	Check if given header UUID correspond to a file which has been merged. More...
JUUID	getHeaderUUID (const Evt &event) const
	Get the header UUID corresponding to the given event. More...
double	getNormalisation (const JUUID &UUID) const
	Get normalisation for given header UUID. More...
double	getNormalisation (const Evt &event) const
	Get normalisation for given event. More...
void	merge ()
	Merge all matching headers. More...
const_iterator	find (const uuid_t &uuid, const bool useCache=false) const
	Find header with given UUID. More...
const_iterator	find (const Evt &event, const bool useCache=false) const
	Find the header corresponding to the given event. More...
bool	insert (const Head &header)
	Insert the given header. More...
size_t	join (const MultiHead &multiHead)
	Join given MultiHead object with this MultiHead object. More...
	ClassDef (MultiHead, 1)

Static Public Member Functions
static void	actionAtFileOpen (int version)
	Action method at file open. More...

Public Attributes
map_type	normalisationMap
	Map between header UUIDs and event-weight normalisations. More...

Static Public Attributes
static int	ROOT_IO_VERSION = -1
	Streamer version as obtained from ROOT file. More...

Detailed Description

Auxiliary data structure to store multiple headers
and bookkeep event-weight normalisations.

Definition at line 37 of file JMultiHead.hh.

Member Typedef Documentation

typedef std::map<JUUID, JAANET::JEvtWeightNormalisation> JAANET::JMultiHead::map_type

Definition at line 40 of file JMultiHead.hh.

Constructor & Destructor Documentation

JAANET::JMultiHead::JMultiHead ( )

inline

Default constructor.

Definition at line 46 of file JMultiHead.hh.

                 :
      MultiHead()
    {}

Member Function Documentation

void JAANET::JMultiHead::merge ( const JHead &  header )

inline

Merge the given header into this object.

Parameters

header

header

Definition at line 56 of file JMultiHead.hh.

    {
      insert(header);
      merge();
    }

bool JAANET::JMultiHead::insert ( const JHead &  header )

inline

Insert the given header.

Parameters

header

header

Returns

true if insertion was successful; else false

Definition at line 69 of file JMultiHead.hh.

    {
      using namespace std;
      
      Head head;
      JAANET::copy(header, head);

      uuid_t uuid;
      uuid_clear(uuid);

      Head::iterator i = head.find(Head::tags::UUID);

      if (i != head.end()) {
        uuid_parse(i->second.c_str(), uuid);
      }

      if (uuid_is_null(uuid) != 0) {
        uuid_generate_random(uuid); // Ensure valid UUID
      }

      char buffer[JUUID::BUFFER_SIZE + 1];
      uuid_unparse_lower(uuid, buffer);

      head.insert(make_pair(Head::tags::UUID, buffer));

      return MultiHead::insert(head);
    }

bool JAANET::JMultiHead::isMerged ( const JUUID &  UUID ) const

inline

Check if given header UUID correspond to a file which has been merged.

Parameters

UUID	header UUID

Returns

true if given header UUID correspond to file which has been merged

Definition at line 104 of file JMultiHead.hh.

    {
      using namespace JPP;
      
      map_type::const_iterator i = normalisationMap.find(UUID);

      if (i != normalisationMap.end()) {
        return i->first != i->second.UUID;
      } else {
        THROW(JValueOutOfRange, "JMultiHead::isMerged(): Given header UUID " << UUID << " not found.");
      }
    }

JUUID JAANET::JMultiHead::getHeaderUUID ( const Evt &  event ) const

inline

Get the header UUID corresponding to the given event.

Parameters

event

event

Returns

header UUID

Definition at line 124 of file JMultiHead.hh.

    {
      using namespace JPP;
      
      const JUUID UUID = event.header_uuid;
      
      map_type::const_iterator i = normalisationMap.find(UUID);

      if (i != normalisationMap.cend()) {
        return i->second.UUID;
      } else {
        THROW(JValueOutOfRange, "JMultiHead::getHeaderUUID(): Header UUID " << UUID << " for given event not found.");
      }
    }

double JAANET::JMultiHead::getNormalisation ( const JUUID &  UUID ) const

inline

Get normalisation for given header UUID.

Parameters

UUID	header UUID

Returns

event-weight normalisation factor

Definition at line 146 of file JMultiHead.hh.

    {
      using namespace JPP;
      
      map_type::const_iterator i = normalisationMap.find(UUID);
      
      if (i != normalisationMap.end()) {
        return i->second.normalisation;
      } else {
        THROW(JValueOutOfRange, "JMultiHead::getNormalisation(): Given header UUID " << UUID << " not found.");
      }
    }

double JAANET::JMultiHead::getNormalisation ( const Evt &  event ) const

inline

Get normalisation for given event.

Parameters

event

event

Returns

event-weight normalisation factor

Definition at line 166 of file JMultiHead.hh.

    {
      return getNormalisation(event.header_uuid);
    }

void JAANET::JMultiHead::merge ( )

inline

Merge all matching headers.

Definition at line 175 of file JMultiHead.hh.

    {
      using namespace std;
      using namespace JPP;
      
      const MultiHead copy = static_cast<const MultiHead&>(*this);
      this->clear();

      for (const_iterator i = copy.cbegin(); i != copy.cend(); ++i) {
        
        JHead header1 = *i;
        header1.createUUID(); // Ensure header UUID is set
        
        const JUUID UUID = header1.UUID; // Initial header UUID
        
        // Merge matching headers following this header in the container
        
        vector<JUUID> mergedHeaders; // Track all headers involved in mergers

        for (const_iterator j = next(i); j != copy.end(); ++j) {

          const JHead header2 = *j;
          
          if (header1.match(header2)) {
            
            header1.add(header2);
            mergedHeaders.push_back(header2.UUID);
          }
        }

        // Retrieve event-weight normalisation for merged header
        
        const JEvtWeight& weighter = getEventWeighter(header1);

        JEvtWeightHelper helper(weighter);
        helper.add(header1);

        const double norm = helper->getNormalisation();

        // Set event-weight normalisations for headers involved in mergers

        for (vector<JUUID>::const_iterator j = mergedHeaders.cbegin(); j != mergedHeaders.cend(); ++j) {
          normalisationMap[*j] = JEvtWeightNormalisation(header1.UUID, norm);
        }

        // Set event-weight normalisation for original header

        normalisationMap[UUID] = JEvtWeightNormalisation(header1.UUID, norm);
        
        insert(header1); // Add merged header to buffer
      }
    }

const_iterator MultiHead::find ( const uuid_t &  uuid, const bool  useCache = false  ) const

inlineinherited

Find header with given UUID.

Note: The parameter useCache can be toggled on for faster lookup.
This should not be used if your MultiHead object is modified between look-ups.

Parameters

uuid	header UUID
useCache	use caching for faster look-up

Returns

header with given UUID

Definition at line 47 of file MultiHead.hh.

  {
    using namespace std;

    static struct Cache
    {
      Cache() { uuid_clear(this->uuid); }
      
      const_iterator it;
      uuid_t         uuid;
    } cache;
    
    if (!useCache) {

      for (cache.it = this->cbegin(); cache.it != this->cend(); ++cache.it) {

        const Head& head     = *cache.it;
        string      uuid_str = head.at(Head::tags::UUID);

        uuid_str.erase(remove_if(uuid_str.begin(), uuid_str.end(), ::isspace), uuid_str.end());
        
        uuid_parse(uuid_str.c_str(), cache.uuid);
        
        if (uuid_compare(uuid, cache.uuid) == 0) {
          return cache.it;
        }
      }
      
      return this->end();
      
    } else {

      if (uuid_compare(uuid, cache.uuid) == 0) {
        return cache.it;
      } else {
        return find(uuid, false);
      }
    }
  }

const_iterator MultiHead::find ( const Evt &  event, const bool  useCache = false  ) const

inlineinherited

Find the header corresponding to the given event.

Note: The parameter useCache can be toggled on for faster lookup.
This should not be used if your MultiHead object is modified between look-ups.

Parameters

event	event
useCache	use caching for faster look-up

Returns

header corresponding to the given event

Definition at line 98 of file MultiHead.hh.

  {
    return find(event.header_uuid, useCache);
  }

bool MultiHead::insert ( const Head &  header )

inlineinherited

Insert the given header.

Parameters

header

header

Returns

true if insertion was successful; else false

Definition at line 111 of file MultiHead.hh.

  {
    using namespace std;
    
    string uuid_str = header.at(Head::tags::UUID);
    uuid_str.erase(remove_if(uuid_str.begin(), uuid_str.end(), ::isspace), uuid_str.end());

    uuid_t uuid;
    uuid_parse(uuid_str.c_str(), uuid);

    if (uuid_is_null(uuid) == 0 && find(uuid) == this->cend()) {
      
      this->push_back(header);
      
      return true;
    }
    
    return false;
  }

size_t MultiHead::join ( const MultiHead &  multiHead )

inlineinherited

Join given MultiHead object with this MultiHead object.

Parameters

multiHead

MultiHead object

Returns

number of inserted headers

Definition at line 138 of file MultiHead.hh.

  {
    using namespace std;

    size_t n = 0;
    
    for (const_iterator i = multiHead.cbegin(); i != multiHead.cend(); ++i) {
      n += (size_t) this->insert(*i);
    }

    return n;
  }

static void MultiHead::actionAtFileOpen ( int  version )

inlinestaticinherited

Action method at file open.

Parameters

version

version

Definition at line 157 of file MultiHead.hh.

  {
    ROOT_IO_VERSION = version;
  }

MultiHead::ClassDef ( MultiHead  , 1    )

inherited

Member Data Documentation

map_type JAANET::JMultiHead::normalisationMap

Map between header UUIDs and event-weight normalisations.

Definition at line 229 of file JMultiHead.hh.

int MultiHead::ROOT_IO_VERSION = -1

staticinherited

Streamer version as obtained from ROOT file.

Definition at line 163 of file MultiHead.hh.

---

The documentation for this struct was generated from the following file:

• JMultiHead.hh