TRTCond::StrawT0ContainerTemplate< LEVEL > Class Template Reference

class for storing/accessing trt t0 data More...

#include <StrawT0Container.h>

Inheritance diagram for TRTCond::StrawT0ContainerTemplate< LEVEL >:

Collaboration diagram for TRTCond::StrawT0ContainerTemplate< LEVEL >:

Public Types
typedef StrawT0	value_type
	Type of atomic element. More...
typedef const StrawT0	const_value_type
	const Type of atomic element. More...
typedef StrawT0Trait	trait_type
	Type of trait. More...
typedef std::vector< std::pair< ExpandedIdentifier, const StrawT0 * > >	FlatContainer
	fill vector with all entries in the container. needed to dump to Peter's flat file format More...

Public Member Functions
	StrawT0ContainerTemplate ()
	constructor More...
virtual	~StrawT0ContainerTemplate ()
	destructor More...
float	getT0 (const ExpandedIdentifier &id) const
	access to unpacked t0 More...
float	getT0Err (const ExpandedIdentifier &id) const
	access to unpacked t0 error More...
void	setT0 (const ExpandedIdentifier &id, float t0, float t0err)
	set t0 More...
void	setT0 (float t0, float t0err)
	set the top-level t0 More...
void	unpack (const StrawT0 &sd, float &t0, float &t0err) const
	public method to unpack a StrawT0 object More...
float	unpackT0 (const StrawT0 &sd) const
	more public methods More...
float	unpackT0Err (const StrawT0 &sd) const
void	setPackingLimits (float t0min, float t0max, float t0errmin, float t0errmax)
	change the packing limits More...
void	set (const ExpandedIdentifier &id, const StrawT0 &t)
	set a value. More...
void	set (const StrawT0 &t)
	set the default value More...
const StrawT0 &	get (const ExpandedIdentifier &id) const
	get a value. More...
const StrawT0 &	get (const ExpandedIdentifier &id, size_t &resolvelevel) const
const StrawT0 &	get () const
	get the default value More...
void	clear ()
	clear entire container More...
void	clear (const ExpandedIdentifier &id)
	clear only entries specified More...
const DaughterContainer &	daughters () const
	return the vector of daughters More...
size_t	numObjects () const
	return the total number of valid calibration objects More...
bool	operator== (const NestedContainerBase &rhs) const
	equality operator, used for compressing More...
bool	operator== (const StrawT0 &rhs) const
	another equality operator, used for compressing More...
size_t	footprint () const
	return the memory allocated by the container and its daughters More...
void	crunch ()
	reduce the footprint as much as possible by removing the extra space allocated by the vectors More...
void	printindent () const
	some IO for debugging More...
void	print () const
void	getall (FlatContainer &entries) const

Static Public Member Functions
static const char *	classname ()
	classname used to talk to iovservice More...

Private Types
typedef std::vector< NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait > >	DaughterContainer
	typedef of container More...

Private Attributes
LinearPacker< float, unsigned char >	m_t0packer
	packing borders More...
LinearPacker< float, unsigned char >	m_t0errpacker
DaughterContainer	m_daughters
	Container of Daughters. More...
StrawT0	m_default
	Type of atomic element. More...

Detailed Description

template<int LEVEL>
class TRTCond::StrawT0ContainerTemplate< LEVEL >

class for storing/accessing trt t0 data

Definition at line 44 of file StrawT0Container.h.

Member Typedef Documentation

const_value_type

typedef const StrawT0 TRTCond::NestedContainerBase< NestingLevel, NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait > , StrawT0 , StrawT0Trait >::const_value_type

inherited

const Type of atomic element.

Definition at line 161 of file NestedContainer.h.

DaughterContainer

typedef std::vector<NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait > > TRTCond::NestedContainerBase< NestingLevel, NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait > , StrawT0 , StrawT0Trait >::DaughterContainer

privateinherited

typedef of container

Definition at line 154 of file NestedContainer.h.

FlatContainer

typedef std::vector< std::pair<ExpandedIdentifier, const StrawT0 *> > TRTCond::NestedContainerBase< NestingLevel, NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait > , StrawT0 , StrawT0Trait >::FlatContainer

inherited

fill vector with all entries in the container. needed to dump to Peter's flat file format

Definition at line 346 of file NestedContainer.h.

trait_type

typedef StrawT0Trait TRTCond::NestedContainerBase< NestingLevel, NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait > , StrawT0 , StrawT0Trait >::trait_type

inherited

Type of trait.

Definition at line 162 of file NestedContainer.h.

value_type

typedef StrawT0 TRTCond::NestedContainerBase< NestingLevel, NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait > , StrawT0 , StrawT0Trait >::value_type

inherited

Type of atomic element.

Definition at line 160 of file NestedContainer.h.

Constructor & Destructor Documentation

StrawT0ContainerTemplate()

template<int LEVEL>

TRTCond::StrawT0ContainerTemplate< LEVEL >::StrawT0ContainerTemplate ( )

inline

constructor

Definition at line 52 of file StrawT0Container.h.

: m_t0packer(0,64),m_t0errpacker(0,16) {}

~StrawT0ContainerTemplate()

template<int LEVEL>

virtual TRTCond::StrawT0ContainerTemplate< LEVEL >::~StrawT0ContainerTemplate ( )

inlinevirtual

destructor

Definition at line 55 of file StrawT0Container.h.

{}

Member Function Documentation

classname()

template<int LEVEL>

static const char* TRTCond::StrawT0ContainerTemplate< LEVEL >::classname ( )

inlinestatic

classname used to talk to iovservice

Definition at line 93 of file StrawT0Container.h.

{ return "TRTCond::StrawT0Container" ; }

clear() [1/2]

void TRTCond::NestedContainerBase< NestingLevel, NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait > , StrawT0 , StrawT0Trait >::clear ( )

inlineinherited

clear entire container

Definition at line 238 of file NestedContainer.h.

                 {
      for( typename DaughterContainer::iterator it = m_daughters.begin() ; it != m_daughters.end(); ++it ) 
    NestedContainerDaughterAccessor<Daughter,T,Trait>::clear(*it) ;
      m_daughters.clear() ;
      Trait::erase(m_default) ;
    }

clear() [2/2]

void TRTCond::NestedContainerBase< NestingLevel, NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait > , StrawT0 , StrawT0Trait >::clear ( const ExpandedIdentifier &  id )

inlineinherited

clear only entries specified

Definition at line 246 of file NestedContainer.h.

                                                {
      if( NestingLevel == id.level() ) clear() ;
      else {
    unsigned int thisindex = id.index(NestingLevel+1) ;
    if(thisindex<m_daughters.size()) 
      NestedContainerDaughterAccessor<Daughter,T,Trait>::clear(m_daughters[thisindex],id ) ;
      }
    }

crunch()

void TRTCond::NestedContainerBase< NestingLevel, NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait > , StrawT0 , StrawT0Trait >::crunch ( )

inlineinherited

reduce the footprint as much as possible by removing the extra space allocated by the vectors

Definition at line 292 of file NestedContainer.h.

                  {
      // first the daughters 
      for( typename DaughterContainer::iterator it = m_daughters.begin() ; it != m_daughters.end(); ++it ) 
    NestedContainerDaughterAccessor<Daughter,T,Trait>::crunch(*it) ;
      // now use, if anything is there
      if( m_daughters.size()>0 ) {
    // find the first daughter that is valid
    size_t firstvaliddaughter(0);
    bool allequal(true) ;
    for(size_t idau=0; idau<m_daughters.size() && allequal; ++idau) {
      allequal = NestedContainerDaughterAccessor<Daughter,T,Trait>::empty(m_daughters[idau]) ;
      if( allequal ) {
        bool isvalid = Trait::isvalid( NestedContainerDaughterAccessor<Daughter,T,Trait>::get(m_daughters[idau])) ;
        if( isvalid ) {
          if( firstvaliddaughter==0 ) firstvaliddaughter = idau ;
        } else {
          allequal = NestedContainerDaughterAccessor<Daughter,T,Trait>::isequal(m_daughters[idau],m_daughters[firstvaliddaughter]) ;
        }
      }
    }
    if(allequal) {
      // set the default value to the value form the first daughter
      T defaultvalue(Trait::initialvalue()) ;
      if( firstvaliddaughter < m_daughters.size() ) 
        Trait::copy(defaultvalue,NestedContainerDaughterAccessor<Daughter,T,Trait>::get(m_daughters[firstvaliddaughter])) ;
      clear() ; // this clears pointers in the daughters. would rather replace that with destructors.
      m_daughters = DaughterContainer(0) ;
      m_default = defaultvalue ;
    } else if(m_daughters.size()<m_daughters.capacity())  {
      DaughterContainer newdaughters(0) ;
      newdaughters.reserve( m_daughters.size() ) ;
      newdaughters.insert( newdaughters.end(), m_daughters.begin(), m_daughters.end() ) ;
      newdaughters.swap(m_daughters) ;
    }
      }
    }

daughters()

const DaughterContainer& TRTCond::NestedContainerBase< NestingLevel, NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait > , StrawT0 , StrawT0Trait >::daughters ( ) const

inlineinherited

return the vector of daughters

Definition at line 256 of file NestedContainer.h.

{ return m_daughters ; }

footprint()

size_t TRTCond::NestedContainerBase< NestingLevel, NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait > , StrawT0 , StrawT0Trait >::footprint ( ) const

inlineinherited

return the memory allocated by the container and its daughters

Definition at line 282 of file NestedContainer.h.

                             {
      size_t total = Trait::footprint(m_default) + (m_daughters.capacity()-m_daughters.size())*sizeof(Daughter) ;
      for( typename DaughterContainer::const_iterator it = m_daughters.begin() ; it != m_daughters.end(); ++it ) 
    total += NestedContainerDaughterAccessor<Daughter,T,Trait>::footprint(*it) ;
      return total ;
    }

get() [1/3]

const StrawT0 & TRTCond::NestedContainerBase< NestingLevel, NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait > , StrawT0 , StrawT0Trait >::get ( ) const

inlineinherited

get the default value

Definition at line 232 of file NestedContainer.h.

{ return m_default ; }

get() [2/3]

const StrawT0 & TRTCond::NestedContainerBase< NestingLevel, NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait > , StrawT0 , StrawT0Trait >::get ( const ExpandedIdentifier &  id ) const

inlineinherited

get a value.

return the default value if no valid entry for id exists.

Definition at line 205 of file NestedContainer.h.

                                                       {
      if( NestingLevel < id.level() ) {
    unsigned int thisindex = id.index(NestingLevel+1) ;
    if(thisindex<m_daughters.size()) {
      const T& rc = NestedContainerDaughterAccessor<Daughter,T,Trait>::get(m_daughters[thisindex],id) ;
      // only return this value if it is valid. otherwise, return the default.
      if( Trait::isvalid(rc) ) return rc ;
    }
      }
      return m_default ;
    }

get() [3/3]

const StrawT0 & TRTCond::NestedContainerBase< NestingLevel, NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait > , StrawT0 , StrawT0Trait >::get ( const ExpandedIdentifier &  id, size_t &  resolvelevel  ) const

inlineinherited

Definition at line 217 of file NestedContainer.h.

   {
     if( NestingLevel < id.level() ) {
       unsigned int thisindex = id.index(NestingLevel+1) ;
       if(thisindex<m_daughters.size()) {
          const T& rc = NestedContainerDaughterAccessor<Daughter,T,Trait>::get(m_daughters[thisindex],id,resolvelevel) ;
           if( Trait::isvalid(rc) ) return rc ;   
         }
      }
      resolvelevel = NestingLevel ; 
      return m_default ;
    }

getall()

void TRTCond::NestedContainerBase< NestingLevel, NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait > , StrawT0 , StrawT0Trait >::getall ( FlatContainer &  entries ) const

inlineinherited

Definition at line 347 of file NestedContainer.h.

                                                {
      // add the daughters
      for(unsigned int idau = 0; idau<m_daughters.size(); ++idau) {
    FlatContainer dauentries ;
    // first get them
    NestedContainerDaughterAccessor<Daughter,T,Trait>::getall(m_daughters[idau], dauentries) ;
    // now update the identifiers to have the dauhgter index  set correctly
    for(unsigned int j=0; j< dauentries.size(); ++j ) 
      dauentries[j].first.index(NestingLevel+1) = idau ;
    // and append
    entries.insert(entries.end(),dauentries.begin(),dauentries.end()) ;
      }
      // add the default value
      if( Trait::isvalid(m_default) ) {
    ExpandedIdentifier id(0,0,0,0,0,NestingLevel) ;
    entries.push_back( std::pair<ExpandedIdentifier, const T*>(id,&m_default)) ; 
      }
    }

getT0()

template<int LEVEL>

float TRTCond::StrawT0ContainerTemplate< LEVEL >::getT0 ( const ExpandedIdentifier &  id ) const

inline

access to unpacked t0

Definition at line 58 of file StrawT0Container.h.

                                                    { 
      const StrawT0& sd = NestedContainer<LEVEL,StrawT0,StrawT0Trait>::get(id) ;
      return StrawT0Trait::isvalid(sd) ? m_t0packer.unpack(sd.packedt0()) : 0 ;
    }

getT0Err()

template<int LEVEL>

float TRTCond::StrawT0ContainerTemplate< LEVEL >::getT0Err ( const ExpandedIdentifier &  id ) const

inline

access to unpacked t0 error

Definition at line 64 of file StrawT0Container.h.

                                                       { 
      const StrawT0& sd = NestedContainer<LEVEL,StrawT0,StrawT0Trait>::get(id) ;
      return StrawT0Trait::isvalid(sd) ? m_t0errpacker.unpack(sd.packedt0err()) : 0 ;
    }

numObjects()

size_t TRTCond::NestedContainerBase< NestingLevel, NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait > , StrawT0 , StrawT0Trait >::numObjects ( ) const

inlineinherited

return the total number of valid calibration objects

Definition at line 260 of file NestedContainer.h.

                              { 
      size_t rc(0) ;
      assert( std::distance(m_daughters.begin(),m_daughters.end())==(int)m_daughters.size()) ;
      assert( m_daughters.size() < 1000 ) ;
      for( typename DaughterContainer::const_iterator it = m_daughters.begin() ; it != m_daughters.end(); ++it ) 
    rc += NestedContainerDaughterAccessor<Daughter,T,Trait>::numObjects(*it) ;
      if( Trait::isvalid(m_default) ) ++rc ;
      return rc ;
    }

operator==() [1/2]

bool TRTCond::NestedContainerBase< NestingLevel, NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait > , StrawT0 , StrawT0Trait >::operator== ( const NestedContainerBase< NestingLevel, NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait >, StrawT0, StrawT0Trait > &  rhs ) const

inlineinherited

equality operator, used for compressing

Definition at line 272 of file NestedContainer.h.

                                                          {
      return m_daughters.size()==0 && rhs.m_daughters.size()==0 && Trait::isequal(m_default,rhs.m_default) ;
    }

operator==() [2/2]

bool TRTCond::NestedContainerBase< NestingLevel, NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait > , StrawT0 , StrawT0Trait >::operator== ( const T &  rhs ) const

inlineinherited

another equality operator, used for compressing

Definition at line 277 of file NestedContainer.h.

                                        {
      return m_daughters.size()==0 && Trait::isequal(m_default,rhs) ;
    }

print()

void TRTCond::NestedContainerBase< NestingLevel, NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait > , StrawT0 , StrawT0Trait >::print ( ) const

inlineinherited

Definition at line 334 of file NestedContainer.h.

                       {
      printindent() ;
      ExpandedIdentifier id;
      std::cout << "level = " << id.name(NestingLevel) << " (" << NestingLevel << ")"  << std::endl ;
      for(unsigned int i=0; i< m_daughters.size(); ++i) {
    printindent() ;
    std::cout << "daughter " << i << std::endl ;
    NestedContainerDaughterAccessor<Daughter,T,Trait>::print(m_daughters[i]) ;
      }
    }

printindent()

void TRTCond::NestedContainerBase< NestingLevel, NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait > , StrawT0 , StrawT0Trait >::printindent ( ) const

inlineinherited

some IO for debugging

Definition at line 330 of file NestedContainer.h.

                             {
      for(int i=0; i<NestingLevel; ++i) 
    std::cout << '\t' ;
    }

set() [1/2]

void TRTCond::NestedContainerBase< NestingLevel, NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait > , StrawT0 , StrawT0Trait >::set ( const ExpandedIdentifier &  id, const T &  t  )

inlineinherited

set a value.

using 'level' in id we can specify if we want to set the default value.

Definition at line 191 of file NestedContainer.h.

                                                        {
      if( NestingLevel == id.level() ) {
    // set the default value
    Trait::copy(m_default,t) ;
      } else {
    unsigned int thisindex = id.index(NestingLevel+1) ;
    // expand daughter array if necessary
    if(thisindex>=m_daughters.size()) 
      m_daughters.resize( thisindex+1, NestedContainerDaughterAccessor<Daughter,T,Trait>::initialvalue() ) ; 
    NestedContainerDaughterAccessor<Daughter,T,Trait>::set(m_daughters[thisindex], id, t ) ;
      }
    }

set() [2/2]

void TRTCond::NestedContainerBase< NestingLevel, NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait > , StrawT0 , StrawT0Trait >::set ( const T &  t )

inlineinherited

set the default value

Definition at line 235 of file NestedContainer.h.

{ Trait::copy(m_default,t) ; }

setPackingLimits()

template<int LEVEL>

void TRTCond::StrawT0ContainerTemplate< LEVEL >::setPackingLimits	(	float	t0min,
		float	t0max,
		float	t0errmin,
		float	t0errmax
	)

change the packing limits

create the new packers

update all entries in the container.

Definition at line 97 of file StrawT0Container.h.

  {
    LinearPacker<float,unsigned char> newt0packer(t0min,t0max) ;
    LinearPacker<float,unsigned char> newt0errpacker(t0errmin,t0errmax) ;
    LinearPacker<float,unsigned char> oldt0packer = m_t0packer ;
    LinearPacker<float,unsigned char> oldt0errpacker = m_t0errpacker ;
 
    typename NestedContainer<LEVEL,StrawT0,StrawT0Trait>::FlatContainer entries ;
    this->getall( entries ) ;
    for(typename NestedContainer<LEVEL,StrawT0,StrawT0Trait>::FlatContainer::iterator 
      it = entries.begin() ; it != entries.end(); ++it) {
      StrawT0& sd = const_cast<StrawT0&>(*(it->second)) ;
      float t0    = oldt0packer.unpack(sd.packedt0()); 
      float t0err = oldt0errpacker. unpack(sd.packedt0err());
      unsigned char newpackedt0    = newt0packer.pack(t0) ;
      unsigned char newpackedt0err = newt0errpacker.pack(t0err) ;
      sd = StrawT0( newpackedt0, newpackedt0err ) ;
    }
    m_t0packer = newt0packer ;
    m_t0errpacker = newt0errpacker ;
  }

setT0() [1/2]

template<int LEVEL>

void TRTCond::StrawT0ContainerTemplate< LEVEL >::setT0 ( const ExpandedIdentifier &  id, float  t0, float  t0err  )

inline

set t0

Definition at line 70 of file StrawT0Container.h.

                                                                    {
      NestedContainer<LEVEL,StrawT0,StrawT0Trait>::set(id,StrawT0(m_t0packer.pack(t0),m_t0errpacker.pack(t0err))) ;
    }

setT0() [2/2]

template<int LEVEL>

void TRTCond::StrawT0ContainerTemplate< LEVEL >::setT0 ( float  t0, float  t0err  )

inline

set the top-level t0

Definition at line 75 of file StrawT0Container.h.

                                      {
      NestedContainer<LEVEL,StrawT0,StrawT0Trait>::set(StrawT0(m_t0packer.pack(t0),m_t0errpacker.pack(t0err))) ;
    }

unpack()

template<int LEVEL>

void TRTCond::StrawT0ContainerTemplate< LEVEL >::unpack ( const StrawT0 &  sd, float &  t0, float &  t0err  ) const

inline

public method to unpack a StrawT0 object

Definition at line 80 of file StrawT0Container.h.

                                                                   {
      t0    = m_t0packer.unpack(sd.packedt0()) ;
      t0err = m_t0errpacker.unpack(sd.packedt0err()) ;
    }

unpackT0()

template<int LEVEL>

float TRTCond::StrawT0ContainerTemplate< LEVEL >::unpackT0 ( const StrawT0 &  sd ) const

inline

more public methods

Definition at line 86 of file StrawT0Container.h.

{ return m_t0packer.unpack(sd.packedt0()); }

unpackT0Err()

template<int LEVEL>

float TRTCond::StrawT0ContainerTemplate< LEVEL >::unpackT0Err ( const StrawT0 &  sd ) const

inline

Definition at line 87 of file StrawT0Container.h.

{ return m_t0errpacker.unpack(sd.packedt0err()); }

Member Data Documentation

m_daughters

DaughterContainer TRTCond::NestedContainerBase< NestingLevel, NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait > , StrawT0 , StrawT0Trait >::m_daughters

privateinherited

Container of Daughters.

Definition at line 156 of file NestedContainer.h.

m_default

StrawT0 TRTCond::NestedContainerBase< NestingLevel, NestedContainer< NestingLevel+1, StrawT0, StrawT0Trait > , StrawT0 , StrawT0Trait >::m_default

privateinherited

Type of atomic element.

Definition at line 157 of file NestedContainer.h.

m_t0errpacker

template<int LEVEL>

LinearPacker<float,unsigned char> TRTCond::StrawT0ContainerTemplate< LEVEL >::m_t0errpacker

private

Definition at line 49 of file StrawT0Container.h.

m_t0packer

template<int LEVEL>

LinearPacker<float,unsigned char> TRTCond::StrawT0ContainerTemplate< LEVEL >::m_t0packer

private

packing borders

Definition at line 48 of file StrawT0Container.h.

---

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

• StrawT0Container.h