Classes
class	range_error

Typedefs
typedef uint32_t	roitype_t
typedef std::vector< std::vector< roitype_t > >	roiserial_type

Enumerations
enum	ROIENUM { PARAM , ETA , ETAMINUS , ETAPLUS , PHI , PHIMINUS , PHIPLUS , ZED , ZEDMINUS , ZEDPLUS }
enum	MASK { FULLSCAN = 0x1 , COMPOSITE = 0x2 , ROITYPE = 0x4 }

Functions
bool	contains (const IRoiDescriptor &roi, double z0, double dzdr)
	see whether a segment is contained within the roi in r-z
bool	contains_zrange (const IRoiDescriptor &roi, double z0, double dzdr, double zmin, double zmax)
bool	contains (const IRoiDescriptor &roi, double z, double r, double phi)
	see whether a point is contained within the roi (in phi and r-z)
bool	containsPhi (const IRoiDescriptor &roi, double phi)
	test whether a stub is contained within the roi
bool	containsZed (const IRoiDescriptor &roi, double z, double r)
double	phicheck (double phi)
	basic range checkers
double	etacheck (double eta)
double	zedcheck (double zed)
void	serialise (const std::vector< const IRoiDescriptor * > &rois, roiserial_type &s)
	serialise an entire vector of IRoiDescriptors
void	serialise (const TrigRoiDescriptorCollection &rois, roiserial_type &s)
	serialise an entire TrigRoiDescriptor collection
void	deserialise (const roiserial_type &s, std::vector< const IRoiDescriptor * > &rois)
	deserialise uint32_t vector into a full vector of IRoiDescriptors
void	deserialise (const roiserial_type &s, TrigRoiDescriptorCollection &rois)
	deserialise uint32_t vector into a TrigRoiDescriptorCollection
void	serialise (const IRoiDescriptor *roi, std::vector< roitype_t > &s)
	serialise a single IRoiDescriptor
IRoiDescriptor *	deserialise (const roitype_t &s_end, const roitype_t s_last)
	deserialise to a single IRoiDescriptors (including constituents)

Typedef Documentation

◆ roiserial_type

typedef std::vector< std::vector<roitype_t> > RoiUtil::roiserial_type

Definition at line 22 of file RoiSerialise.h.

◆ roitype_t

typedef uint32_t RoiUtil::roitype_t

Definition at line 21 of file RoiSerialise.h.

Enumeration Type Documentation

◆ MASK

enum RoiUtil::MASK

Enumerator
FULLSCAN
COMPOSITE
ROITYPE

Definition at line 35 of file RoiSerialise.cxx.

            { 
    FULLSCAN  = 0x1,
    COMPOSITE = 0x2, 
    ROITYPE   = 0x4
  };

◆ ROIENUM

enum RoiUtil::ROIENUM

Enumerator
PARAM
ETA
ETAMINUS
ETAPLUS
PHI
PHIMINUS
PHIPLUS
ZED
ZEDMINUS
ZEDPLUS

Definition at line 28 of file RoiSerialise.cxx.

               { 
    PARAM,
    ETA, ETAMINUS, ETAPLUS, 
    PHI, PHIMINUS, PHIPLUS, 
    ZED, ZEDMINUS, ZEDPLUS 
  };

Function Documentation

◆ contains() [1/2]

bool RoiUtil::contains	(	const IRoiDescriptor &	roi,
		double	z,
		double	r,
		double	phi )

see whether a point is contained within the roi (in phi and r-z)

Definition at line 110 of file RoiUtil.cxx.

                                                                                  {
  if ( roi.composite() ) {
    for ( const IRoiDescriptor* rd : roi ) {
      if ( RoiUtil::contains( *rd, z, r, phi ) ) return true;
    }
    return false;
  }
  else { 
    return ( RoiUtil::containsZed( roi, z, r ) && RoiUtil::containsPhi( roi, phi ) );
  }
}

◆ contains() [2/2]

bool RoiUtil::contains	(	const IRoiDescriptor &	roi,
		double	z0,
		double	dzdr )

see whether a segment is contained within the roi in r-z

test whether a stub is contained within the roi

Definition at line 42 of file RoiUtil.cxx.

                                                                          {
  const double zouter = dzdr*MAX_R + z0;
 
  auto contains_internal = [zouter, z0]( const IRoiDescriptor& rd )  {
    return ( z0<=rd.zedPlus() && z0>=rd.zedMinus() &&
             zouter<=rd.zedOuterPlus() && zouter>=rd.zedOuterMinus() );
  };
 
  if ( roi.composite() ) {
    for ( const IRoiDescriptor* rd : roi ) {
      if ( contains_internal( *rd ) ) return true;
    }
    return false;
  }
  else return contains_internal( roi );
} 

◆ contains_zrange()

bool RoiUtil::contains_zrange	(	const IRoiDescriptor &	roi,
		double	z0,
		double	dzdr,
		double	zmin,
		double	zmax )

Definition at line 60 of file RoiUtil.cxx.

                                                                                                           { 
  const double zouter = dzdr*MAX_R + z0;
 
  auto contains_internal = [zouter, z0, zmin, zmax]( const IRoiDescriptor& rd )  {
    return ( z0<=zmax && z0>=zmin &&
             zouter<=rd.zedOuterPlus() && zouter>=rd.zedOuterMinus() );
  };
 
  if ( roi.composite() ) {
    for ( const IRoiDescriptor* rd : roi ) {
      if ( contains_internal( *rd ) ) return true;
    }
    return false;
  }
  else return contains_internal( roi );
}

◆ containsPhi()

bool RoiUtil::containsPhi	(	const IRoiDescriptor &	roi,
		double	phi )

test whether a stub is contained within the roi

Definition at line 79 of file RoiUtil.cxx.

                                                                 {
  if ( roi.composite() ) {
    for ( const IRoiDescriptor* rd : roi ) {
      if ( RoiUtil::containsPhi( *rd, phi ) ) return true;
    }
    return false;
  }
  else {
    if ( roi.isFullscan() ) return true; 
    if ( roi.phiPlus()>roi.phiMinus() ) return ( phi<roi.phiPlus() && phi>roi.phiMinus() );
    else                                return ( phi<roi.phiPlus() || phi>roi.phiMinus() );
  } 
}

◆ containsZed()

bool RoiUtil::containsZed	(	const IRoiDescriptor &	roi,
		double	z,
		double	r )

Definition at line 94 of file RoiUtil.cxx.

                                                                         {
  if ( roi.composite() ) {
    for ( const IRoiDescriptor* rd : roi ) {
      if ( RoiUtil::containsZed( *rd, z, r ) ) return true;
    }
    return false;
  }
  else { 
    if ( roi.isFullscan() ) return true;
    double zminus = r*roi.dzdrMinus() + roi.zedMinus();
    double zplus  = r*roi.dzdrPlus()  + roi.zedPlus();
    return ( z>=zminus && z<=zplus );
  }
}

◆ deserialise() [1/3]

void RoiUtil::deserialise	(	const roiserial_type &	s,
		std::vector< const IRoiDescriptor * > &	rois )

deserialise uint32_t vector into a full vector of IRoiDescriptors

deserialise a serialised vector into a full vector of IRoiDescriptors

Definition at line 62 of file RoiSerialise.cxx.

                                                                                                  { 
  if ( s.empty() ) return;
  rois.resize(s.size());
  for ( size_t i=0 ; i<s.size() ; i++ ) { 
    if ( s[i].empty() ) continue;
    const roitype_t* s_end  = &s[i][0];
    const roitype_t* s_last = &s[i].back();
    rois[i] = RoiUtil::deserialise( s_end, s_last );
  } 
  // const roitype_t* s_end  = &s[0];
  // const roitype_t* s_last = &s.back();
  // while ( s_end<s_last ) rois.push_back( RoiUtil::deserialise( s_end, s_last ) );
}

◆ deserialise() [2/3]

void RoiUtil::deserialise	(	const roiserial_type &	s,
		TrigRoiDescriptorCollection &	rois )

deserialise uint32_t vector into a TrigRoiDescriptorCollection

deserialise a serialised vector into a full vector of IRoiDescriptors

Oh dear, or dear rois.push_back( RoiUtil::deserialise( s_end, s_last ) );

while ( s_end<s_last )

Definition at line 78 of file RoiSerialise.cxx.

                                                                                             { 
  if ( s.empty() ) return;
  for ( size_t i=0 ; i<s.size() ; i++ ) { 
    if ( s[i].empty() ) continue;
    const roitype_t* s_end  = &s[i][0];
    const roitype_t* s_last = &s[i].back();
    rois.push_back( dynamic_cast<TrigRoiDescriptor*>(RoiUtil::deserialise( s_end, s_last )) );
 
  }
  //  const roitype_t* s_end  = &s[0];
  //  const roitype_t* s_last = &s.back();
  //  while ( s_end<s_last ) rois.push_back( dynamic_cast<TrigRoiDescriptor*>(RoiUtil::deserialise( s_end, s_last )) );
}

◆ deserialise() [3/3]

IRoiDescriptor * RoiUtil::deserialise	(	const roitype_t *&	s_end,
		const roitype_t *	s_last )

deserialise to a single IRoiDescriptors (including constituents)

get the packed version / fullscan / composite word

get the version

at this point we can have some customisation for the version number if required

is it a fullscan roi ?

is it a composite roi

set the expected limit of the serialised roitype_t container

calculate the untimate end of the basic roi roitype_t container

protection against over flowing the vector contents NB: this should really print an error or throw an exception but skipped in the interests of code portability

actually s_end becomes the address of the next word

get the additional (unwanted) roi words if required

create if fullscan

if not full scan, create with the roi parameters ...

this requires the roi words ... NB: if not required, the roi words are all set to 0

created the roi, now set composite if required NB: this is needed in case it is composite, but has no constituents

create constituents if required

Definition at line 162 of file RoiSerialise.cxx.

                                                                                                      {
 
  TrigRoiDescriptor* roi = 0;
 
  const roitype_t* s = s_end;
  uint32_t param = *(reinterpret_cast<const uint32_t*>(&s[RoiUtil::PARAM]));
  int version = (param>>8);
  bool fullscan  = false;
  if (param&1) fullscan  = true;
  bool composite = false;
  if (param&2) composite = true;
 
  bool roiwords = false;
  if (param&4) roiwords  = true;
     
  if ( fullscan ) s_end += RoiUtil::PARAM;
  else            s_end += RoiUtil::ZEDPLUS;
  unsigned Nextra = ( roiwords ? 3 : 0 );    
  s_end += Nextra;
  
  if ( s_end>s_last ) return 0; 
  s_end++;
  unsigned extra[3] = { 0, 0, 0 };
  unsigned extra_start = ( fullscan ? RoiUtil::PARAM+1 : RoiUtil::ZEDPLUS+1 );
 
  for ( unsigned i=0 ; i<Nextra ; i++ ) extra[i] = unsigned( s[extra_start+i] );
  
  unsigned roiWord = extra[0];
  unsigned l1Id    = extra[1];
  unsigned roiId   = extra[2];    
  if ( fullscan ) roi = new TrigRoiDescriptor( true );
  else {     
    roi = new TrigRoiDescriptor( roiWord, l1Id, roiId, 
                 fconv(s[RoiUtil::ETA]), fconv(s[RoiUtil::ETAMINUS]), fconv(s[RoiUtil::ETAPLUS]), 
                 fconv(s[RoiUtil::PHI]), fconv(s[RoiUtil::PHIMINUS]), fconv(s[RoiUtil::PHIPLUS]), 
                 fconv(s[RoiUtil::ZED]), fconv(s[RoiUtil::ZEDMINUS]), fconv(s[RoiUtil::ZEDPLUS]) ); 
 
  }
 
  if ( roi && version>roi->version() ) roi->version( version );
 
  
  if ( roi && composite ) { 
 
    roi->setComposite(true); 
  
    
    unsigned size   = *s_end;
    
    s_end++;
    
    std::cout << "size " << size << std::endl;
 
    if ( size>0 ) { 
      for ( unsigned i=0 ; i<size ; i++ ) { 
    roi->push_back( RoiUtil::deserialise( s_end, s_last ) ); 
      } 
    }
  }
  
  return roi;
      
} 

◆ etacheck()

double RoiUtil::etacheck ( double eta )

Definition at line 133 of file RoiUtil.cxx.

                                   {
  if ( !(eta>-100  && eta<100) ) { // check also for nan
    throw range_error( (std::string("eta out of range: ")+std::to_string(eta)).c_str() ); 
  } 
  return eta;
}

◆ phicheck()

double RoiUtil::phicheck ( double phi )

basic range checkers

Definition at line 123 of file RoiUtil.cxx.

                                   {
  while ( phi> M_PIF ) phi-=M_2PI;
  while ( phi<-M_PIF ) phi+=M_2PI;
  if ( !(phi >= -M_PIF && phi <= M_PIF) ) { // use ! of range rather than range to also catch nan etc
    throw range_error( (std::string("phi out of range: ")+std::to_string(phi)).c_str() ); 
  } 
  return phi;
}

◆ serialise() [1/3]

void RoiUtil::serialise	(	const IRoiDescriptor *	roi,
		std::vector< roitype_t > &	s )

serialise a single IRoiDescriptor

serialise a single IRoiDescriptor (including constituents)

packed version number

pack fullscan flag

pack the composite flag

push back the additional (unwanted?) roi ID variables

now actual roi parameters

number of constituents if a composite roi

now serialise the constituents ...

Definition at line 97 of file RoiSerialise.cxx.

                                                                                   {
  
  uint32_t param = ( (roi->version()&0xff) << 8);
  //  if ( roi->isFullscan() ) param |= 1;
  if ( roi->isFullscan() ) param |= RoiUtil::FULLSCAN;
  //  if ( roi->composite() )  param |= 0x2;
  if ( roi->composite() )  param |= RoiUtil::COMPOSITE;
  uint32_t extra[3] = { roi->roiWord(), roi->l1Id(), roi->roiId() };
 
  //  bool plusextra = false;
  //  for ( int i=0 ; i<3 ; i++ ) plusextra |= ( extra[i]!=0 );
  bool plusextra = ( extra[0]!=0 ) || ( extra[1]!=0 ) || ( extra[2]!=0 );
 
  //  if ( plusextra ) param |= 0x4;
  if ( plusextra ) param |= RoiUtil::ROITYPE;
 
  //  s.push_back( roi->isFullscan() ? 1 : 0 );
  s.push_back( * static_cast<roitype_t*>(&param) );
 
  int Nextra = 0;
  if ( plusextra ) Nextra = 3;
 
  if ( !roi->isFullscan() ) { 
     s.push_back( uconv(roi->eta()) );
     s.push_back( uconv(roi->etaMinus()) );
     s.push_back( uconv(roi->etaPlus()) );
    
     s.push_back( uconv(roi->phi()) );
     s.push_back( uconv(roi->phiMinus()) );
     s.push_back( uconv(roi->phiPlus()) );
    
     s.push_back( uconv(roi->zed()) );
     s.push_back( uconv(roi->zedMinus()) );
     s.push_back( uconv(roi->zedPlus()) );
  }    
 
  for ( int i=0 ; i<Nextra ; i++ ) s.push_back( extra[i] ); // push back the size of extra information if required
  if ( roi->composite() ) { 
    s.push_back( roi->size() );
    //  if ( roi->composite() && roi->size()>0 ) {
    if ( roi->size()>0 ) {
      IRoiDescriptor::roi_iterator itr  = roi->begin();
      IRoiDescriptor::roi_iterator iend = roi->end();
      while ( itr!=iend ) RoiUtil::serialise( *itr++, s );
    }
  }    
 
} 

◆ serialise() [2/3]

void RoiUtil::serialise	(	const std::vector< const IRoiDescriptor * > &	rois,
		RoiUtil::roiserial_type &	s )

serialise an entire vector of IRoiDescriptors

serialise a vector of IRoiDescriptors

Definition at line 45 of file RoiSerialise.cxx.

                                                                                                { 
  s.clear();
  s.resize(rois.size());
  for ( size_t i=0 ; i<rois.size() ; i++ ) RoiUtil::serialise( rois[i], s[i] );   
}

◆ serialise() [3/3]

void RoiUtil::serialise	(	const TrigRoiDescriptorCollection &	rois,
		RoiUtil::roiserial_type &	s )

serialise an entire TrigRoiDescriptor collection