4.4. Modifications to Skeleton.cpp

Up until now we have built code to wrap the skeleton.cpp in classes that are compatibile with the RingDaq readout framework. The readout framework also requires that we:

1. Select (or write and register) an event trigger.

2. Register an instance of our CTraditionalEventSegment as an event segment so that it can respond to the event trigger.

3. Register an instacne of our CTraditionalScaler as a scaler so that it can respond to scaler triggers.

The actions above are all done by editing the Skeleton.cpp (note the capital S).

Lets first take up the event trigger. In the classical readout framework this is selected at compile time by defining a preprocessor symbol, or by creating and registering a replacement trigger. For the RingDaq readout framework, you must select a trigger in your software. While this is a bit more burdensome, it is more flexible.

Triggering in the RingDaq framework is divided into two parts, the trigger itself, and dead-time management. These are represented by a class descended from CTrigger and another class descended from CBusy. Objects of these classes can be mixed. It is anticpated that there may be cases where a specific bit of trigger hardware cannot also do deadtime management.

The readout framework supplies trigger/busy classes for the CAEN V262 I/O register and the CAEN V977 coincidence register/latch. In addition it is pretty easy to create new trigger classes and to use them to trigger your readout. The example below selects the CAEN V262 as the trigger and busy manager. The signals used are identical to those used by the SPDAQ frameworks.

#include <config.h>
#include "Skeleton.h"
#include <CExperiment.h>
#include <TCLInterpreter.h>
#include <CTimedTrigger.h>

#include "CCAENEventSegment.h"


#include "CSIS3820Scaler.h"

#include <CCAENV262Trigger.h>  
#include <CCAENV262Busy.h>

...
void
Skeleton::SetupReadout(CExperiment* pExperiment)
{
...
  pExperiment->EstablishTrigger(new CCAENV262Trigger(0x444400, 0) ); 
  pExperiment->EstablishBusy(new CCAENV262Busy(0x444400, 0));        
  
...
}


                

Now lets register the a CTraditionalEventSegment to respond to the trigger. The Readout framework allows you to register any number of event segments. The segments are processed in the order in which you register them, much the same way SpecTcl event processors work.

...
#include "CTraditionalEventSegment.h"  
...
void
Skeleton::SetupReadout(CExperiment* pExperiment)
{
  CReadoutMain::SetupReadout(pExperiment);

  // Establish your trigger here by creating a trigger object
  // and establishing it.

  pExperiment->EstablishTrigger(new CCAENV262Trigger(0x444400, 0));
  pExperiment->EstablishBusy(new CCAENV262Busy(0x444400, 0));

  // Create and add your event segments here, by creating them and invoking CExp
eriment's
  // AddEventSegment

  pExperiment->AddEventSegment(new CTraditionalEventSegment); 

}


                

The code to register the scaler wrapper is about the same, however it is added to Skeleton::SetupScalers.

...
#include "CTraditionalScaler.h"  
using namespace std;             
...
void
Skeleton::SetupScalers(CExperiment* pExperiment)
{
  CReadoutMain::SetupScalers(pExperiment);      // Establishes the default scale
r trigger.

  // Sample: Set up a timed trigger at 2 second intervals.

  timespec t;
  t.tv_sec  = 2;                                  
  t.tv_nsec = 0;
  CTimedTrigger* pTrigger = new CTimedTrigger(t);
  pExperiment->setScalerTrigger(pTrigger);

  // Create and add your scaler modules here.

  pExperiment->AddScalerModule(new CTraditionalScaler); 

}