This class provides access to ECL channel map that is either a) Loaded from the database (see ecl/dbobject/include/ECLChannelMap.h). More...

#include <ECLChannelMapper.h>

Public Member Functions
	ECLChannelMapper ()
	Default constructor.

	~ECLChannelMapper ()
	Default destructor.

bool	initFromFile ()
	Initialize channel mapper using data stored in default location.

bool	initFromFile (const char *eclMapFile)
	Initialize channel mapper using data stored in the ASCII file.

bool	initFromDB ()
	Initialize channel mapper from the conditions database.

ECLChannelMap	getDBObject ()
	Convert internal data to ECLChannelMap database object.

int	getCrateID (int iCOPPERNode, int iFINESSE, bool pcie40=false)
	Get crate number by given COPPER node number and FINESSE number.

int	getCellId (int iCrate, int iShaper, int iChannel)
	Get CellId by given crate number, shaper position in the crate and DSP channel number in the shaper.

int	getCOPPERNode (int iCrate)
	Get number of COPPER node by given crate number.

int	getFINESSE (int iCrate)
	Get number of FINESSE (0/1) in COPPER by given crate number.

int	getSubSystem (int iCrate)
	Get ECL subsystem ID by given crate number: 0 – barrel, 1 – forward. 2 – backward endcap.

int	getCrateID (int cellID)
	Get crate number by given CellId.

int	getShaperPosition (int cellID)
	Get position of the shaper in the crate by given CellId.

int	getShaperChannel (int cellID)
	Get number of DSP channel in the shaper by given number of CellId.

int	getElectronicsID (int cellID)
	Return channel index in ECLChannelMap.

int	getNShapersInCrate (int iCrate)
	Get number of ShaperDSP modules in the given VME crate number.

	ClassDef (ECLChannelMapper, 1)
	ClassDef.

Static Public Member Functions
static ECLChannelMapper *	getInstance (bool use_db=true)
	Return main instance of ECLChannelMapper.

Private Attributes
bool	isInitialized
	initialization flag

int	convertArrayBarrel [ECL_BARREL_CRATES ECL_BARREL_SHAPERS_IN_CRATE ECL_CHANNELS_IN_SHAPER]
	convert (iCrate, iShaper, iChannel) to CellId for Barrel ECL

int	convertArrayFWD [ECL_FWD_CRATES ECL_FWD_SHAPERS_IN_CRATE ECL_CHANNELS_IN_SHAPER]
	convert (iCrate, iShaper, iChannel) to CellId for Forward endcap

int	convertArrayBKW [ECL_BKW_CRATES ECL_BKW_SHAPERS_IN_CRATE ECL_CHANNELS_IN_SHAPER]
	convert (iCrate, iShaper, iChannel) to CellId Backward endcap

int	convertArrayInv [ECL_TOTAL_CHANNELS][3]
	convert CellId to (iCrate, iShaper, iChannel)

Static Private Attributes
static ECLChannelMapper *	instance = nullptr
	Main instance of ECLChannelMapper.

Detailed Description

This class provides access to ECL channel map that is either a) Loaded from the database (see ecl/dbobject/include/ECLChannelMap.h).

b) (** NOT SUPPORTED **) Loaded from the text file (standard location is FileSystem::findFile("ecl/data/ecl_channels_map.txt"))

Please note that (a) is recommended and (b) should be used only for very specific rare cases (such as prepation of new ECLChannelMap payloads)

Definition at line 29 of file ECLChannelMapper.h.

Constructor & Destructor Documentation

◆ ECLChannelMapper()

ECLChannelMapper ( )

Default constructor.

Definition at line 25 of file ECLChannelMapper.cc.

{
  int i;
  for (i = 0; i < ECL_BARREL_CRATES * ECL_BARREL_SHAPERS_IN_CRATE * ECL_CHANNELS_IN_SHAPER; i++)
    convertArrayBarrel[i] = 0;
  for (i = 0; i < ECL_FWD_CRATES * ECL_FWD_SHAPERS_IN_CRATE * ECL_CHANNELS_IN_SHAPER; i++)
    convertArrayFWD[i] = 0;
  for (i = 0; i < ECL_BKW_CRATES * ECL_BKW_SHAPERS_IN_CRATE * ECL_CHANNELS_IN_SHAPER; i++)
    convertArrayBKW[i] = 0;
  for (i = 0; i < ECL_TOTAL_CHANNELS; i++)
    for (int j = 0; j < 3; j++)
      convertArrayInv[i][j] = 0;
 
  isInitialized = false;
 
}

◆ ~ECLChannelMapper()

~ECLChannelMapper ( )

inline

Default destructor.

Definition at line 49 of file ECLChannelMapper.h.

49{}

Member Function Documentation

◆ getCellId()

int getCellId	(	int	iCrate,
		int	iShaper,
		int	iChannel
	)

Get CellId by given crate number, shaper position in the crate and DSP channel number in the shaper.

Definition at line 290 of file ECLChannelMapper.cc.

{
  // iCrate = 1  - 36  -- Barrel
  //          37 - 44  -- Forward
  //          45 - 52  -- Backward
  int cellID = 0;
  int arrayIndex;
 
  if (iCrate   < 1 || iCrate   > 52) return -1;
  if (iShaper  < 1 || iShaper  > 12) return -1;
  if (iChannel < 1 || iChannel > 16) return -1;
 
  if (iCrate >= 1 && iCrate <= 36) {
    //int thetaID = 1 + (iShaper - 1) * 4 + (iChannel - 1) % 4;
    //int phiID   = 1 + (iCrate  - 1) * 4 + (iChannel - 1) / 4;
    //cellID  = 1 + ECL_FWD_CHANNELS + (phiID - 1) + (thetaID - 1) * 144;
 
    arrayIndex = (iCrate - 1) * ECL_BARREL_SHAPERS_IN_CRATE * ECL_CHANNELS_IN_SHAPER
                 + (iShaper - 1) * ECL_CHANNELS_IN_SHAPER + (iChannel - 1);
    cellID = convertArrayBarrel[arrayIndex];
 
  }
 
  if (iCrate > 36 && iCrate < 45) {
    arrayIndex = (iCrate - 37) * ECL_FWD_SHAPERS_IN_CRATE * ECL_CHANNELS_IN_SHAPER
                 + (iShaper - 1) * ECL_CHANNELS_IN_SHAPER + (iChannel - 1);
    cellID = convertArrayFWD[arrayIndex];
  }
 
  if (iCrate > 44) {
    arrayIndex = (iCrate - 45) * ECL_BKW_SHAPERS_IN_CRATE * ECL_CHANNELS_IN_SHAPER
                 + (iShaper - 1) * ECL_CHANNELS_IN_SHAPER + (iChannel - 1);
    cellID = convertArrayBKW[arrayIndex];
  }
 
 
  return cellID;
}

◆ getCOPPERNode()

int getCOPPERNode ( int iCrate )

Get number of COPPER node by given crate number.

Definition at line 379 of file ECLChannelMapper.cc.

{
  int systemID, iNode, iCOPPERNode;
 
  if (iCrate < 1 || iCrate > ECL_CRATES) return -1;
  systemID = (iCrate <= ECL_BARREL_CRATES) * BECL_ID + (iCrate > ECL_BARREL_CRATES) * EECL_ID;
  iNode = (iCrate <= ECL_BARREL_CRATES) ? (iCrate - 1) / 2 : (iCrate - ECL_BARREL_CRATES - 1) % 8;
  iCOPPERNode = systemID + iNode + 1;
 
  return iCOPPERNode;
}

◆ getCrateID() [1/2]

int getCrateID ( int cellID )

Get crate number by given CellId.

Definition at line 328 of file ECLChannelMapper.cc.

{
  if (cellID > 0 && cellID <= ECL_TOTAL_CHANNELS) {
    return convertArrayInv[cellID - 1 ][0];
  } else  return -1;
}

◆ getCrateID() [2/2]

int getCrateID	(	int	iCOPPERNode,
		int	iFINESSE,
		bool	pcie40 = `false`
	)

Get crate number by given COPPER node number and FINESSE number.

Parameters

iCOPPERNode	Node ID (26 nodes in COPPER case, 3 nodes in PCIe40 case)
iFINESSE	Channel number (0 or 1 in COPPER case, 0-17 in PCIe40 case)
pcie40	Set to true if unpacking PCIe40 data

Definition at line 233 of file ECLChannelMapper.cc.

{
  int iCrate;
 
  if (!pcie40) {
    // Converting from COPPER nodes
    if (iFINESSE > ECL_FINESSES_IN_COPPER - 1) {
      B2ERROR("ECLChannelMapper::ERROR:: wrong FINESSE " << iFINESSE);
      return -1;
    }
 
    if ((iCOPPERNode & BECL_ID) == BECL_ID) {
      iCrate = (iCOPPERNode - BECL_ID - 1) * ECL_FINESSES_IN_COPPER + iFINESSE + 1;
    } else if ((iCOPPERNode & EECL_ID) == EECL_ID) {
      iCrate = ECL_BARREL_CRATES + iFINESSE * ECL_FWD_CRATES + (iCOPPERNode - EECL_ID - 1) + 1;
    } else {
      B2ERROR("ECLChannelMapper::ERROR:: wrong COPPER NodeID 0x" << std::hex << iCOPPERNode << " BECL_ID 0x" << BECL_ID << " EECL_ID 0x"
              << EECL_ID);
      return -1;
    }
  } else {
    // Converting from PCIe40 nodes
    const int ECL_BARREL_FEE_IN_PCIE40 = 18;
    const int ECL_ENDCAP_FEE_IN_PCIE40 = 16;
 
    // crates  1..18 -> PCIe40, #1
    // crates 19..36 -> PCIe40, #2
    // crates 37,45,38,46,..,44,52 -> PCIe40, #3
 
    if (iCOPPERNode == BECL_ID + 1 || iCOPPERNode == BECL_ID + 2) {
      // Barrel crates
      iCrate = (iCOPPERNode - BECL_ID - 1) * ECL_BARREL_FEE_IN_PCIE40 + iFINESSE + 1;
      if (iFINESSE >= ECL_BARREL_FEE_IN_PCIE40) {
        B2ERROR("ECLChannelMapper:: slot id must be less than 18, got slot id " << iFINESSE);
        return -1;
      }
    } else if (iCOPPERNode == BECL_ID + 3) {
      // Endcap crates
      iCrate = 2 * ECL_BARREL_FEE_IN_PCIE40 + (iFINESSE % 2) * 8 + iFINESSE / 2 + 1;
      if (iFINESSE >= ECL_ENDCAP_FEE_IN_PCIE40) {
        B2ERROR("ECLChannelMapper:: slot id must be less than 16, got slot id " << iFINESSE);
        return -1;
      }
    } else {
      B2ERROR("ECLChannelMapper:: wrong COPPER NodeID 0x" << std::hex << iCOPPERNode << " expected BECL_ID 0x" << BECL_ID);
      return -1;
    }
  }
 
  if (iCrate > ECL_CRATES || iCrate < 1) {
    B2ERROR("ECLChannelMapper::getCrateID::ERROR:: wrong crate number " << iCrate << " return -1");
    return -1;
  }
 
  return iCrate;
}

◆ getDBObject()

ECLChannelMap getDBObject ( )

Convert internal data to ECLChannelMap database object.

Definition at line 205 of file ECLChannelMapper.cc.

{
  ECLChannelMap map;
 
  if (!isInitialized) {
    B2FATAL("ECLChannelMapper:: Tried to generate dbobject before initialization");
  }
 
  int mappingBAR_size = ECL_BARREL_CRATES * ECL_BARREL_SHAPERS_IN_CRATE * ECL_CHANNELS_IN_SHAPER;
  int mappingFWD_size = ECL_FWD_CRATES    * ECL_FWD_SHAPERS_IN_CRATE    * ECL_CHANNELS_IN_SHAPER;
  int mappingBWD_size = ECL_BKW_CRATES    * ECL_BKW_SHAPERS_IN_CRATE    * ECL_CHANNELS_IN_SHAPER;
 
  std::vector<int> mappingBAR(mappingBAR_size);
  std::vector<int> mappingFWD(mappingFWD_size);
  std::vector<int> mappingBWD(mappingBWD_size);
 
  for (int i = 0; i < mappingBAR_size; i++)
    mappingBAR[i] = convertArrayBarrel[i];
  for (int i = 0; i < mappingFWD_size; i++)
    mappingFWD[i] = convertArrayFWD[i];
  for (int i = 0; i < mappingBWD_size; i++)
    mappingBWD[i] = convertArrayBKW[i];
 
  map.setMappingVectors(mappingBAR, mappingFWD, mappingBWD);
 
  return map;
}

◆ getElectronicsID()

int getElectronicsID ( int cellID )

Return channel index in ECLChannelMap.

Definition at line 349 of file ECLChannelMapper.cc.

{
  if (cellID < 1 || cellID > ECL_TOTAL_CHANNELS) return -1;
 
  int crate   = getCrateID(cellID);
  int shaper  = getShaperPosition(cellID);
  int channel = getShaperChannel(cellID);
 
  int arrayIndex = 0;
  // Total number of electronic IDs in barrel
  const int bar_eid_count = ECL_BARREL_CRATES * ECL_BARREL_SHAPERS_IN_CRATE * ECL_CHANNELS_IN_SHAPER;
  // Total number of electronic IDs in forward endcap
  const int fwd_eid_count = ECL_FWD_CRATES    * ECL_FWD_SHAPERS_IN_CRATE    * ECL_CHANNELS_IN_SHAPER;
 
  if (crate <= 36) {
    arrayIndex += (crate - 1) * ECL_BARREL_SHAPERS_IN_CRATE * ECL_CHANNELS_IN_SHAPER
                  + (shaper - 1) * ECL_CHANNELS_IN_SHAPER + (channel - 1);
  } else if (crate <= 44) {
    arrayIndex += bar_eid_count;
    arrayIndex += (crate - 37) * ECL_FWD_SHAPERS_IN_CRATE * ECL_CHANNELS_IN_SHAPER
                  + (shaper - 1) * ECL_CHANNELS_IN_SHAPER + (channel - 1);
  } else {
    arrayIndex += bar_eid_count + fwd_eid_count;
    arrayIndex += (crate - 45) * ECL_BKW_SHAPERS_IN_CRATE * ECL_CHANNELS_IN_SHAPER
                  + (shaper - 1) * ECL_CHANNELS_IN_SHAPER + (channel - 1);
  }
 
  return arrayIndex;
}

◆ getFINESSE()

int getFINESSE ( int iCrate )

Get number of FINESSE (0/1) in COPPER by given crate number.

Definition at line 391 of file ECLChannelMapper.cc.

{
  if (iCrate < 1 || iCrate > ECL_CRATES) return -1;
 
  return (iCrate <= ECL_BARREL_CRATES) ? (iCrate - 1) % 2 : (iCrate - ECL_BARREL_CRATES - 1) / 8;
}

◆ getInstance()

ECLChannelMapper * getInstance ( bool use_db = true )

static

Return main instance of ECLChannelMapper.

Parameters

use_db If true, run initFromDB() at the creation of main instance

Definition at line 49 of file ECLChannelMapper.cc.

{
  if (!instance) {
    instance = new ECLChannelMapper();
    if (use_db) instance->initFromDB();
    else instance->initFromFile();
  }
  return instance;
}

◆ getNShapersInCrate()

int getNShapersInCrate ( int iCrate )

inline

Get number of ShaperDSP modules in the given VME crate number.

Definition at line 90 of file ECLChannelMapper.h.

      {
        if (iCrate <= ECL_BARREL_CRATES) return ECL_BARREL_SHAPERS_IN_CRATE;
        if (ECL_BARREL_CRATES < iCrate && iCrate <= ECL_BARREL_CRATES + ECL_FWD_CRATES) return ECL_FWD_SHAPERS_IN_CRATE;
        if (ECL_BARREL_CRATES + ECL_FWD_CRATES < iCrate && iCrate <= ECL_CRATES) return ECL_BKW_SHAPERS_IN_CRATE;
        return 0;
      }

◆ getShaperChannel()

int getShaperChannel ( int cellID )

Get number of DSP channel in the shaper by given number of CellId.

Definition at line 342 of file ECLChannelMapper.cc.

{
  if (cellID > 0 && cellID <= ECL_TOTAL_CHANNELS) {
    return convertArrayInv[cellID - 1][2];
  } else  return -1;
}

◆ getShaperPosition()

int getShaperPosition ( int cellID )

Get position of the shaper in the crate by given CellId.

Definition at line 335 of file ECLChannelMapper.cc.

{
  if (cellID > 0 && cellID <= ECL_TOTAL_CHANNELS) {
    return convertArrayInv[cellID - 1][1];
  } else  return -1;
}

◆ getSubSystem()

int getSubSystem ( int iCrate )

Get ECL subsystem ID by given crate number: 0 – barrel, 1 – forward. 2 – backward endcap.

Definition at line 398 of file ECLChannelMapper.cc.

{
  if (iCrate <= ECL_BARREL_CRATES) return 0;
  if (ECL_BARREL_CRATES < iCrate && iCrate <= ECL_BARREL_CRATES + ECL_FWD_CRATES)
    return 1;
  if (ECL_BARREL_CRATES + ECL_FWD_CRATES < iCrate && iCrate <= ECL_CRATES) return 2;
  return -1;
}

◆ initFromDB()

bool initFromDB ( )

Initialize channel mapper from the conditions database.

Definition at line 127 of file ECLChannelMapper.cc.

{
  DBObjPtr<Belle2::ECLChannelMap> channelMap("ECLChannelMap");
  // Re-initialize only if interval of validity was changed
  if (isInitialized && !channelMap.hasChanged()) {
    return true;
  }
 
  if (!channelMap.isValid()) {
    B2FATAL("ECLChannelMapper:: Could not get ECLChannelMap from the database.");
  }
 
  B2INFO("ECLChannelMapper:: loaded ECLChannelMap from the database"
         << LogVar("IoV", channelMap.getIoV()));
 
  const auto& mappingBAR = channelMap->getMappingBAR();
  const auto& mappingFWD = channelMap->getMappingFWD();
  const auto& mappingBWD = channelMap->getMappingBWD();
 
  int cellID;
  // Loop variables
  int iCrate = 1, iShaper = 1, iChannel = 1;
  // Index in currently used array (converArrayBarrel,*FWD,*BKW)
  int arrayIndex = 0;
  int iMaxShapers = ECL_BARREL_SHAPERS_IN_CRATE;
 
  while (iCrate <= ECL_CRATES) {
    if (iCrate <= ECL_BARREL_CRATES) {
      // Barrel
      cellID = mappingBAR[arrayIndex];
      convertArrayBarrel[arrayIndex] = cellID;
    } else if (iCrate <= ECL_BARREL_CRATES + ECL_FWD_CRATES) {
      // Forward endcap
      cellID = mappingFWD[arrayIndex];
      convertArrayFWD[arrayIndex] = cellID;
    } else {
      // Backward endcap
      cellID = mappingBWD[arrayIndex];
      convertArrayBKW[arrayIndex] = cellID;
    }
 
    if (cellID > ECL_TOTAL_CHANNELS) {
      B2FATAL("ECLChannelMapper:: wrong cellID (" << cellID << ") in the database payload");
      return false;
    }
 
    if (cellID > 0) {
      convertArrayInv[cellID - 1][0] = iCrate;
      convertArrayInv[cellID - 1][1] = iShaper;
      convertArrayInv[cellID - 1][2] = iChannel;
    }
 
    arrayIndex++;
    // Increment all indices, accounting for hierarchical
    // structure of channels <- shapers <- crates
    iChannel++;
    if (iChannel > ECL_CHANNELS_IN_SHAPER) {
      iChannel = 1;
      iShaper++;
      if (iShaper > iMaxShapers) {
        iShaper = 1;
        if (iCrate == ECL_BARREL_CRATES) {
          arrayIndex = 0;
          iMaxShapers = getNShapersInCrate(iCrate + 1);
        } else  if (iCrate == ECL_BARREL_CRATES + ECL_FWD_CRATES) {
          arrayIndex = 0;
          iMaxShapers = getNShapersInCrate(iCrate + 1);
        }
        iCrate++;
      }
    }
  }
 
  isInitialized = true;
 
  return true;
}

◆ initFromFile() [1/2]

bool initFromFile ( )

Initialize channel mapper using data stored in default location.

Definition at line 42 of file ECLChannelMapper.cc.

{
  std::string filePath = FileSystem::findFile("ecl/data/ecl_channels_map.txt");
  return initFromFile(filePath.c_str());
}

◆ initFromFile() [2/2]

bool initFromFile ( const char * eclMapFile )

Initialize channel mapper using data stored in the ASCII file.

Definition at line 59 of file ECLChannelMapper.cc.

{
  B2WARNING("Reading possibly outdated ECLChannelMap from " << eclMapFileName);
 
  ifstream mapFile(eclMapFileName);
  if (mapFile.is_open()) {
 
    float iCrate, iShaper, iChannel, thetaID, phiID, cellID;
    int arrayIndex = 0;
    int arrayCount = 0;
    while (mapFile.good()) {
 
      // Ignoring commented lines
      char ch = mapFile.get();
      if (ch == '#') {
        mapFile.ignore(256, '\n');
        continue;
      } else if (ch == '\n') {
        continue;
      } else {
        mapFile.unget();
      }
 
      mapFile >> iCrate >> iShaper >> iChannel >> thetaID >> phiID >> cellID;
 
      if (cellID > static_cast<float>(ECL_TOTAL_CHANNELS)) {
        B2ERROR("ECLChannelMapper:: wrong cellID in the init file " << eclMapFileName);
        return false;
      }
 
      if (cellID > 0) {
        convertArrayInv[(int)cellID - 1][0] = (int)iCrate;
        convertArrayInv[(int)cellID - 1][1] = (int)iShaper;
        convertArrayInv[(int)cellID - 1][2] = (int)iChannel;
      }
 
      // Barrel
      if (iCrate >= 1 && iCrate <= 36) {
        arrayIndex = arrayCount;
        convertArrayBarrel[arrayIndex] = (int)cellID;
      }
 
      // Forward endcap
      if (iCrate > 36 && iCrate < 45) {
        arrayIndex = arrayCount - 36 * 12 * 16;
 
        if (arrayIndex >= 0 && arrayIndex < ECL_FWD_CRATES * ECL_FWD_SHAPERS_IN_CRATE * ECL_CHANNELS_IN_SHAPER)
          convertArrayFWD[arrayIndex] = (int)cellID;
      }
 
      // Backward endcap
      if (iCrate > 44) {
        arrayIndex = arrayCount - 36 * 12 * 16 - 8 * 10 * 16;
        if (arrayIndex >= 0 && arrayIndex < ECL_BKW_CRATES * ECL_BKW_SHAPERS_IN_CRATE * ECL_CHANNELS_IN_SHAPER)
          convertArrayBKW[arrayIndex] = (int)cellID;
      }
      arrayCount++;
    }
  } else {
    B2ERROR("ERROR:: file " << eclMapFileName << " doesn't found");
    return false;
  }
 
  isInitialized = true;
 
  return true;
}

Member Data Documentation

◆ convertArrayBarrel

int convertArrayBarrel[ECL_BARREL_CRATES *ECL_BARREL_SHAPERS_IN_CRATE *ECL_CHANNELS_IN_SHAPER]

private

convert (iCrate, iShaper, iChannel) to CellId for Barrel ECL

Definition at line 35 of file ECLChannelMapper.h.

◆ convertArrayBKW

int convertArrayBKW[ECL_BKW_CRATES *ECL_BKW_SHAPERS_IN_CRATE *ECL_CHANNELS_IN_SHAPER]

private

convert (iCrate, iShaper, iChannel) to CellId Backward endcap

Definition at line 39 of file ECLChannelMapper.h.

◆ convertArrayFWD

int convertArrayFWD[ECL_FWD_CRATES *ECL_FWD_SHAPERS_IN_CRATE *ECL_CHANNELS_IN_SHAPER]

private

convert (iCrate, iShaper, iChannel) to CellId for Forward endcap

Definition at line 37 of file ECLChannelMapper.h.

◆ convertArrayInv

int convertArrayInv[ECL_TOTAL_CHANNELS][3]

private

convert CellId to (iCrate, iShaper, iChannel)

Definition at line 41 of file ECLChannelMapper.h.

◆ instance

ECLChannelMapper * instance = nullptr

staticprivate

Main instance of ECLChannelMapper.

Definition at line 43 of file ECLChannelMapper.h.

◆ isInitialized

bool isInitialized

private

initialization flag

Definition at line 32 of file ECLChannelMapper.h.

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

ecl/mapper/include/ECLChannelMapper.h
ecl/mapper/src/ECLChannelMapper.cc

Public Member Functions

Static Public Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ECLChannelMapper()

◆ ~ECLChannelMapper()

Member Function Documentation

◆ getCellId()

◆ getCOPPERNode()

◆ getCrateID() [1/2]

◆ getCrateID() [2/2]

◆ getDBObject()

◆ getElectronicsID()

◆ getFINESSE()

◆ getInstance()

◆ getNShapersInCrate()

◆ getShaperChannel()

◆ getShaperPosition()

◆ getSubSystem()

◆ initFromDB()

◆ initFromFile() [1/2]

◆ initFromFile() [2/2]

Member Data Documentation

◆ convertArrayBarrel

◆ convertArrayBKW

◆ convertArrayFWD

◆ convertArrayInv

◆ instance

◆ isInitialized