PdfInfo.h

//--------------------------------------------------------------------------
#ifndef HEPMC_PDF_INFO_H
#define HEPMC_PDF_INFO_H

// garren@fnal.gov, July 2006
//
// Additional PDF information

namespace HepMC {


class PdfInfo {

public:
  // ---  birth/death:
  //
  PdfInfo()
    : m_id1(0), 
      m_id2(0),
      m_pdf_id1(0),
      m_pdf_id2(0),
      m_x1(0),
      m_x2(0),
      m_scalePDF(0),
      m_pdf1(0),
      m_pdf2(0)
    {}

  PdfInfo( int i1, int i2, double x1, double x2,
           double q, double p1, double p2,
           int pdf_id1 = 0, int pdf_id2 = 0 );

  ~PdfInfo() {}
    
  // ---  copying:
  //
  PdfInfo( PdfInfo const & orig );      
  PdfInfo &  operator = ( PdfInfo const & rhs ); 
  void swap( PdfInfo & other ); 

  // ---  equivalence:
  //
  bool    operator==( const PdfInfo& ) const; 
  bool    operator!=( const PdfInfo& ) const; 

  // ---  accessors:
    int   id1()                   const { return m_id1; }
    int   id2()                   const { return m_id2; }
    int   pdf_id1()                   const { return m_pdf_id1; }
    int   pdf_id2()                   const { return m_pdf_id2; }
    double x1()                   const { return m_x1; } 
    double x2()                   const { return m_x2; }
    double scalePDF()             const { return m_scalePDF;  }
    double pdf1()                 const { return m_pdf1; }
    double pdf2()                 const { return m_pdf2; }

    bool  is_valid()                     const;

  // ---  mutators:
    void   set_id1(const int &i)              { m_id1=i; }
    void   set_id2(const int &i)              { m_id2=i; }
    void   set_pdf_id1(const int &i)              { m_pdf_id1=i; }
    void   set_pdf_id2(const int &i)              { m_pdf_id2=i; }
    void   set_x1(const double &f)            { m_x1=f; }
    void   set_x2(const double &f)            { m_x2=f; }
    void   set_scalePDF(const double &f)      { m_scalePDF=f;  }
    void   set_pdf1(const double &f)          { m_pdf1=f; }
    void   set_pdf2(const double &f)          { m_pdf2=f; }

private: // data members
    int   m_id1; 
    int   m_id2; 
    int   m_pdf_id1; 
    int   m_pdf_id2; 
    double m_x1;
    double m_x2;
    double m_scalePDF; 
    double m_pdf1;
    double m_pdf2;

};

// Free Functions

// IO
std::ostream & operator << (std::ostream &, PdfInfo const *);
std::istream & operator >> (std::istream &, PdfInfo *);

// inline operators
inline PdfInfo::PdfInfo( int i1, int i2, double xin1, double xin2,
                         double q, double p1, double p2,
                         int pid1, int pid2 )
    : m_id1(i1), 
      m_id2(i2),
      m_pdf_id1(pid1),
      m_pdf_id2(pid2),
      m_x1(xin1),
      m_x2(xin2),
      m_scalePDF(q),
      m_pdf1(p1),
      m_pdf2(p2)
   {}

inline PdfInfo::PdfInfo( PdfInfo const & orig )
    : m_id1(orig.m_id1), 
      m_id2(orig.m_id2),
      m_pdf_id1(orig.m_pdf_id1), 
      m_pdf_id2(orig.m_pdf_id2),
      m_x1(orig.m_x1),
      m_x2(orig.m_x2),
      m_scalePDF(orig.m_scalePDF),
      m_pdf1(orig.m_pdf1),
      m_pdf2(orig.m_pdf2)
   {}

inline PdfInfo &  PdfInfo::operator = ( PdfInfo const & rhs ) 
{
  PdfInfo temp( rhs );
  swap( temp );
  return *this;
}

inline void PdfInfo::swap( PdfInfo & other ) 
{
  std::swap(m_id1, other.m_id1); 
  std::swap(m_id2, other.m_id2);
  std::swap(m_pdf_id1, other.m_pdf_id1); 
  std::swap(m_pdf_id2, other.m_pdf_id2);
  std::swap(m_x1, other.m_x1);
  std::swap(m_x2, other.m_x2);
  std::swap(m_scalePDF, other.m_scalePDF);
  std::swap(m_pdf1, other.m_pdf1);
  std::swap(m_pdf2, other.m_pdf2);
}

inline bool    PdfInfo::operator==( const PdfInfo& a ) const
{
    return (    a.id1() == this->id1() 
             && a.id2() == this->id2() 
             && a.pdf_id1() == this->pdf_id1() 
             && a.pdf_id2() == this->pdf_id2() 
             && a.x1() == this->x1() 
             && a.x2() == this->x2()
             && a.scalePDF() == this->scalePDF() 
             && a.pdf1() == this->pdf1()
             && a.pdf2() == this->pdf2() );
}

inline bool    PdfInfo::operator!=( const PdfInfo& a ) const
{
    return !( a == *this );
}

inline bool  PdfInfo::is_valid() const
{
    if( m_id1 != 0 ) return true;
    if( m_id2 != 0 ) return true;
    if( m_pdf_id1 != 0 ) return true;
    if( m_pdf_id2 != 0 ) return true;
    if( m_x1 != 0 ) return true;
    if( m_x2 != 0 ) return true;
    if( m_scalePDF != 0 ) return true;
    if( m_pdf1 != 0 ) return true;
    if( m_pdf2 != 0 ) return true;
    return false;
}

} // HepMC

#endif  // HEPMC_PDF_INFO_H