LHCInfo.h

Go to the documentation of this file.

#ifndef CondFormats_RunInfo_LHCInfo_H
#define CondFormats_RunInfo_LHCInfo_H
 
#include "CondFormats/Serialization/interface/Serializable.h"
#include "CondFormats/Common/interface/Time.h"
#include <bitset>
#include <iostream>
#include <string>
#include <sstream>
#include <vector>
 
class LHCInfo {
public:
  enum FillType { UNKNOWN = 0, PROTONS = 1, IONS = 2, COSMICS = 3, GAP = 4 };
  enum ParticleType { NONE = 0, PROTON = 1, PB82 = 2, AR18 = 3, D = 4, XE54 = 5 };
 
  enum IntParamIndex {
    LHC_FILL = 0,
    BUNCHES_1 = 1,
    BUNCHES_2 = 2,
    COLLIDING_BUNCHES = 3,
    TARGET_BUNCHES = 4,
    FILL_TYPE = 5,
    PARTICLES_1 = 6,
    PARTICLES_2 = 7,
    LUMI_SECTION = 8,
    ISIZE = 9
  };
  enum FloatParamIndex {
    CROSSING_ANGLE = 0,
    BETA_STAR = 1,
    INTENSITY_1 = 2,
    INTENSITY_2 = 3,
    ENERGY = 4,
    DELIV_LUMI = 5,
    REC_LUMI = 7,
    LUMI_PER_B = 8,
    BEAM1_VC = 9,
    BEAM2_VC = 10,
    BEAM1_RF = 11,
    BEAM2_RF = 12,
    INST_LUMI = 13,
    INST_LUMI_ERR = 14,
    FSIZE = 15
  };
  enum TimeParamIndex { CREATE_TIME = 0, BEGIN_TIME = 1, END_TIME = 2, TSIZE = 3 };
  enum StringParamIndex { INJECTION_SCHEME = 0, LHC_STATE = 1, LHC_COMMENT = 2, CTPPS_STATUS = 3, SSIZE = 4 };
 
  typedef FillType FillTypeId;
  typedef ParticleType ParticleTypeId;
  LHCInfo();
  LHCInfo(const LHCInfo& rhs);
  ~LHCInfo();
 
  LHCInfo* cloneFill() const;
 
  //constant static unsigned integer hosting the maximum number of LHC bunch slots
  static size_t const bunchSlots = 3564;
 
  //constant static unsigned integer hosting the available number of LHC bunch slots
  static size_t const availableBunchSlots = 2808;
 
  void setFillNumber(unsigned short lhcFill);
 
  //getters
  unsigned short const fillNumber() const;
 
  unsigned short const bunchesInBeam1() const;
 
  unsigned short const bunchesInBeam2() const;
 
  unsigned short const collidingBunches() const;
 
  unsigned short const targetBunches() const;
 
  FillTypeId const fillType() const;
 
  ParticleTypeId const particleTypeForBeam1() const;
 
  ParticleTypeId const particleTypeForBeam2() const;
 
  float const crossingAngle() const;
 
  float const betaStar() const;
 
  float const intensityForBeam1() const;
 
  float const intensityForBeam2() const;
 
  float const energy() const;
 
  float const delivLumi() const;
 
  float const recLumi() const;
 
  float const instLumi() const;
 
  float const instLumiError() const;
 
  cond::Time_t const createTime() const;
 
  cond::Time_t const beginTime() const;
 
  cond::Time_t const endTime() const;
 
  std::string const& injectionScheme() const;
 
  std::vector<float> const& lumiPerBX() const;
 
  std::string const& lhcState() const;
 
  std::string const& lhcComment() const;
 
  std::string const& ctppsStatus() const;
 
  unsigned int const& lumiSection() const;
 
  std::vector<float> const& beam1VC() const;
 
  std::vector<float> const& beam2VC() const;
 
  std::vector<float> const& beam1RF() const;
 
  std::vector<float> const& beam2RF() const;
 
  std::vector<float>& beam1VC();
 
  std::vector<float>& beam2VC();
 
  std::vector<float>& beam1RF();
 
  std::vector<float>& beam2RF();
 
  //returns a boolean, true if the injection scheme has a leading 25ns
  //TODO: parse the circulating bunch configuration, instead of the string.
  bool is25nsBunchSpacing() const;
 
  //returns a boolean, true if the bunch slot number is in the circulating bunch configuration
  bool isBunchInBeam1(size_t const& bunch) const;
 
  bool isBunchInBeam2(size_t const& bunch) const;
 
  //member functions returning *by value* a vector with all filled bunch slots
  std::vector<unsigned short> bunchConfigurationForBeam1() const;
 
  std::vector<unsigned short> bunchConfigurationForBeam2() const;
 
  //setters
  void setBunchesInBeam1(unsigned short const& bunches);
 
  void setBunchesInBeam2(unsigned short const& bunches);
 
  void setCollidingBunches(unsigned short const& collidingBunches);
 
  void setTargetBunches(unsigned short const& targetBunches);
 
  void setFillType(FillTypeId const& fillType);
 
  void setParticleTypeForBeam1(ParticleTypeId const& particleType);
 
  void setParticleTypeForBeam2(ParticleTypeId const& particleType);
 
  void setCrossingAngle(float const& angle);
 
  void setBetaStar(float const& betaStar);
 
  void setIntensityForBeam1(float const& intensity);
 
  void setIntensityForBeam2(float const& intensity);
 
  void setEnergy(float const& energy);
 
  void setDelivLumi(float const& delivLumi);
 
  void setRecLumi(float const& recLumi);
 
  void setInstLumi(float const& instLumi);
 
  void setInstLumiError(float const& instLumiError);
 
  void setCreationTime(cond::Time_t const& createTime);
 
  void setBeginTime(cond::Time_t const& beginTime);
 
  void setEndTime(cond::Time_t const& endTime);
 
  void setInjectionScheme(std::string const& injectionScheme);
 
  void setLumiPerBX(std::vector<float> const& lumiPerBX);
 
  void setLhcState(std::string const& lhcState);
 
  void setLhcComment(std::string const& lhcComment);
 
  void setCtppsStatus(std::string const& ctppsStatus);
 
  void setLumiSection(unsigned int const& lumiSection);
 
  void setBeam1VC(std::vector<float> const& beam1VC);
 
  void setBeam2VC(std::vector<float> const& beam2VC);
 
  void setBeam1RF(std::vector<float> const& beam1RF);
 
  void setBeam2RF(std::vector<float> const& beam2RF);
 
  //sets all values in one go
  void setInfo(unsigned short const& bunches1,
               unsigned short const& bunches2,
               unsigned short const& collidingBunches,
               unsigned short const& targetBunches,
               FillTypeId const& fillType,
               ParticleTypeId const& particleType1,
               ParticleTypeId const& particleType2,
               float const& angle,
               float const& beta,
               float const& intensity1,
               float const& intensity2,
               float const& energy,
               float const& delivLumi,
               float const& recLumi,
               float const& instLumi,
               float const& instLumiError,
               cond::Time_t const& createTime,
               cond::Time_t const& beginTime,
               cond::Time_t const& endTime,
               std::string const& scheme,
               std::vector<float> const& lumiPerBX,
               std::string const& lhcState,
               std::string const& lhcComment,
               std::string const& ctppsStatus,
               unsigned int const& lumiSection,
               std::vector<float> const& beam1VC,
               std::vector<float> const& beam2VC,
               std::vector<float> const& beam1RF,
               std::vector<float> const& beam2RF,
               std::bitset<bunchSlots + 1> const& bunchConf1,
               std::bitset<bunchSlots + 1> const& bunchConf2);
 
  bool equals(const LHCInfo& rhs) const;
 
  bool empty() const;
 
  //dumping values on output stream
  void print(std::stringstream& ss) const;
 
  std::bitset<bunchSlots + 1> const& bunchBitsetForBeam1() const;
 
  std::bitset<bunchSlots + 1> const& bunchBitsetForBeam2() const;
 
  void setBunchBitsetForBeam1(std::bitset<bunchSlots + 1> const& bunchConfiguration);
 
  void setBunchBitsetForBeam2(std::bitset<bunchSlots + 1> const& bunchConfiguration);
 
private:
  bool m_isData = false;
  std::vector<std::vector<unsigned int> > m_intParams;
  std::vector<std::vector<float> > m_floatParams;
  std::vector<std::vector<unsigned long long> > m_timeParams;
  std::vector<std::vector<std::string> > m_stringParams;
  std::bitset<bunchSlots + 1> m_bunchConfiguration1, m_bunchConfiguration2;
 
  COND_SERIALIZABLE;
};
 
std::ostream& operator<<(std::ostream&, LHCInfo lhcInfo);
 
#endif  // CondFormats_RunInfo_LHCInfo_H