SctApiHisto.h

#ifndef SCTROD_SCTAPI_HISTO_H
#define SCTROD_SCTAPI_HISTO_H

// Make sure USE_IS etc. are defined 
#include "config.h"

#include <map.h>

#include <boost/date_time/posix_time/posix_time.hpp>

#include "ScanMonitor.h"

#include "utility.h"
#include "Sct/Addressing.h"

#include "SctApiFwd.h"

struct scan_result_ptrs;

namespace SctApi {

  void saveHistogramToFile(scan_result_ptrs histo, std::string filename);

  void readHistogramToFile(const Sct::UCID & ucid, const Scan &scan, const ScanEx &ex, UINT32 mid, std::string sn, 
                           scan_result_ptrs scanData, time_t saveTime, int frame = 0);

#ifdef USE_IS

  void readHistogramToIS(const Sct::UCID & ucid, const Scan &scan, const ScanEx &ex,
                         UINT32 mid, scan_result_ptrs scanData);
#endif

struct ModuleMask {
  UINT32 mask0;
  UINT32 mask1;
};

class RodScanEx {
 public:
  // Module slots in use
  ModuleMask channels;

  // Module slots per Group
  ModuleMask groupChannels[8];

  // Module slots for each slave
  ModuleMask slaveChannels[4];

  int slaves;

  char bitFieldDSP;

  int firstSlave;
};

class ScanEx {
 public:
  ScanEx() 
#if USE_CONST_SCAN
    : startTime(boost::posix_time::second_clock::universal_time()),
    endTime(boost::posix_time::second_clock::universal_time())
#endif
    {}

  std::map<RodLabel, RodScanEx> rodInfo;

  typedef std::map<RodLabel, RodScanEx> RodInfoMap;

  RodScanEx &getOrNewRod(const RodLabel &l, RodScanEx defaultEx);
  const RodScanEx &getRodScanInfo(const RodLabel &l) const;
  RodScanEx &getRodScanInfo(const RodLabel &l);

  std::vector<std::list<std::string> > groupLists;

#if USE_CONST_SCAN
  // These are moved from Scan...
  ModuleList getModuleList(unsigned int group) const;
  void setModuleList(unsigned int group, const ModuleList & newList);
  unsigned int getNGroups() const;
  void setNGroups(unsigned int val);
  
  boost::posix_time::ptime getStartTime() const;
  void setStartTime(boost::posix_time::ptime t);
  
  boost::posix_time::ptime getEndTime() const;
  void setEndTime(boost::posix_time::ptime t);

  // And need some place to store stuff
  unsigned int m_maxGroup;
  boost::posix_time::ptime startTime, endTime;
#endif

  unsigned int diagnosticReg;

  std::map<std::pair<RodLabel, int>, Utility::MemoryBlock> histoMap;

  std::map<std::pair<RodLabel, int>, Utility::MemoryBlock> evCountMap;

  int trimScan;

  // Maps

  UINT8 groupDspMap[4];
  UINT8 groupSpMap[2];
  UINT8 groupRangeMap[2];
};

class ScanControl {
 protected:
  SctApi &api;

  ScanControl(SctApi &api, int bin, int event);
  ScanControl(SctApi &api);

  virtual ~ScanControl() {}
 public:
  virtual void startHistogramming() = 0;

  virtual void initialisePolling() = 0;

  virtual void reportEventErrors() = 0;

  virtual void reportTimeout() = 0;

  virtual void nextBin() = 0;

  virtual bool checkScanComplete(bool &progressMade, bool &newBin) = 0;

  virtual void abort() = 0;

/*   /\** Poll *\/ */
/*   virtual void pollHistogramming(ScanEx &ex, int bins, int events, int timeout = 5) = 0; */

  virtual void finishHistogram(bool success) = 0;

#if USE_CONST_SCAN
  static void setModuleScanCacheToLastPointInScan(SctApi &api, boost::shared_ptr<const Scan> aScan, 
                          boost::shared_ptr<const ScanEx> scanEx);
#else
  static void setModuleScanCacheToLastPointInScan(SctApi &api, boost::shared_ptr<const Scan> aScan);
#endif

  void printVetoStatus();
};

class ScanControlRODHisto : public ScanControl {
 protected:
  std::map<RodLabel, int> lastBin;
  std::map<RodLabel, int> lastEvent;
  std::map<RodLabel, bool> reportedFinished;
  
#warning "This should be const"
  boost::shared_ptr<Scan> scan;
  boost::shared_ptr<ScanEx> scanEx;

  int finalBin;
  int finalTrigger;

  int sectionStartBin;
  int sectionEndBin;
  int sectionEndTrigger;

  // Store for internal timing
  time_t scanStart;

  bool aborting;

  unsigned int getEventCounter(const RodLabel &rodLabel, int slave, bool fromMaster);

  void readHistograms();

  scan_result_ptrs readHistogramData(UINT32 mid, int frame = 0);

  char* readHistogramRawData(UINT32 mid, int frame = 0);

  void postScanModuleSetup();


  unsigned long *getHistogramChunk(RodLabel label, int slave, unsigned long offset, unsigned long size);


  unsigned long *getEventCountChunk(RodLabel label, int slave);

  bool checkDebugOption(int opt);

  bool findNextSection();
 public:
  ScanControlRODHisto(SctApi &api, boost::shared_ptr<Scan> aScan, boost::shared_ptr<ScanEx> aScanEx);

  virtual ~ScanControlRODHisto() {};

  void startHistogramming();

  void initialisePolling();

  void reportEventErrors();

  typedef std::pair<std::pair<int, int>, std::pair<int, int> > TrapBuffers;

  TrapBuffers getTrapBuffers(const RodLabel rlabel, int dsp);

  unsigned int getProcTime(const RodLabel rlabel, int dsp);

  void dumpHistoStatus(const RodLabel label, int dsp);

  void reportTimeout();

  void nextBin();

  bool checkScanComplete(bool &progressMade, bool &newBin);

  void abort();

  virtual bool checkScanCompleteROD(const RodLabel &rodLabel, bool &progressMade, bool &newBin, int &totalBin);

  void finishHistogram(bool success);

  std::pair<RodLabel, unsigned int> findModuleSlave(unsigned int mid);
};

class ScanControlTIMHisto : public ScanControlRODHisto {
  int binCount;

 public:
#warning "Constify scan"
  ScanControlTIMHisto(SctApi &api, boost::shared_ptr<Scan> aScan, boost::shared_ptr<ScanEx> aScanEx);

  void startHistogramming();

  void nextBin();

  void finishHistogram(bool success);

  bool checkScanCompleteROD(const RodLabel &rodLabel, bool &progressMade, bool &newBin, int &totalBin);

  // Same as RODHisto
/*   /\** Tidy up, read out and save histogram *\/ */
/*   void finishHistogram(); */
};

class ScanControlAsyncHisto : public ScanControlRODHisto {
  int binCount;

 public:
#warning "Constify scan"
  ScanControlAsyncHisto(SctApi &api, boost::shared_ptr<Scan> aScan, boost::shared_ptr<ScanEx> aScanEx);

  void startHistogramming();

  void nextBin();

  void finishHistogram(bool success);

  // checkScanCompleteROD is not called as polling not done
};

} // Close SctApi namespace

#endif

---