VP1CaloCellManager Class Reference

#include <VP1CaloCellManager.h>

Inheritance diagram for VP1CaloCellManager:

Collaboration diagram for VP1CaloCellManager:

Public Slots
void	selectionUpdated (const VP1CCIntervalMap &)
void	scaleUpdated (const QPair< bool, double > &)
void	outlineUpdated (const bool &)
void	globalCutsUpdated (const VP1CC_GlobalCuts &)
void	clipVolumeRadiusChanged (double radius)

Public Member Functions
	VP1CaloCellManager (VP1CC_SelectionTypes type, VP1CC_SoNode2CCMap *node2cc, bool useEt, const QPair< bool, double > &scale, bool outline, const VP1CC_GlobalCuts &globalCuts)
	~VP1CaloCellManager ()
void	add (VP1CaloCell *cell)

Private Member Functions
void	updateScene (const VP1Interval &newInterval, bool positive)

Private Attributes
VP1CC_SelectionTypes	m_type
VP1CC_SoNode2CCMap *	m_node2cc
bool	m_useEt
QPair< bool, double >	m_scale
bool	m_outline
VP1CCMultimap	m_positiveCells
VP1CCMultimap	m_negativeCells
VP1CCMultimapIterator	m_firstDisplayedPos
VP1CCMultimapIterator	m_lastDisplayedPos
VP1CCMultimapIterator	m_firstDisplayedNeg
VP1CCMultimapIterator	m_lastDisplayedNeg
VP1CCIntervalPair	m_intervals
VP1CC_GlobalCuts	m_globalCuts

Detailed Description

Definition at line 38 of file VP1CaloCellManager.h.

Constructor & Destructor Documentation

VP1CaloCellManager()

VP1CaloCellManager::VP1CaloCellManager	(	VP1CC_SelectionTypes	type,
		VP1CC_SoNode2CCMap *	node2cc,
		bool	useEt,
		const QPair< bool, double > &	scale,
		bool	outline,
		const VP1CC_GlobalCuts &	globalCuts )

Definition at line 12 of file VP1CaloCellManager.cxx.

                                                          :
  m_type(type),
  m_node2cc(node2cc),
  m_useEt(useEt),
  m_scale(scale),
  m_outline(outline),
  m_globalCuts(globalCuts)
{
  // Initialize private iterators
  m_firstDisplayedPos = m_positiveCells.end();
  m_lastDisplayedPos  = m_positiveCells.end();
  m_firstDisplayedNeg = m_negativeCells.end();
  m_lastDisplayedNeg  = m_negativeCells.end();
 
  m_intervals = VP1CCIntervalPair(VP1Interval(),VP1Interval());
}

~VP1CaloCellManager()

VP1CaloCellManager::~VP1CaloCellManager

(

)

Definition at line 34 of file VP1CaloCellManager.cxx.

{
  // Clear multimaps
  VP1CCMultimapIterator it = m_positiveCells.begin();
  while(it!=m_positiveCells.end()) {
    if(it->second) {
      delete it->second;
      it->second = 0;
    }
    ++it;
  }
 
  it = m_negativeCells.begin();
  while(it!=m_negativeCells.end()) {
    if(it->second) {
      delete it->second;
      it->second = 0;
    }
    ++it;
  }
 
  m_positiveCells.clear();
  m_negativeCells.clear();
}

Member Function Documentation

add()

void VP1CaloCellManager::add

(

VP1CaloCell *

cell

)

Definition at line 59 of file VP1CaloCellManager.cxx.

{
  double energy = cell->getCaloCell()->energy();
 
  if(m_useEt)
    energy = cell->energyToTransverse(energy);
 
  // We need to choose which map to add the new cell to according to its energy sign
  VP1CCMultimap& useMap = energy < 0 ? m_negativeCells : m_positiveCells;
 
  // This is going to be the new key in the map
  double ccKey = fabs(energy);
 
  // Add new element to the map
  useMap.emplace(ccKey,cell);
}

clipVolumeRadiusChanged

void VP1CaloCellManager::clipVolumeRadiusChanged ( double radius )

slot

Definition at line 128 of file VP1CaloCellManager.cxx.

{
  m_globalCuts.clipRadius=radius; // Adjust radius to match new value
  for(VP1CCMultimapIterator it=m_firstDisplayedPos; it!=m_lastDisplayedPos; ++it)
    it->second->updateScene(m_node2cc,m_useEt,m_scale,m_outline,m_globalCuts);
  for(VP1CCMultimapIterator it=m_firstDisplayedNeg; it!=m_lastDisplayedNeg; ++it)
    it->second->updateScene(m_node2cc,m_useEt,m_scale,m_outline,m_globalCuts);
}

globalCutsUpdated

void VP1CaloCellManager::globalCutsUpdated ( const VP1CC_GlobalCuts & new_cuts )

slot

Definition at line 119 of file VP1CaloCellManager.cxx.

{
  m_globalCuts = new_cuts;
  for(VP1CCMultimapIterator it=m_firstDisplayedPos; it!=m_lastDisplayedPos; ++it)
    it->second->updateScene(m_node2cc,m_useEt,m_scale,m_outline,m_globalCuts);
  for(VP1CCMultimapIterator it=m_firstDisplayedNeg; it!=m_lastDisplayedNeg; ++it)
    it->second->updateScene(m_node2cc,m_useEt,m_scale,m_outline,m_globalCuts);
}

outlineUpdated

void VP1CaloCellManager::outlineUpdated ( const bool & new_outline )

slot

Definition at line 103 of file VP1CaloCellManager.cxx.

{
  m_outline = new_outline;
 
  // Redraw objects with new outline settings
  // Pos
  for(VP1CCMultimapIterator it=m_firstDisplayedPos; it!=m_lastDisplayedPos; ++it) {
    it->second->updateScene(m_node2cc,m_useEt,m_scale,m_outline,m_globalCuts);
  }
 
  // Neg
  for(VP1CCMultimapIterator it=m_firstDisplayedNeg; it!=m_lastDisplayedNeg; ++it) {
    it->second->updateScene(m_node2cc,m_useEt,m_scale,m_outline,m_globalCuts);
  }
}

scaleUpdated

void VP1CaloCellManager::scaleUpdated ( const QPair< bool, double > & new_scale )

slot

Definition at line 87 of file VP1CaloCellManager.cxx.

{
  m_scale = new_scale;
 
  // Redraw objects with new scale
  // Pos
  for(VP1CCMultimapIterator it=m_firstDisplayedPos; it!=m_lastDisplayedPos; ++it) {
    it->second->updateScene(m_node2cc,m_useEt,m_scale,m_outline,m_globalCuts);
  }
 
  // Neg
  for(VP1CCMultimapIterator it=m_firstDisplayedNeg; it!=m_lastDisplayedNeg; ++it) {
    it->second->updateScene(m_node2cc,m_useEt,m_scale,m_outline,m_globalCuts);
  }
}

selectionUpdated

void VP1CaloCellManager::selectionUpdated ( const VP1CCIntervalMap & intervals )

slot

Definition at line 77 of file VP1CaloCellManager.cxx.

{
  VP1CCIntervalMap::const_iterator it = intervals.find(m_type);
  if(it!=intervals.end()) {
    // Update scene with pos/neg cells
    updateScene(it->first,true);
    updateScene(it->second,false);
  }
}

updateScene()

void VP1CaloCellManager::updateScene ( const VP1Interval & newInterval, bool positive )

private

Definition at line 138 of file VP1CaloCellManager.cxx.

{
  // We need to choose which map to work with, according to the value of 'positive' flag
  VP1CCMultimap* useMap = 0;
  VP1CCMultimapIterator* useItFirst = 0;
  VP1CCMultimapIterator* useItLast = 0;
  VP1Interval* currentInterval = 0;
 
  if(positive) {
    useMap = &m_positiveCells;
    useItFirst = &m_firstDisplayedPos;
    useItLast = &m_lastDisplayedPos;
    currentInterval = &m_intervals.first;
  } else {
    useMap = &m_negativeCells;
    useItFirst = &m_firstDisplayedNeg;
    useItLast = &m_lastDisplayedNeg;
    currentInterval = &m_intervals.second;
  }
 
  // If new iterval is equal to the existing one just check global cuts
  if(*currentInterval==newInterval) {
    for(VP1CCMultimapIterator it=*useItFirst; it!=*useItLast; ++it)
      it->second->updateScene(m_node2cc,m_useEt,m_scale,m_outline,m_globalCuts);
    return;
  }
 
  // If new interval is empty hide everything and update the current interval
  if(newInterval.isEmpty()) {
    for(VP1CCMultimapIterator it=*useItFirst; it!=*useItLast; ++it)
      it->second->remove3DObjects(m_node2cc);
    *currentInterval = newInterval;
    *useItFirst = useMap->end();
    *useItLast = useMap->end();
    return;
  }
 
  // If old interval was empty, find values for first & last iterators and
  // display everything between them, taking into account global cuts
  if(currentInterval->isEmpty()) {
    *useItFirst = useMap->lower_bound(newInterval.lower());
    if(newInterval.upper() == VP1Interval::inf())
      *useItLast = useMap->end();
    else
      *useItLast = useMap->upper_bound(newInterval.upper());
 
    for(VP1CCMultimapIterator it=*useItFirst; it!=*useItLast; ++it)
      it->second->updateScene(m_node2cc,m_useEt,m_scale,m_outline,m_globalCuts);
 
    *currentInterval = newInterval;
    return;
  }
 
  // No one is empty.
  VP1CCMultimapIterator newIterator;
 
  if(currentInterval->lower() != newInterval.lower() &&
     currentInterval->upper() != newInterval.upper()) {
    // This is unexpected!
    // Hide everything what was there before and display new thresholds
    for(VP1CCMultimapIterator it=*useItFirst; it!=*useItLast; ++it)
      it->second->remove3DObjects(m_node2cc);
 
    *useItFirst = useMap->lower_bound(newInterval.lower());
    if(newInterval.upper() == VP1Interval::inf())
      *useItLast = useMap->end();
    else
      *useItLast = useMap->upper_bound(newInterval.upper());
 
    for(VP1CCMultimapIterator it=*useItFirst; it!=*useItLast; ++it)
      it->second->updateScene(m_node2cc,m_useEt,m_scale,m_outline,m_globalCuts);
 
  } else if (currentInterval->lower() != newInterval.lower()) {
    // Adjust lower threshold
    newIterator = useMap->lower_bound(newInterval.lower());
 
    if(currentInterval->lower() < newInterval.lower())
      // May need to hide something
      for(VP1CCMultimapIterator it=*useItFirst; it!=newIterator; ++it)
    it->second->remove3DObjects(m_node2cc);
    else
      // May need to add new objects to the scene
      for(VP1CCMultimapIterator it=newIterator; it!=*useItFirst; ++it)
    it->second->updateScene(m_node2cc,m_useEt,m_scale,m_outline,m_globalCuts);
 
    *useItFirst = newIterator;
 
  } else {
 
    // Adjust upper threshold
    if(newInterval.upper() == VP1Interval::inf()) {
      newIterator = useMap->end();
 
      // May need to add new objects to the scene
      for(VP1CCMultimapIterator it=*useItLast; it!=newIterator; ++it)
    it->second->updateScene(m_node2cc,m_useEt,m_scale,m_outline,m_globalCuts);
    } else {
      newIterator = useMap->upper_bound(newInterval.upper());
 
      if(*useItLast == useMap->end() ||
     currentInterval->upper() > newInterval.upper()) {
    // May need to hide something
    for(VP1CCMultimapIterator it=newIterator; it!=*useItLast; ++it)
      it->second->remove3DObjects(m_node2cc);
      } else {
    // May need to add new objects to the scene
    for(VP1CCMultimapIterator it=*useItLast; it!=newIterator; ++it)
      it->second->updateScene(m_node2cc,m_useEt,m_scale,m_outline,m_globalCuts);
      }
    }
    *useItLast = newIterator;
  }
 
  *currentInterval = newInterval;
}

Member Data Documentation

m_firstDisplayedNeg

VP1CCMultimapIterator VP1CaloCellManager::m_firstDisplayedNeg

private

Definition at line 90 of file VP1CaloCellManager.h.

m_firstDisplayedPos

VP1CCMultimapIterator VP1CaloCellManager::m_firstDisplayedPos

private

Definition at line 88 of file VP1CaloCellManager.h.

m_globalCuts

VP1CC_GlobalCuts VP1CaloCellManager::m_globalCuts

private

Definition at line 97 of file VP1CaloCellManager.h.

m_intervals

VP1CCIntervalPair VP1CaloCellManager::m_intervals

private

Definition at line 94 of file VP1CaloCellManager.h.

m_lastDisplayedNeg

VP1CCMultimapIterator VP1CaloCellManager::m_lastDisplayedNeg

private

Definition at line 91 of file VP1CaloCellManager.h.

m_lastDisplayedPos

VP1CCMultimapIterator VP1CaloCellManager::m_lastDisplayedPos

private

Definition at line 89 of file VP1CaloCellManager.h.

m_negativeCells

VP1CCMultimap VP1CaloCellManager::m_negativeCells

private

Definition at line 85 of file VP1CaloCellManager.h.

m_node2cc

VP1CC_SoNode2CCMap* VP1CaloCellManager::m_node2cc

private

Definition at line 72 of file VP1CaloCellManager.h.

m_outline

bool VP1CaloCellManager::m_outline

private

Definition at line 81 of file VP1CaloCellManager.h.

m_positiveCells

VP1CCMultimap VP1CaloCellManager::m_positiveCells

private

Definition at line 84 of file VP1CaloCellManager.h.

m_scale

QPair<bool,double> VP1CaloCellManager::m_scale

private

Definition at line 78 of file VP1CaloCellManager.h.

m_type

VP1CC_SelectionTypes VP1CaloCellManager::m_type

private

Definition at line 69 of file VP1CaloCellManager.h.

m_useEt

bool VP1CaloCellManager::m_useEt

private

Definition at line 75 of file VP1CaloCellManager.h.

---

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

• VP1CaloCellManager.h
• VP1CaloCellManager.cxx