/data3/calcul/jacquem/working_dir/Micromegas/micromegasFrameWork/include/parser/DiracReader.hh

Go to the documentation of this file.

/* @version $Revision: 1328 $ * @modifiedby $Author: jacquem $ * @lastmodified $Date: 2011-10-03 17:04:17 +0200 (Mon, 03 Oct 2011) $ */

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// Crossdaq  for MICROMEGAS READOUT                                     //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
// 20091109 -
// - The absolute bcId is always counted at 5MHz,
//   other bcId depend on the bunch crossing period
//////////////////////////////////////////////////////////////////////////

#ifndef DIRAC_READER_HH
#define DIRAC_READER_HH

#include <stdlib.h>
#include "mTypes.h"
#include "DifReader.hh"

#define LABVIEW_DIRAC_READER "labviewDirac"

class Run;
class Event;
class Detector;
class ChannelHit;

#include <vector>

//////////////////////////////////////////////////////////////////////////
  class DiracChannelConfig {
    public:
      // ------ data members -------//
      bool test;                                     // bit 1
      bool enable;                                   // bit 0
  }; // class DiracChannelConfig

//////////////////////////////////////////////////////////////////////////
// Configuration Chip
  class DiracChipConfig {
    public:
      bool read(unsigned char *buf);
    public:
      // ------ data members -------//
      ui16 gain;                                     // 3 bits (0-2)
      bool analogData;                               // bit 3
      // all data are shifted by 4 bits...
      ui16 bHiThreshold;                             // 8 bits for channels 32-63
      ui16 bMidThreshold;                            // 8 bits
      ui16 bLoThreshold;                             // 8 bits
      ui16 aHiThreshold;                             // 8 bits for channels 0-31
      ui16 aMidThreshold;                            // 8 bits
      ui16 aLoThreshold;                             // 8 bits
      DiracChannelConfig chConfig[64];               // 64 * 2 bits
  }; // class DiracChipConfig

//////////////////////////////////////////////////////////////////////////
// Configuration DIF
  class DiracDifConfig {
    public:
      bool read(unsigned char *buf);
    public:
      // ------ data members -------//
      i32 id;                                        // difId
      ui32 bcPeriod;                                 // the BC period in nanoseconds
      // --- configuration data for the DIF
      bool powerPulsing;                             // bit 6
      bool analogReading;                            // bit 5
      bool digitalReading;                           // bit 4
      ui16 acqMode;                                  // 4 bits (0-3) / 8
      ui16 lowState;                                 // 12 bits (0-11 / 16)
      ui16 highState;                                // 12 bits (0-11 / 16)
      ui16 afterState;                               // 6 bits (0-5) / 8
      ui16 beforeState;                              // 6 bits (0-5) / 8
      bool inverted;                                 // bit 11
      bool ctestEnable;                              // bit 10
      ui16 ctestPeriod;                              // 10 bits (0-9 / 16)
      ui16 ctestDelay;                               // 10 bits (0-9 / 16)
      ui16 ctestWidth;                               // 10 bits (0-9 / 16)
      ui16 triggerDelay;                             // 10 bits (0-9 / 16)
      ui32 charge;                                   // 32 bits
      // --- configuration data for each chip
      i32 nbChips;                                   // number of Dirac chips
      std::vector<DiracChipConfig> chipConfigs;      // config for each chip
  }; // class DiracDifConfig

//////////////////////////////////////////////////////////////////////////
// 8 trigger infos for each DIF which sends data
  class DiracTriggerInfo {
    public:
      DiracTriggerInfo();
      bool read(unsigned char *buf);
    public:
      // ------ data members -------//
      // --- data acquisition
      ui16 bcId;      // 12-bit bcId from dirac chip
      ui16 data[64];  // the data
      // --- configuration
      bool reject;    // bit 0
      ui16 pileUp;    // 5 bits (1-5)
      ui16 trigger;   // 10 bits (6-15)
      i64 bcIdAbs;    // 48 bits (16-63)
      ui32 bcIdFpga;  // 16 bits (64-79)
  }; // class DiracTriggerInfo

//////////////////////////////////////////////////////////////////////////
///     CLASS DATAREADER                                                //
//////////////////////////////////////////////////////////////////////////
class DiracReader : public DifReader {

  // public methods
  public:
    DiracReader(Run& aRun, FILE *aFile, ui32 firstEventId);
    ~DiracReader();
    int getNextEvent(Event& eventToFill);
    static const char *type(const int subtype = 0) { return LABVIEW_DIRAC_READER; };

  //------ methods --------//
  private:
    void reset();
    int getConfigData();
    int getAcqData();
    int storeHits(Event& event);
    ChannelHit *newHit(Event& event, const DiracDifConfig& difConfig, const DiracTriggerInfo& trigInfo, const int chipNum, const int chNum);
    void storeDifInfo(const int difId);

  // ------ data members -------//
  protected:
    unsigned short CRC;            // current CRC for the whole file

    // DIFs and chips
    int nbDifs;                    // number of Difs which sent data
    std::vector<DiracDifConfig> difConfigs; //

    // data reconstruction
    i64 bcId_AbsOrg;               // the bcId origin, at 5MHz, for the whole file
    int acqDifId;                  // Id of the current DIF board
    DiracTriggerInfo trigInfos[8];
}; // class DiracReader

#endif // DIRAC_READER_HH

---