---

MyExperiment.cpp

Go to the documentation of this file.

//  This file contains a test readout system.
//   It derives from the CReadoutMain class
//   to setup our experiment specific requirements
//   creates an instance of it and lets the base classes
//  do most of the work:
#include <CReadoutMain.h>
#include <CExperiment.h>
#include <CInterpreterStartup.h>
#include <CInterpreterCore.h>
#include <CRunVariableCommand.h>
#include <CRunVariable.h>
#include <CStateVariableCommand.h>
#include <CStateVariable.h>
#include <TCLInterpreter.h>
#include <CDAQTCLProcessor.h>
#include <CVMEScalerLRS1151.h>
#include <CTraditionalEventSegment.h>
#include <CEventSegment.h>
#include <CDocumentedPacket.h>
#include "Hierarchy.h"
//
//   This declaration makes possible the use of the 'old style skelton'.
//
CTraditionalEventSegment oldstyle;

//  The class below implements a counting pattern event segment.
//  The number of items in the pattern is a constructor parameter.
//  The class also constructs a Documented packet as described in the
//  constructor so that the event segment is tagged appropriately.
//
class CCountingEventSegment : public CEventSegment {
private:
  unsigned int      m_nPatternLength;
  CDocumentedPacket m_PacketId;

  // Constructors and canonical operations.

public:
  CCountingEventSegment(unsigned int nLength,
                        unsigned short nTag,
                const string& rName, const string& rDescription,
                        const string& rVersion);
  virtual ~CCountingEventSegment() {}
private:
  CCountingEventSegment(const CCountingEventSegment& rhs);
  CCountingEventSegment& operator= (const CEventSegment& rhs);
  int                    operator==(const CEventSegment& rhs) const;
  int                    operator!=(const CEventSegment& rhs) const;
public:

  // Class attribute selectors:
public:
  int                getPatternLenth() const { return m_nPatternLength; }
  const CDocumentedPacket& getPacket() const { return m_PacketId; }
  
  // Class has no mutators.
protected:

  // Overrides of the interface pure virtual methods:

public:
  virtual   void Initialize () {}
  virtual   DAQWordBufferPtr& Read (DAQWordBufferPtr& rBuffer);
  virtual   void Clear () {}
  virtual   unsigned int MaxSize () { return m_nPatternLength + 2;} // not needed.
  

protected:

  
};


/* Implementation of the CCountingEventSegment. */

CCountingEventSegment::CCountingEventSegment(unsigned int nLength,
                                             unsigned short nTag,
                                             const string& rName,
                                             const string& rDescription,
                                             const string& rVersion) :
  CEventSegment(),
  m_nPatternLength(nLength),
  m_PacketId(nTag, rName, rDescription, rVersion)
{}


DAQWordBufferPtr&
CCountingEventSegment::Read(DAQWordBufferPtr& rBuffer)
{
  rBuffer = m_PacketId.Begin(rBuffer);  //  Open the packet.

  for(int i =0; i < m_nPatternLength; i++) {
    *rBuffer = i;
    ++rBuffer;                  // Preincrement is faster than post.
  }
  rBuffer =  m_PacketId.End(rBuffer);   // close the packet.
  return rBuffer;
}

// The variables below create event segments that can will be registered
// for readout.  Note that if they don't get registered, because of the way
// CDocumentedPackets work their packets will still appear in the documentation
// buffer.

CCountingEventSegment seg1(10, 
                           0x1, 
                           string("Ten"), 
                           string("Segment with 10 size counting pattern"),
                           string("1.1"));
CCountingEventSegment seg2(20,
                           0x2, 
                           string("Twenty"), 
                           string("Segment with 20 consecutive shorts"),
                           string("0.1"));

// Build the objects needed for a two level hierarchy:

CCountingEventSegment seg3(10, 0x3, string("Hierarchy.Ten"),
                           string("Nested segment with 10 consec. shorts"),
                           string("1.1"));

CCountingEventSegment seg4(20, 0x4, string("Hierarchy.Twenty"),
                           string("Nested segment with 20 consec shorts"),
                           string("0.1"));

Hierarchy hier(0xaaaa, string("Hierarchy"),
               string("Top level of the hierarchy"),
               string("2.5"));
class CMyExperiment : public CReadoutMain
{
public:
   // Constructors and other canonical operations:

   CMyExperiment() {
   }
   virtual ~CMyExperiment() {
   }
   // Copy construction, assignment and comparison 
   // make no sense and are therefore disallowed:
private:
   CMyExperiment(const CMyExperiment& rhs);
   CMyExperiment& operator=(const CMyExperiment& rhs);
   int            operator==(const CMyExperiment& rhs);
   int            operator!=(const CMyExperiment& rhs);
public:
   // The member functions below allow us to override/extend base
   // class behavior for experiment specific stuff.
   
protected:
   virtual void SetupReadout(CExperiment& rExperiment);
   virtual void SetupScalers(CExperiment& rExperiment);

public:
   virtual void SetupRunVariables(CExperiment& rExperiment,
                                  CInterpreterStartup& rStartup,
                                  CInterpreterCore&    rCore);
   virtual void SetupStateVariables(CExperiment& rExperiment,
                                  CInterpreterStartup& rStartup,
                                  CInterpreterCore&    rCore);
   virtual void AddUserCommands(CExperiment& rExperiment,
                                  CInterpreterStartup& rStartup,
                                  CInterpreterCore&    rCore);
   
};

// The system relies on a globally accessible instsance of a CReadoutMain 
// derived object called MyApp so here it is:

CMyExperiment MyApp;

void
CMyExperiment::SetupReadout(CExperiment& rExperiment)
{
   CReadoutMain::SetupReadout(rExperiment);
   
   // Insert your code below this comment.

   rExperiment.AddEventSegment(&oldstyle);
   rExperiment.AddEventSegment(&seg1);
   rExperiment.AddEventSegment(&seg2);
   hier.AddSegment(&seg3);
   hier.AddSegment(&seg4);
   rExperiment.AddEventSegment(&hier);

}
void
CMyExperiment::SetupScalers(CExperiment& rExperiment)
{
   CReadoutMain::SetupScalers(rExperiment);

   // Insert your code below this comment.

   // For test,setup an LRS 1151 at 0x200c00

   //   CScaler* pScaler = new CVMEScalerLRS1151(0xc00200);
   //   rExperiment.AddScalerModule(pScaler);

}
void
CMyExperiment::SetupRunVariables(CExperiment& rExperiment,
                                  CInterpreterStartup& rStartup,
                                 CInterpreterCore&   rCore)
{
   CReadoutMain::SetupRunVariables(rExperiment, rStartup, rCore);
   
   CRunVariableCommand& rCommand(*(rCore.getRunVariables()));
   
   // Add your code below this commet. rCommand is a reference to the run variable
   // commands object.
}
/*
    This function allows you to create run state variables.  Run state
   variables are TCL variables that are write locked during a run.  Their
   values are logged to run state variable buffers at run state transitions.

   An example of a run state variable is the run number; created by the
   base class.  An example of run variables you might like to create are
   fixed run conditions, such as beam species, energy, target species,
   trigger conditions etc.

   The Tcl command statevar can also be used to create list and delete
   state variables.

   \param rExperiment - CExperiment& the experiment object.
   \param rStartup   - CInterpreterStartup& the interpreter startup
                                            object.
    \param rCore  - CInterpreterCore& the core TCL interpreter
         add on functionality.  Normally you will obtain the 
         state variable command object and do CStateVariableCommand::Create
         calls to add your run variables.

   \note The base class creates key run variables.  It is therefore 
   very important to be sure the base class version of this function is
   called.
*/
void
CMyExperiment::SetupStateVariables(CExperiment& rExperiment,
                                   CInterpreterStartup& rStartup,
                                   CInterpreterCore&    rCore)
{
   CReadoutMain::SetupStateVariables(rExperiment, rStartup, rCore);
   
   CStateVariableCommand& rCommand(*(rCore.getStateVariables()));
   
   // Insert your code below this comment.  Note that rCommand is the 
   // state variable command object.

}
void
CMyExperiment::AddUserCommands(CExperiment& rExperiment, 
                                   CInterpreterStartup& rStartup,
                                   CInterpreterCore&    rCore)
{
   CReadoutMain::AddUserCommands(rExperiment, rStartup, rCore);
   
   CTCLInterpreter& rInterp(rStartup.Interp());
   
   // Add your command definitions after this comment.  rInterp
   // is a reference to the interpreter.
}

---