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

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

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

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

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

map_type

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

Definition at line 40 of file JMultiHead.hh.

Constructor & Destructor Documentation

JMultiHead()

JAANET::JMultiHead::JMultiHead ( )

inline

Default constructor.

Definition at line 46 of file JMultiHead.hh.

                 :
      MultiHead()
    {}

Member Function Documentation

merge() [1/2]

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();
    }

insert() [1/2]

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);
    }

isMerged()

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.");
      }
    }

getHeaderUUID()

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.");
      }
    }

getNormalisation() [1/2]

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.");
      }
    }

getNormalisation() [2/2]

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);
    }

merge() [2/2]

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
      }
    }

find() [1/2]

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);
      }
    }
  }

find() [2/2]

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);
  }

insert() [2/2]

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;
  }

join()

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;
  }

actionAtFileOpen()

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;
  }

ClassDef()

MultiHead::ClassDef ( MultiHead , 1  )

inherited

Member Data Documentation

normalisationMap

map_type JAANET::JMultiHead::normalisationMap

Map between header UUIDs and event-weight normalisations.

Definition at line 229 of file JMultiHead.hh.

ROOT_IO_VERSION

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