2.3. Creating scaler banks and scaler modules

The readout framework supports a hierachical organization of scalers using two classes CScaler which is intended to represent a single scaler module (but need not), and CScalerBank a CScaler into which CScaler objects including CScalerBank objects can be put.

Thus a CScalerBank is to CScaler as a CCompoundEventSegment is to CEventSegment objects.

The interface of a CScaler is similar to that of a CScaler:

So lets look at a simple CScaler. In this case we will be building a CScaler class that manages a single SIS 3820 scaler module.

First the header for the class:

#include <CScaler.h>


class CSIS3820;

class CSIS3820Scaler : public CScaler   
private:
  CSIS3820*   m_pScaler;                

public:
  CSIS3820Scaler(unsigned long base, int crate = 0); 
  ~CSIS3820Scaler();


  // The interface required by the CScaler class:

public:                          
  virtual void initialize();
  virtual void clear();
  virtual std::vector<uint32_t> read();


};

                

As before, let's look at the implementation in logical pieces. The front matterr is a few #include directives to pull in the headers we need:

#include <config.h>
#include "CSIS3820Scaler.h"
#include <CSIS3820.h>
#include <iostream>
#include <vector>
                

The constructor and destructor are pretty simple as well:

CSIS3820Scaler::CSIS3820Scaler(unsigned long base, int crate) :
     m_pScaler(new CSIS3820(base, crate))   
{


}


CSIS3820Scaler::~CSIS3820Scaler()
{
  delete m_pScaler;     

}
                    
                

Next lets look at the initialize and clear methods as they are relatively short.

void CSIS3820Scaler::initialize()
{
  m_pScaler->setOperatingMode(CSIS3820::LatchingScaler);  
  m_pScaler->setLatchSource(CSIS3820::LatchVMEOnly);
  m_pScaler->EnableClearOnLatch();                        
  m_pScaler->Enable();                                    
  m_pScaler->Arm();

}

void CSIS3820Scaler::clear()
{
  m_pScaler->ClearChannels();                           
}

                

Clears

The way in which this module is being cleared is not techincally correct. The module supports a clear on latch. As coded, the scalers will be cleared a read time and then a bit later when clear is called. This can cause a few counts to be lost over the duration of the run. The correct way to handl this module is to clear it at initialization time and then not to provide a clear function. The code was written this way in order to illustrate the use of a clear method rather than to be strictly speaking correct.

The std::vector class makes it pretty easy to write the read method as well.

std::vector<uint32_t>
CSIS3820Scaler::read()
{
  std::vector<uint32_t> result;   
  uint32_t              channels[32];   

  m_pScaler->LatchAndRead(reinterpret_cast<unsigned long*>(channels)); 

  result.insert(result.begin(), channels, channels + 32); 

  return result;

  
}
                    
                

Before leaving this discussion of scalers lets take a short tour of the CScalerBank class. This class allows us to group several CScaler objects into a single scaler-like object.

Suppose we have several SIS 3820 scaler modules. In a detector system. The example below organizes them into a single scaler bank which we can hand out as our detector system's scaler.

...
    CSIS3820Scaler sc1(0x80000000);
    CSIS3820Scaler sc2(0x80010000);
    CSIS3820Scaler sc3(0x80020000);
    
    CScalerBank myDetectorScalers;
    myDetectorScalers.AddScalerModule(&sc1);
    myDetectorScalers.AddScalerModule(&sc2);
    myDetectorScalers.AddScalerModule(&sc3);
...
                

Naturally since, CScalerBank objects are themselves derived from CScaler they can be added, in turn, to other scaler banks.