4.3. Writing the adaptors.

4.3.1. Wrapping skeleton.cpp in a CEventSegment

The RingDaq readout framework builds up its response to an event trigger in terms of event segments. Event segments can be simple (CEventSegment derived objects), or they can be composed of other event segments (CCompoundEventSegment). Our job in this section is going to be to build a CEventSegment that will wrap the event related functions in skeleton.cpp.

Let's start by comparing the functions in skeleton.cpp and the related methods in CEventSegment.

Our modified skeleton.cpp provides three functions that are involved in physics event processing:

By contrast, the CEventSegment provides the following methods:

The preceeding list implies that we should write an event segment in which initialize calls initevt, clear calls clearevt, read does some adaptation and calls readevt and disable is not implemented.

The header for this sort of event segment looks like:

#include <config.h>
#include <CEventSegment.h>   

class CTraditionalEventSegment : public CEventSegment 
{
public:
  void initialize();
  void clear();
  size_t read(void* pBuffer, size_t maxwords);
};
                      
                    

Now let's look at the implementation and discuss how that adapts to the functions in skeleton.cpp For the most part this is pretty simple as well:

#include <config.h>
#include "CTraditionalEventSegment.h"
#include <stdint.h>              
#include <string>


typedef int16_t WORD;     

extern void initevt ();   
extern void clearevt ();
extern WORD readevt (WORD* bufpt);




void
CTraditionalEventSegment::initialize()
{
  ::initevt();
}
void
CTraditionalEventSegment::clear()
{
  ::clearevt();
}

size_t
CTraditionalEventSegment::read(void* pBuffer, size_t maxwords)
{
  WORD* p = reinterpret_cast<WORD*>(pBuffer);  

  size_t nWords = ::readevt(p);                      
  if (nWords > maxwords) {
    throw std::string("readevt read more than maxwords of data"); 
  }
  return nWords;                                    
}

                    

For the most part this is very straightforward, and similar to the SPDAQ production readout wrapper class for classic event segments.

4.3.2. Wrapping skeleton.cpp in a CScaler

We must also write an adaptor taht wraps the scaler parts of skeleton.cpp in a CScaler. This too is relatively straightforward. Let's once more start by comparing the two software interfaces:

The functions the skeleton.cpp uses to manage the scaler readout are:

From this comparison we can see it's pretty trivial to wrap iniscl and clrscl. Here is a header and the first part of the implementation of a wrapper that shows how these functions get trivially wrapped:

#include <CScaler.h>    

class CTraditionalScaler : public CScaler 
{
public:                      
  void initialize();            
  void clear();
  std::vector<uint32_t> read();
};

                    

The implementation of the trivial wrappers is shown below along with the front matter of the implementation file.

#include <config.h>
#include "CTraditionalScaler.h"


typedef uint16_t UINT16;   
typedef uint32_t UINT32;

extern void iniscl();      
extern void clrscl();
extern UINT16 readscl(UINT32* buffer, int numscalers);

void
CTraditionalScaler::initialize() 
{
  ::iniscl();
}

void
CTraditionalScaler::clear()     
{
  ::clrscl();
}

                    

Wrapping the readscl function is a bit trickier. Specifically we have to make some decisions about how to know the number of scalers that will be read by the readscl function. We need to do this not only to be able to provide the value back to the function (its second parameter), but also to be able to allocate storage for the buffer into which readscl will read its data.

There are several strategies that come to mind:

1. Hard code the number of scalers in CTraditionalScaler.

2. Add a function to the skeleton.cpp code allowing it to report the number of scalers it will read.

3. Make the scaler count a construtor parameter fo the CTraditionalScaler class.

4. Provide some mechanism that allows both the skeleton.cpp and the CTraditionalScaler code to obtain the number of scalers from some external information (e.g. data file, Tcl Script or environment variable.

In this example we will assume that a function named numScalers has been added to the skeleton.cpp file that reports the number of scaler channesl that will be read. We leave it to you to determine how that function knows this number.

...
extern size_t numScalers();    
...
std::vector<uint32_t>
CTraditionalScaler::read()
{
  size_t nChannels = ::numScalers();  
  uint32_t scalerBuffer[nChannels];  
  std::vector<uint32_t> result;

  readscl(scalerBuffer, nChannels);    
  for (int i =0; i < nChannels; i++) {
    result.push_back(scalerBuffer[i]);  
  }
  return result;                         
}