Public Member Functions
	Clockwork ()
	~Clockwork ()
	Clockwork (const Clockwork &)=delete
Clockwork &	operator= (const Clockwork &)=delete
void	BuildCellManagers ()
void	FillManagers ()
std::string	SearchTileRawchanKeys (const std::vector< std::string > &inputKeys)

Public Attributes
VP1CaloCellController *	controller {nullptr}
bool	noCalo {false}
bool	noLArDigitsGlobal {false}
bool	noLArDigitsEvent {false}
bool	noTileDigitsGlobal {false}
bool	noTileDigitsEvent {false}
bool	modeSimple {true}
const TileDetDescrManager *	tile_dd_man {nullptr}
const CaloCell_ID *	calo_id {nullptr}
const TileID *	tile_id {nullptr}
const TileHWID *	tile_hw_id {nullptr}
const TileInfo *	tile_info {nullptr}
const TileCablingService *	tile_cabling {nullptr}
const LArOnlineID *	lar_onlineID {nullptr}
const ICaloBadChanTool *	calo_badchannel {nullptr}
const CaloCellContainer *	calocells {nullptr}
const LArDigitContainer *	lar_digits {nullptr}
const TileDigitsContainer *	tile_digits {nullptr}
const TileRawChannelContainer *	tile_rawchannel {nullptr}
VP1CCManagerContainer	cell_managers
VP1MbtsHelper *	mbtsHelper
VP1CC_SoNode2CCMap	node2ccMap
VP1CC_SeparatorMap	sepHelperMap
VP1CC_SeparatorTypesSet	sepTypes

Detailed Description

Definition at line 61 of file VP1CaloCellSystem.cxx.

Constructor & Destructor Documentation

◆ Clockwork() [1/2]

VP1CaloCellSystem::Clockwork::Clockwork ( )

Definition at line 161 of file VP1CaloCellSystem.cxx.

: mbtsHelper(new VP1MbtsHelper(false))
{
    // Initialize set of available separator types besides MBTS
    sepTypes.insert(VP1CC_SepLArEMBPos);
    sepTypes.insert(VP1CC_SepLArEMECPos);
    sepTypes.insert(VP1CC_SepLArHECPos);
    sepTypes.insert(VP1CC_SepLArFCALPos);
    sepTypes.insert(VP1CC_SepLArEMBNeg);
    sepTypes.insert(VP1CC_SepLArEMECNeg);
    sepTypes.insert(VP1CC_SepLArHECNeg);
    sepTypes.insert(VP1CC_SepLArFCALNeg);
    sepTypes.insert(VP1CC_SepTilePositiveUp);
    sepTypes.insert(VP1CC_SepTilePositiveDown);
    sepTypes.insert(VP1CC_SepTilePositiveNeg);
    sepTypes.insert(VP1CC_SepTileNegativeUp);
    sepTypes.insert(VP1CC_SepTileNegativeDown);
    sepTypes.insert(VP1CC_SepTileNegativePos);
}

◆ ~Clockwork()

VP1CaloCellSystem::Clockwork::~Clockwork ( )

Definition at line 181 of file VP1CaloCellSystem.cxx.

{
    if(mbtsHelper) delete mbtsHelper;
}

◆ Clockwork() [2/2]

VP1CaloCellSystem::Clockwork::Clockwork ( const Clockwork & )

delete

Member Function Documentation

◆ BuildCellManagers()

void VP1CaloCellSystem::Clockwork::BuildCellManagers ( )

Definition at line 186 of file VP1CaloCellSystem.cxx.

{
    // Populate cell_managers map
    cell_managers[VP1CC_SelTypeEMB0] = new VP1CaloCellManager(VP1CC_SelTypeEMB0,&node2ccMap,
            controller->energyModeEt(),controller->scale(),
            controller->showVolumeOutLines(),controller->globalCuts());
    cell_managers[VP1CC_SelTypeEMB1] = new VP1CaloCellManager(VP1CC_SelTypeEMB1,&node2ccMap,
            controller->energyModeEt(),controller->scale(),
            controller->showVolumeOutLines(),controller->globalCuts());
    cell_managers[VP1CC_SelTypeEMB2] = new VP1CaloCellManager(VP1CC_SelTypeEMB2,&node2ccMap,
            controller->energyModeEt(),controller->scale(),
            controller->showVolumeOutLines(),controller->globalCuts());
    cell_managers[VP1CC_SelTypeEMB3] = new VP1CaloCellManager(VP1CC_SelTypeEMB3,&node2ccMap,
            controller->energyModeEt(),controller->scale(),
            controller->showVolumeOutLines(),controller->globalCuts());
    cell_managers[VP1CC_SelTypeEMEC0] = new VP1CaloCellManager(VP1CC_SelTypeEMEC0,&node2ccMap,
            controller->energyModeEt(),controller->scale(),
            controller->showVolumeOutLines(),controller->globalCuts());
    cell_managers[VP1CC_SelTypeEMEC1] = new VP1CaloCellManager(VP1CC_SelTypeEMEC1,&node2ccMap,
            controller->energyModeEt(),controller->scale(),
            controller->showVolumeOutLines(),controller->globalCuts());
    cell_managers[VP1CC_SelTypeEMEC2] = new VP1CaloCellManager(VP1CC_SelTypeEMEC2,&node2ccMap,
            controller->energyModeEt(),controller->scale(),
            controller->showVolumeOutLines(),controller->globalCuts());
    cell_managers[VP1CC_SelTypeEMEC3] = new VP1CaloCellManager(VP1CC_SelTypeEMEC3,&node2ccMap,
            controller->energyModeEt(),controller->scale(),
            controller->showVolumeOutLines(),controller->globalCuts());
    cell_managers[VP1CC_SelTypeHEC0] = new VP1CaloCellManager(VP1CC_SelTypeHEC0,&node2ccMap,
            controller->energyModeEt(),controller->scale(),
            controller->showVolumeOutLines(),controller->globalCuts());
    cell_managers[VP1CC_SelTypeHEC1] = new VP1CaloCellManager(VP1CC_SelTypeHEC1,&node2ccMap,
            controller->energyModeEt(),controller->scale(),
            controller->showVolumeOutLines(),controller->globalCuts());
    cell_managers[VP1CC_SelTypeHEC2] = new VP1CaloCellManager(VP1CC_SelTypeHEC2,&node2ccMap,
            controller->energyModeEt(),controller->scale(),
            controller->showVolumeOutLines(),controller->globalCuts());
    cell_managers[VP1CC_SelTypeHEC3] = new VP1CaloCellManager(VP1CC_SelTypeHEC3,&node2ccMap,
            controller->energyModeEt(),controller->scale(),
            controller->showVolumeOutLines(),controller->globalCuts());
    cell_managers[VP1CC_SelTypeFCAL1] = new VP1CaloCellManager(VP1CC_SelTypeFCAL1,&node2ccMap,
            controller->energyModeEt(),controller->scale(),
            controller->showVolumeOutLines(),controller->globalCuts());
    cell_managers[VP1CC_SelTypeFCAL2] = new VP1CaloCellManager(VP1CC_SelTypeFCAL2,&node2ccMap,
            controller->energyModeEt(),controller->scale(),
            controller->showVolumeOutLines(),controller->globalCuts());
    cell_managers[VP1CC_SelTypeFCAL3] = new VP1CaloCellManager(VP1CC_SelTypeFCAL3,&node2ccMap,
            controller->energyModeEt(),controller->scale(),
            controller->showVolumeOutLines(),controller->globalCuts());
    cell_managers[VP1CC_SelTypeTileB] = new VP1CaloCellManager(VP1CC_SelTypeTileB,&node2ccMap,
            controller->energyModeEt(),controller->scale(),
            controller->showVolumeOutLines(),controller->globalCuts());
    cell_managers[VP1CC_SelTypeTileEC] = new VP1CaloCellManager(VP1CC_SelTypeTileEC,&node2ccMap,
            controller->energyModeEt(),controller->scale(),
            controller->showVolumeOutLines(),controller->globalCuts());
    cell_managers[VP1CC_SelTypeTileCrack] = new VP1CaloCellManager(VP1CC_SelTypeTileCrack,&node2ccMap,
            controller->energyModeEt(),controller->scale(),
            controller->showVolumeOutLines(),controller->globalCuts());
 
    // Connect controller signals to manager slots
    for(VP1CCManagerContainer::iterator it=cell_managers.begin(); it!=cell_managers.end(); ++it) {
        connect(controller,SIGNAL(selectionIntervalsChanged(VP1CCIntervalMap)),
                it->second,SLOT(selectionUpdated(VP1CCIntervalMap)));
        connect(controller,SIGNAL(scaleChanged(QPair<bool,double>)),
                it->second,SLOT(scaleUpdated(QPair<bool,double>)));
        connect(controller,SIGNAL(showVolumeOutLinesChanged(bool)),
                it->second,SLOT(outlineUpdated(bool)));
        connect(controller,SIGNAL(globalCutsChanged(VP1CC_GlobalCuts)),
                it->second,SLOT(globalCutsUpdated(VP1CC_GlobalCuts)));
        connect(controller->customTourEditor(),SIGNAL(clipVolumeRadiusChanged(double)),
                it->second,SLOT(clipVolumeRadiusChanged(double)));
    }
}

◆ FillManagers()

void VP1CaloCellSystem::Clockwork::FillManagers ( )

Definition at line 259 of file VP1CaloCellSystem.cxx.

{
    // For events with no Calo Cells do nothing
    if(!calocells) return;
 
    for(const CaloCell* cell : *calocells) {
 
        // for each cell:
        //   1. determine its type
        //   2. build VP1CaloCell of appropriate type
        //   3. add it to the appropriate manager
        try {
            if(calo_id->is_em_barrel(cell->ID())) {
                // ------- EMB ----------
                VP1CC_LArEMB* embCC = new VP1CC_LArEMB(cell,&sepHelperMap);
 
                switch(calo_id->sampling(cell->ID())) {
                case 0: {
                    cell_managers[VP1CC_SelTypeEMB0]->add(embCC);
                    break;
                }
                case 1: {
                    cell_managers[VP1CC_SelTypeEMB1]->add(embCC);
                    break;
                }
                case 2: {
                    cell_managers[VP1CC_SelTypeEMB2]->add(embCC);
                    break;
                }
                case 3: {
                    cell_managers[VP1CC_SelTypeEMB3]->add(embCC);
                    break;
                }
                default: { //unknown case, tidy up
                  delete embCC; embCC=nullptr;
                  break;
                }
                }
                // ------- EMB ----------
            }
            else if(calo_id->is_em_endcap(cell->ID()) || calo_id->is_hec(cell->ID())) {
                VP1CC_LArEMECHEC* emechecCC = new VP1CC_LArEMECHEC(cell,calo_id,&sepHelperMap);
 
                if(calo_id->is_em_endcap(cell->ID())) {
                    // ------- EMEC ----------
                    switch(calo_id->sampling(cell->ID())) {
                    case 0: {
                        cell_managers[VP1CC_SelTypeEMEC0]->add(emechecCC);
                        break;
                    }
                    case 1: {
                        cell_managers[VP1CC_SelTypeEMEC1]->add(emechecCC);
                        break;
                    }
                    case 2: {
                        cell_managers[VP1CC_SelTypeEMEC2]->add(emechecCC);
                        break;
                    }
                    case 3: {
                        cell_managers[VP1CC_SelTypeEMEC3]->add(emechecCC);
                        break;
                    }
                    default: { //unknown case, tidy up
                      delete emechecCC; emechecCC=nullptr;
                      break;
                    }
                    }
                    // ------- EMEC ----------
                } else {
                    // ------- HEC ----------
                    switch(calo_id->sampling(cell->ID())) {
                    case 0: {
                        cell_managers[VP1CC_SelTypeHEC0]->add(emechecCC);
                        break;
                    }
                    case 1: {
                        cell_managers[VP1CC_SelTypeHEC1]->add(emechecCC);
                        break;
                    }
                    case 2: {
                        cell_managers[VP1CC_SelTypeHEC2]->add(emechecCC);
                        break;
                    }
                    case 3: {
                        cell_managers[VP1CC_SelTypeHEC3]->add(emechecCC);
                        break;
                    }
                    default: { //unknown case, tidy up
                      delete emechecCC; emechecCC=nullptr;
                      break;
                    }
                    }
                    // ------- EMEC ----------
                }
            }
            else if(calo_id->is_fcal(cell->ID())) {
                // ------- FCAL ----------
                VP1CC_LArFCAL* fcalCC = new VP1CC_LArFCAL(cell,&sepHelperMap);
 
                switch(calo_id->sampling(cell->ID())) {
                case 1: {
                    cell_managers[VP1CC_SelTypeFCAL1]->add(fcalCC);
                    break;
                }
                case 2: {
                    cell_managers[VP1CC_SelTypeFCAL2]->add(fcalCC);
                    break;
                }
                case 3: {
                    cell_managers[VP1CC_SelTypeFCAL3]->add(fcalCC);
                    break;
                }
                default: { //unknown case, tidy up
                      delete fcalCC; fcalCC=nullptr;
                      break;
                    }
                }
                // ------- FCAL ----------
            }
            else if(!calo_id->is_tile_gapscin(cell->ID())) {
                // ------- Tile Barrel EC ----------
                VP1CC_TileBarEc* tileCC = new VP1CC_TileBarEc(cell,tile_id,&sepHelperMap);
 
                if(calo_id->is_tile_barrel(cell->ID()))
                    cell_managers[VP1CC_SelTypeTileB]->add(tileCC);
                else
                    cell_managers[VP1CC_SelTypeTileEC]->add(tileCC);
            }
            else if(calo_id->is_tile_gapscin(cell->ID())) {
                // ------- Tile Crack ----------
                VP1CC_TileCrack* tilecrackCC = new VP1CC_TileCrack(cell,tile_id,&sepHelperMap);
 
                cell_managers[VP1CC_SelTypeTileCrack]->add(tilecrackCC);
            }
        }
        catch(std::runtime_error& err) {
            // --- do nothing for now
            std::cout << "RunTime exception caught! --> " << err.what() << std::endl;
        }
    } // iterate over cells
}

◆ operator=()

Clockwork & VP1CaloCellSystem::Clockwork::operator= ( const Clockwork & )

delete

◆ SearchTileRawchanKeys()

std::string VP1CaloCellSystem::Clockwork::SearchTileRawchanKeys ( const std::vector< std::string > & inputKeys )

Definition at line 401 of file VP1CaloCellSystem.cxx.

{
    // Search order
    std::vector<std::string> searchOrder;
    searchOrder.push_back("TileRawChannelOpt2");
    searchOrder.push_back("TileRawChannelOpt");
    searchOrder.push_back("TileRawChannelFixed");
    searchOrder.push_back("TileRawChannelFitCool");
    searchOrder.push_back("TileRawChannelFit");
    searchOrder.push_back("TileRawChannelCnt");
    searchOrder.push_back("TileRawChannelFlt");
 
    for(size_t i=0; i<searchOrder.size(); ++i) {
        std::string searchString = searchOrder[i];
        for(size_t ii=0; ii<inputKeys.size(); ++ii)
            if(inputKeys[ii]==searchString)
                return searchString;
    }
    // No keys found from Search Order, return empty string
    return std::string("");
}

Member Data Documentation

◆ calo_badchannel

const ICaloBadChanTool* VP1CaloCellSystem::Clockwork::calo_badchannel {nullptr}

Definition at line 120 of file VP1CaloCellSystem.cxx.

120{nullptr};

◆ calo_id

const CaloCell_ID* VP1CaloCellSystem::Clockwork::calo_id {nullptr}

Definition at line 108 of file VP1CaloCellSystem.cxx.

108{nullptr};

◆ calocells

const CaloCellContainer* VP1CaloCellSystem::Clockwork::calocells {nullptr}

Definition at line 127 of file VP1CaloCellSystem.cxx.

127{nullptr};

◆ cell_managers

VP1CCManagerContainer VP1CaloCellSystem::Clockwork::cell_managers

Definition at line 137 of file VP1CaloCellSystem.cxx.

◆ controller

VP1CaloCellController* VP1CaloCellSystem::Clockwork::controller {nullptr}

Definition at line 84 of file VP1CaloCellSystem.cxx.

84{nullptr};

◆ lar_digits

const LArDigitContainer* VP1CaloCellSystem::Clockwork::lar_digits {nullptr}

Definition at line 128 of file VP1CaloCellSystem.cxx.

128{nullptr};

◆ lar_onlineID

const LArOnlineID* VP1CaloCellSystem::Clockwork::lar_onlineID {nullptr}

Definition at line 119 of file VP1CaloCellSystem.cxx.

119{nullptr};

◆ mbtsHelper

VP1MbtsHelper* VP1CaloCellSystem::Clockwork::mbtsHelper

Definition at line 144 of file VP1CaloCellSystem.cxx.

◆ modeSimple

bool VP1CaloCellSystem::Clockwork::modeSimple {true}

Definition at line 97 of file VP1CaloCellSystem.cxx.

97{true}; // Which mode (simple/expert) is used for LAr

◆ noCalo

bool VP1CaloCellSystem::Clockwork::noCalo {false}

Definition at line 91 of file VP1CaloCellSystem.cxx.

91{false}; // If Calo has been switched off don't show anything

◆ node2ccMap

VP1CC_SoNode2CCMap VP1CaloCellSystem::Clockwork::node2ccMap

Definition at line 152 of file VP1CaloCellSystem.cxx.

◆ noLArDigitsEvent

bool VP1CaloCellSystem::Clockwork::noLArDigitsEvent {false}

Definition at line 93 of file VP1CaloCellSystem.cxx.

93{false}; // Are we able to show LAr digits for this event?

◆ noLArDigitsGlobal

bool VP1CaloCellSystem::Clockwork::noLArDigitsGlobal {false}

Definition at line 92 of file VP1CaloCellSystem.cxx.

92{false}; // Are we able to show LAr digits at all?

◆ noTileDigitsEvent

bool VP1CaloCellSystem::Clockwork::noTileDigitsEvent {false}

Definition at line 95 of file VP1CaloCellSystem.cxx.

95{false}; // Are we able to show Tile digits for this event?

◆ noTileDigitsGlobal

bool VP1CaloCellSystem::Clockwork::noTileDigitsGlobal {false}

Definition at line 94 of file VP1CaloCellSystem.cxx.

94{false}; // Are we able to show Tile digits at all?

◆ sepHelperMap

VP1CC_SeparatorMap VP1CaloCellSystem::Clockwork::sepHelperMap

Definition at line 155 of file VP1CaloCellSystem.cxx.

◆ sepTypes

VP1CC_SeparatorTypesSet VP1CaloCellSystem::Clockwork::sepTypes

Definition at line 158 of file VP1CaloCellSystem.cxx.

◆ tile_cabling

const TileCablingService* VP1CaloCellSystem::Clockwork::tile_cabling {nullptr}

Definition at line 118 of file VP1CaloCellSystem.cxx.

118{nullptr};

◆ tile_dd_man

const TileDetDescrManager* VP1CaloCellSystem::Clockwork::tile_dd_man {nullptr}

Definition at line 105 of file VP1CaloCellSystem.cxx.

105{nullptr};

◆ tile_digits

const TileDigitsContainer* VP1CaloCellSystem::Clockwork::tile_digits {nullptr}

Definition at line 129 of file VP1CaloCellSystem.cxx.

129{nullptr};

◆ tile_hw_id

const TileHWID* VP1CaloCellSystem::Clockwork::tile_hw_id {nullptr}

Definition at line 110 of file VP1CaloCellSystem.cxx.

110{nullptr};

◆ tile_id

const TileID* VP1CaloCellSystem::Clockwork::tile_id {nullptr}

Definition at line 109 of file VP1CaloCellSystem.cxx.

109{nullptr};

◆ tile_info

const TileInfo* VP1CaloCellSystem::Clockwork::tile_info {nullptr}

Definition at line 117 of file VP1CaloCellSystem.cxx.

117{nullptr};

◆ tile_rawchannel

const TileRawChannelContainer* VP1CaloCellSystem::Clockwork::tile_rawchannel {nullptr}

Definition at line 130 of file VP1CaloCellSystem.cxx.

130{nullptr};

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

VP1CaloCellSystem.cxx

Public Member Functions

Public Attributes