JSignal.h

//-----------------------------------------------------------------------------
// $Id$
//-----------------------------------------------------------------------------
// Filename : JSignal.h
// Section  : TRG CDC
// Owner    : Jaebak KIM (K.U.)
// Email    : jbkim@hep.korea.ac.kr
//-----------------------------------------------------------------------------
// Description : A class for Signals in CDC Trigger for 3D tracker.
//-----------------------------------------------------------------------------
// $Log$
//-----------------------------------------------------------------------------
 
#ifndef TRGCDCJSignal_FLAG_
#define TRGCDCJSignal_FLAG_
 
#include <string>
#include <vector>
#include <utility>
#include <map>
#include <tuple>
 
#ifdef TRGCDC_SHORT_NAMES
#define JSignal TRGCDCJSignal
#endif
 
namespace Belle2 {
  class TRGCDCJSignalData;
 
  class TRGCDCJSignal {
 
  public:
 
    TRGCDCJSignal();
    explicit TRGCDCJSignal(TRGCDCJSignalData*);
    TRGCDCJSignal(int const& bitwidth, double const& value, double const& min, double const& max, int const& clock, TRGCDCJSignalData*);
    TRGCDCJSignal(int const& bitwidth, double const& value, double const& min, double const& max, TRGCDCJSignalData*);
    TRGCDCJSignal(signed long long const& intValue, double const& toReal, signed long long const& minInt,
                  signed long long const& maxInt, double const& actual, double const& minActual, double const& maxActual, int const& finishClock,
                  TRGCDCJSignalData*, bool b_slv = 0);
    TRGCDCJSignal(double const& value, double const& toReal, TRGCDCJSignalData*);
    TRGCDCJSignal(std::vector<bool> const& slvValue, int const& finishClock, TRGCDCJSignalData*);
 
    ~TRGCDCJSignal() {}
 
    TRGCDCJSignal& assignTo(TRGCDCJSignal const& rhs, int targetClock, std::string& finalCode);
    TRGCDCJSignal& assignTo(TRGCDCJSignal const& rhs, int targetClock);
    TRGCDCJSignal& operator<= (TRGCDCJSignal const& rhs);
    TRGCDCJSignal const operator- () const;
    TRGCDCJSignal const operator+ (TRGCDCJSignal const& rhs) const;
    TRGCDCJSignal const operator- (TRGCDCJSignal const& rhs) const;
    TRGCDCJSignal const operator* (TRGCDCJSignal const& rhs) const;
 
    void dump() const;
    TRGCDCJSignal const shift(int nBits, int operate = 1) const;
    TRGCDCJSignal const offset(TRGCDCJSignal const& valueMin) const;
    TRGCDCJSignal const invOffset(TRGCDCJSignal const& valueMin) const;
    static void choose(TRGCDCJSignal& target, TRGCDCJSignal const& targetMin, TRGCDCJSignal const& targetMax,
                       TRGCDCJSignal const& reference, std::vector<std::vector<TRGCDCJSignal> > data, int targetClock);
    static void choose(TRGCDCJSignal& target, TRGCDCJSignal const& targetMin, TRGCDCJSignal const& targetMax,
                       TRGCDCJSignal const& reference, std::vector<std::vector<TRGCDCJSignal> >& data);
    static void choose(TRGCDCJSignal& target, TRGCDCJSignal const& reference, std::vector<std::vector<TRGCDCJSignal> > data,
                       int targetClock);
    static void choose(TRGCDCJSignal& target, TRGCDCJSignal const& reference, std::vector<std::vector<TRGCDCJSignal> >& data);
    static void ifElse(std::vector<std::pair<TRGCDCJSignal, std::vector<std::pair<TRGCDCJSignal*, TRGCDCJSignal> > > >& data,
                       int targetClock);
    static void ifElse(std::vector<std::pair<TRGCDCJSignal, std::vector<std::pair<TRGCDCJSignal*, TRGCDCJSignal> > > >& data);
    TRGCDCJSignal const limit(signed long long minInt, signed long long maxInt, double minActual, double maxActual) const;
    TRGCDCJSignal const limit(TRGCDCJSignal const& min, TRGCDCJSignal const& max) const;
    TRGCDCJSignal const resize(int bitwidth) const;
    //TRGCDCJSignal const toSigned() const;
    //TRGCDCJSignal const toUnsigned() const;
    static TRGCDCJSignal const toSlv(TRGCDCJSignal const& in, int test);
    static TRGCDCJSignal const toSlv(TRGCDCJSignal const&);
 
    static TRGCDCJSignal const slvToSigned(TRGCDCJSignal const& in, double const& toReal, signed long long const& minInt,
                                           signed long long const& maxInt, double const& actual, double const& minActual, double const& maxActual, int const& finishClock);
    static TRGCDCJSignal const slvToSigned(TRGCDCJSignal const& in);
    static TRGCDCJSignal const slvToUnsigned(TRGCDCJSignal const& in, double const& toReal, signed long long const& minInt,
                                             signed long long const& maxInt, double const& actual, double const& minActual, double const& maxActual, int const& finishClock);
    static TRGCDCJSignal const slvToUnsigned(TRGCDCJSignal const& in);
    static TRGCDCJSignal const signedToSlv(TRGCDCJSignal const& in);
    static TRGCDCJSignal const unsignedToSlv(TRGCDCJSignal const& in);
 
    static TRGCDCJSignal comp(TRGCDCJSignal const& lhs, std::string operate, TRGCDCJSignal const& rhs);
 
 
    void setName(std::string name);
    void setInt(signed long long value);
    void setActual(double value);
    void setToReal(double value);
    void setType(int type);
    void setBitsize(int bitsize);
    void setFinishClock(int finishClock);
    void setDebug(bool debug);
    void setPrintVhdl(bool printVhdl);
    void setVhdlOutputFile(std::string filename);
    void setCommonData(TRGCDCJSignalData*);
    std::string getName() const;
    int getType() const;
    double getBitsize() const;
    signed long long getInt() const;
    signed long long getMinInt() const;
    signed long long getMaxInt() const;
    double getActual() const;
    double getMinActual() const;
    double getMaxActual() const;
    double getRealInt() const;
    double getRealMinInt() const;
    double getRealMaxInt() const;
    double getToReal() const;
    int getFinishClock() const;
    std::vector<std::pair<std::string, std::vector<int> > > const getArgumentSignals() const;
    TRGCDCJSignalData* getCommonData() const;
    int calType() const;
    int calType(double minValue) const;
    int calBitwidth() const;
    int calBitwidth(int type, signed long long minInt, signed long long maxInt);
    int calFinishClock() const;
    std::string getVhdlCode() const;
    bool getPrintVhdl() const;
    std::string getVhdlOutputFile() const;
 
    void matchUnit(TRGCDCJSignal& first, TRGCDCJSignal& second) const;
    void swap(TRGCDCJSignal& first, TRGCDCJSignal& second) const;
    bool orderLargestBitsize(TRGCDCJSignal& large, TRGCDCJSignal& small) const;
    signed long long calMaxInteger() const;
    signed long long calMinInteger() const;
    static TRGCDCJSignal const absolute(TRGCDCJSignal const& first);
    //void calTypeBitwidth(TRGCDCJSignal const & first, std::string operation, TRGCDCJSignal const & second, int & type, int & bitwidth) const;
    static signed long long calInt(double value, TRGCDCJSignal const& mother);
    static void calVhdlTypeBitwidth(TRGCDCJSignal const& first, std::string& operation, TRGCDCJSignal const& second, int& type,
                                    int& bitwidth);
    void initArgumentSignals();
    static void combineArguments(TRGCDCJSignal const& first, TRGCDCJSignal const& second, TRGCDCJSignal& result) ;
    void initVhdlCode();
    void toSignedVhdlCode();
    void toUnsignedVhdlCode();
    static void vhdlCode(TRGCDCJSignal const& first, std::string operation, TRGCDCJSignal const& second, TRGCDCJSignal const& result,
                         std::string& targtVhdlCode);
    static void vhdlCode(std::string operation, TRGCDCJSignal const& first, TRGCDCJSignal const& result, std::string& targetVhdlCode);
    static std::string replaceWithSignalNames(std::string const& fromVhdlCode,
                                              std::vector<std::pair<std::string, std::vector<int> > > const& fromVhdlSignals, int const& finishClock,
                                              std::map<std::string, std::vector<int> >& buffers);
    static std::string assignVhdlCode(TRGCDCJSignal const& target, TRGCDCJSignal const& from);
    static std::string chooseVhdlCode(TRGCDCJSignal const& target, TRGCDCJSignal const& reference,
                                      std::vector<std::vector<TRGCDCJSignal> > const& data);
    static std::string ifElseVhdlCode(std::vector<std::pair<TRGCDCJSignal, std::vector<std::pair<TRGCDCJSignal*, TRGCDCJSignal> > > >
                                      const& data);
    void printVhdl(std::string& vhdlCode);
    void checkInt(std::string name) const;
    static bool isSameSignal(TRGCDCJSignal const& lhs, TRGCDCJSignal const& rhs);
    static void valuesToMapSignals(std::vector<std::tuple<std::string, double, int, double, double, int> > const& inValues,
                                   Belle2::TRGCDCJSignalData* inCommonData, std::map<std::string, Belle2::TRGCDCJSignal>& outMap);
    static void mapSignalsToValues(std::map<std::string, Belle2::TRGCDCJSignal>const& inMap,
                                   std::vector<std::pair<std::string, int> > const& inChoose,
                                   std::vector<std::tuple<std::string, double, int, double, double, int> >& outValues);
 
  private:
 
    std::string m_name;
    int m_type; 
    int m_bitsize;
    signed long long m_int;
    std::vector<bool> m_slv;
    signed long long m_minInt;
    signed long long m_maxInt;
    double m_actual;
    double m_minActual;
    double m_maxActual;
    double m_toReal;
    bool m_debug;
    std::string m_vhdlCode;
    std::vector<std::pair<std::string, std::vector<int> > > m_argumentSignals;
    int m_finishClock;
    //bool m_printVhdl;
    TRGCDCJSignalData* m_commonData;
 
  };
 
} 
 
#endif /* TRGCDCJSignal_FLAG_ */