THaCrateMap.h

Go to the documentation of this file.

#ifndef Podd_THaCrateMap_h_
#define Podd_THaCrateMap_h_

//
//  THaCrateMap
//  Layout, or "map", of DAQ Crates.
//
//  THaCrateMap contains info on how the DAQ crates
//  are arranged in Hall A, i.e whether slots are
//  fastbus or vme, what the module types are, and
//  what header info to expect.  Probably nobody needs
//  to know about this except the author, and at present
//  an object of this class is a private member of the decoder.
//
//  author  Robert Michaels (rom@jlab.org)
//


#include "Decoder.h"
#include "TDatime.h"
#include <fstream>
#include <cstdio>  // for FILE
#include <cassert>
#include <iostream>
#include <string>
#include <vector>
#include <array>

namespace Decoder {

class THaCrateMap {
 public:
     static const UInt_t MAXCHAN;
     static const UInt_t MAXDATA;

     explicit THaCrateMap( const char* db = "cratemap" ); // Construct uninitialized
     virtual ~THaCrateMap() = default;
     bool isFastBus( UInt_t crate ) const;          // True if fastbus crate;
     bool isVme( UInt_t crate ) const;              // True if VME crate;
     bool isCamac( UInt_t crate ) const;            // True if CAMAC crate;
     bool isScalerCrate( UInt_t crate ) const;      // True if a Scaler crate
     bool isBankStructure( UInt_t crate ) const;    // True if modules in banks
     UInt_t getNslot( UInt_t crate ) const;         // Returns num occupied slots
     UInt_t getMinSlot( UInt_t crate ) const;       // Returns min slot number
     UInt_t getMaxSlot( UInt_t crate ) const;       // Returns max slot number

 // This class must inform the crateslot where the modules are.

     Int_t  getModel( UInt_t crate, UInt_t slot ) const; // Return module type
     UInt_t getHeader( UInt_t crate, UInt_t slot ) const;// Return header
     UInt_t getMask( UInt_t crate, UInt_t slot ) const;  // Return header mask
     Int_t  getBank( UInt_t crate, UInt_t slot ) const;  // Return bank number
     UInt_t getScalerCrate( UInt_t word) const;          // Return scaler crate if word=header
     const char* getScalerLoc( UInt_t crate ) const;     // Return scaler crate location
     const char* getConfigStr( UInt_t crate, UInt_t slot ) const; // Configuration string
     UInt_t getNchan( UInt_t crate, UInt_t slot ) const; // Max number of channels
     UInt_t getNdata( UInt_t crate, UInt_t slot ) const; // Max number of data words
     bool crateUsed( UInt_t crate ) const;               // True if crate is used
     bool slotUsed( UInt_t crate, UInt_t slot ) const;   // True if slot in crate is used
     bool slotClear( UInt_t crate, UInt_t slot ) const;  // Decide if not clear ea event
     void setUnused( UInt_t crate, UInt_t slot );   // Disables this crate,slot
     int  init(const std::string& the_map);         // Initialize from text-block
     int  init(ULong64_t time = 0);                 // Initialize by Unix time.
     int  init( FILE* fi, const char* fname );      // Initialize from given file
     void print(std::ostream& os = std::cout) const;

     const std::vector<UInt_t>& GetUsedCrates() const;
     const std::vector<UInt_t>& GetUsedSlots( UInt_t crate ) const;

     static const Int_t CM_OK;
     static const Int_t CM_ERR;

     const char* GetName() const { return fDBfileName.c_str(); }

 private:

     enum ECrateCode { kUnknown, kFastbus, kVME, kScaler, kCamac };

     std::string fDBfileName;       // Database file name
     TDatime     fInitTime;         // Database time stamp

     class SlotInfo_t {
     public:
       SlotInfo_t() :
         model(0), header(0), headmask(0xffffffff), bank(-1),
         nchan(0), ndata(0), used(false), clear(true) {}
       Int_t  model;
       UInt_t header;
       UInt_t headmask;
       Int_t  bank;
       UInt_t nchan;
       UInt_t ndata;
       std::string cfgstr;
       bool   used;
       bool   clear;
     };

     class CrateInfo_t {            // Crate Information data descriptor
     public:
       CrateInfo_t();
       ECrateCode  crate_code;
       std::string crate_type_name;
       std::string scalerloc;
       bool crate_used;
       bool bank_structure;
       std::vector<UInt_t> used_slots;
       std::array<SlotInfo_t, MAXSLOT> sltdat;
     };
     std::vector<CrateInfo_t> crdat;

     std::vector<UInt_t> used_crates;

     Int_t  loadConfig( std::string& line, std::string& cfgstr );
     Int_t  setCrateType( UInt_t crate, const char* stype ); // set the crate type
     Int_t  setModel( UInt_t crate, UInt_t slot, Int_t mod,
                      UInt_t nchan= MAXCHAN,
                      UInt_t ndata= MAXDATA );           // set the module type
     void   setUsed( UInt_t crate, UInt_t slot );
     Int_t  SetModelSize( UInt_t crate, UInt_t slot, UInt_t model );

     static Int_t readFile( FILE* fi, std::string& text );

     ClassDef(THaCrateMap,0) // Map of modules in DAQ crates
};

//=============== inline functions ================================
inline
bool THaCrateMap::isFastBus( UInt_t crate ) const
{
  assert( crate < crdat.size() );
  return (crdat[crate].crate_code == kFastbus);
}

inline
bool THaCrateMap::isVme( UInt_t crate ) const
{
  assert( crate < crdat.size() );
  return  (crdat[crate].crate_code == kVME ||
           crdat[crate].crate_code == kScaler );
}

inline
bool THaCrateMap::isCamac( UInt_t crate ) const
{
  assert( crate < crdat.size() );
  return (crdat[crate].crate_code == kCamac);
}

inline
bool THaCrateMap::isScalerCrate( UInt_t crate ) const
{
  assert( crate < crdat.size() );
  return (crdat[crate].crate_code == kScaler);
}

inline
bool THaCrateMap::isBankStructure( UInt_t crate ) const
{
  assert( crate < crdat.size() );
  return (crdat[crate].bank_structure);
}

inline
bool THaCrateMap::crateUsed( UInt_t crate ) const
{
  assert( crate < crdat.size() );
  return crdat[crate].crate_used;
}

inline
bool THaCrateMap::slotUsed( UInt_t crate, UInt_t slot ) const
{
  assert( crate < crdat.size() && slot < crdat[crate].sltdat.size() );
  if( crate >= crdat.size() || slot >= crdat[crate].sltdat.size() )
    return false;
  return crdat[crate].sltdat[slot].used;
}

inline
bool THaCrateMap::slotClear( UInt_t crate, UInt_t slot ) const
{
  assert( crate < crdat.size() && slot < crdat[crate].sltdat.size() );
  return crdat[crate].sltdat[slot].clear;
}

inline
Int_t THaCrateMap::getModel( UInt_t crate, UInt_t slot ) const
{
  assert( crate < crdat.size() && slot < crdat[crate].sltdat.size() );
  return crdat[crate].sltdat[slot].model;
}

inline
UInt_t THaCrateMap::getMask( UInt_t crate, UInt_t slot ) const
{
  assert( crate < crdat.size() && slot < crdat[crate].sltdat.size() );
  return crdat[crate].sltdat[slot].headmask;
}

inline
Int_t THaCrateMap::getBank( UInt_t crate, UInt_t slot ) const
{
  assert( crate < crdat.size() && slot < crdat[crate].sltdat.size() );
  return crdat[crate].sltdat[slot].bank;
}

inline
UInt_t THaCrateMap::getNchan( UInt_t crate, UInt_t slot ) const
{
  assert( crate < crdat.size() && slot < crdat[crate].sltdat.size() );
  return crdat[crate].sltdat[slot].nchan;
}

inline
UInt_t THaCrateMap::getNdata( UInt_t crate, UInt_t slot ) const
{
  assert( crate < crdat.size() && slot < crdat[crate].sltdat.size() );
  return crdat[crate].sltdat[slot].ndata;
}

inline
UInt_t THaCrateMap::getNslot( UInt_t crate ) const
{
  assert( crate < crdat.size() );
  return crdat[crate].used_slots.size();
}

inline
const char* THaCrateMap::getScalerLoc( UInt_t crate ) const
{
  assert( crate < crdat.size() );
  return crdat[crate].scalerloc.c_str();
}

inline
const char* THaCrateMap::getConfigStr( UInt_t crate, UInt_t slot ) const
{
  assert( crate < crdat.size() && slot < crdat[crate].sltdat.size() );
  return crdat[crate].sltdat[slot].cfgstr.c_str();
}

inline
UInt_t THaCrateMap::getMinSlot( UInt_t crate ) const
{
  assert( crate < crdat.size() );
  if( crdat[crate].used_slots.empty() )
    return kMaxUInt;
  return crdat[crate].used_slots.front();
}

inline
UInt_t THaCrateMap::getMaxSlot( UInt_t crate ) const
{
  assert( crate < crdat.size() );
  if( crdat[crate].used_slots.empty() )
    return 0;
  return crdat[crate].used_slots.back();
}

inline
UInt_t THaCrateMap::getHeader( UInt_t crate, UInt_t slot ) const
{
  assert( crate < crdat.size() && slot < crdat[crate].sltdat.size() );
  return crdat[crate].sltdat[slot].header;
}

inline
const std::vector<UInt_t>& THaCrateMap::GetUsedCrates() const
{
  return used_crates;
}

inline
const std::vector<UInt_t>& THaCrateMap::GetUsedSlots( UInt_t crate ) const
{
  assert( crate < crdat.size() );
  return crdat[crate].used_slots;
}

}

#endif