EMTFDaqOut.h

Go to the documentation of this file.

// Class for EMTF DAQ readout

#ifndef __l1t_EMTF_output_h__
#define __l1t_EMTF_output_h__

#include <vector>
#include <boost/cstdint.hpp> // For uint64_t and other types. Also found in DataFormats/L1Trigger/src/classes.h

#include "EMTF/AMC13Header.h"
#include "EMTF/MTF7Header.h"
#include "EMTF/EventHeader.h"
#include "EMTF/Counters.h"
#include "EMTF/ME.h"
#include "EMTF/RPC.h"
#include "EMTF/SP.h"
#include "EMTF/EventTrailer.h"
#include "EMTF/MTF7Trailer.h"
#include "EMTF/AMC13Trailer.h"

// All comments below apply equally to classes in EMTF/ directory - AWB 28.01.16

namespace l1t {
  class EMTFDaqOut {
    
  public:
    explicit EMTFDaqOut(uint64_t dataword); // What does this do? - AWB 28.01.16
    
  // Empty constructor - should we include classes and collections? - AWB 28.01.16
  EMTFDaqOut() :
    hasAMC13Header(false), hasMTF7Header(false), hasEventHeader(false), hasCounters(false), numME(0), numRPC(0), 
      numSP(0), hasEventTrailer(false), hasMTF7Trailer(false), hasAMC13Trailer(false), format_errors(0), dataword(-99)
      {};
    
  /* // Fill constructor - should we included a copy constructor for classes and collections (vectors)? - AWB 28.01.16 */
  /* EMTFDaqOut(emtf::AMC13Header class_AMC13Header, emtf::SPCollection coll_SPCollection) : */
  /*   AMC13Header(class_AMC13Header), SPCollection(coll_SPCollection), format_errors(0), dataword(-99) */
  /*   {}; */
    
    virtual ~EMTFDaqOut() {};

    void set_AMC13Header(emtf::AMC13Header bits)     { AMC13Header = bits;
                                                       hasAMC13Header = true;         }
    void set_MTF7Header(emtf::MTF7Header bits)       { MTF7Header = bits;
                                                       hasMTF7Header = true;          }
    void set_EventHeader(emtf::EventHeader bits)     { EventHeader = bits;
                                                       hasEventHeader = true;         }
    void set_Counters(emtf::Counters bits)           { Counters = bits;
                                                       hasCounters = true;            }
    void set_MECollection(emtf::MECollection bits)   { MECollection = bits;
                                                       numME = MECollection.size();   }
    void push_ME(emtf::ME bits)                      { MECollection.push_back(bits);
                                                       numME += 1;                    }
    void set_RPCCollection(emtf::RPCCollection bits) { RPCCollection = bits;
                                                       numRPC = RPCCollection.size(); }
    void push_RPC(emtf::RPC bits)                    { RPCCollection.push_back(bits);
                                                       numRPC += 1;                   }
    void set_SPCollection(emtf::SPCollection bits)   { SPCollection = bits;
                                                       numSP = SPCollection.size();   }
    void push_SP(emtf::SP bits)                      { SPCollection.push_back(bits);
                                                       numSP += 1;                    }
    void set_EventTrailer(emtf::EventTrailer bits)   { EventTrailer = bits;
                                                       hasEventTrailer = true;        }
    void set_MTF7Trailer(emtf::MTF7Trailer bits)     { MTF7Trailer = bits;
                                                       hasMTF7Trailer  = true;        }
    void set_AMC13Trailer(emtf::AMC13Trailer bits)   { AMC13Trailer = bits;
                                                       hasAMC13Trailer = true;        }
    void add_format_error()                          { format_errors += 1;            }
    void set_dataword(uint64_t bits)                 { dataword = bits;               }
    
    bool                       HasAMC13Header()   const { return hasAMC13Header;  }
    bool                       HasMTF7Header()    const { return hasMTF7Header;   }
    bool                       HasEventHeader()   const { return hasEventHeader;  }
    bool                       HasCounters()      const { return hasCounters;     }
    int                        NumSP()            const { return numSP;           }
    int                        NumRPC()           const { return numRPC;          }
    int                        NumME()            const { return numME;           }
    bool                       HasAMC13Trailer()  const { return hasAMC13Trailer; }
    bool                       HasMTF7Trailer()   const { return hasMTF7Trailer;  }
    bool                       HasEventTrailer()  const { return hasEventTrailer; }
    emtf::AMC13Header          GetAMC13Header()   const { return AMC13Header;     }
    emtf::MTF7Header           GetMTF7Header()    const { return MTF7Header;      }
    emtf::EventHeader          GetEventHeader()   const { return EventHeader;     }
    emtf::Counters             GetCounters()      const { return Counters;        }
    emtf::MECollection         GetMECollection()  const { return MECollection;    }
    emtf::RPCCollection        GetRPCCollection() const { return RPCCollection;   }
    emtf::SPCollection         GetSPCollection()  const { return SPCollection;    }
    emtf::EventTrailer         GetEventTrailer()  const { return EventTrailer;    }
    emtf::MTF7Trailer          GetMTF7Trailer()   const { return MTF7Trailer;     }
    emtf::AMC13Trailer         GetAMC13Trailer()  const { return AMC13Trailer;    }
    const emtf::AMC13Header*   PtrAMC13Header()   const { return & AMC13Header;   }
    const emtf::MTF7Header*    PtrMTF7Header()    const { return & MTF7Header;    }
    const emtf::EventHeader*   PtrEventHeader()   const { return & EventHeader;   }
    const emtf::Counters*      PtrCounters()      const { return & Counters;      }
    const emtf::MECollection*  PtrMECollection()  const { return & MECollection;  }
    const emtf::RPCCollection* PtrRPCCollection() const { return & RPCCollection; }
    const emtf::SPCollection*  PtrSPCollection()  const { return & SPCollection;  }
    const emtf::EventTrailer*  PtrEventTrailer()  const { return & EventTrailer;  }
    const emtf::MTF7Trailer*   PtrMTF7Trailer()   const { return & MTF7Trailer;   }
    const emtf::AMC13Trailer*  PtrAMC13Trailer()  const { return & AMC13Trailer;  }
    int                        Format_Errors()    const { return format_errors;   }
    uint64_t                   Dataword()         const { return dataword;        }
    
  private:
    bool hasAMC13Header; 
    bool hasMTF7Header; 
    bool hasEventHeader; 
    bool hasCounters; 
    int numME; 
    int numRPC; 
    int numSP; 
    bool hasEventTrailer; 
    bool hasMTF7Trailer; 
    bool hasAMC13Trailer; 
    emtf::AMC13Header AMC13Header;
    emtf::MTF7Header MTF7Header;
    emtf::EventHeader EventHeader;
    emtf::Counters Counters;
    emtf::MECollection MECollection;
    emtf::RPCCollection RPCCollection;
    emtf::SPCollection SPCollection;
    emtf::EventTrailer EventTrailer;
    emtf::MTF7Trailer MTF7Trailer;
    emtf::AMC13Trailer AMC13Trailer;
    int format_errors;
    uint64_t dataword; // Should this be more or fewer bits? - AWB 28.01.16
    
  }; // End class EMTFDaqOut

  // Define a vector of EMTFDaqOut
  typedef std::vector<EMTFDaqOut> EMTFDaqOutCollection;

} // End namespace l1t

#endif /* define __l1t_EMTF_output_h__ */