momentum.h

// -*- C++ -*-
// File: momentum.h                                                          //
// Description: header file for 4-momentum class Cmomentum                   //
// This file is part of the SISCone project.                                 //
// For more details, see http://projects.hepforge.org/siscone                //
//                                                                           //
// Copyright (c) 2006 Gavin Salam and Gregory Soyez                          //
//                                                                           //
// This program is free software; you can redistribute it and/or modify      //
// it under the terms of the GNU General Public License as published by      //
// the Free Software Foundation; either version 2 of the License, or         //
// (at your option) any later version.                                       //
//                                                                           //
// This program is distributed in the hope that it will be useful,           //
// but WITHOUT ANY WARRANTY; without even the implied warranty of            //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             //
// GNU General Public License for more details.                              //
//                                                                           //
// You should have received a copy of the GNU General Public License         //
// along with this program; if not, write to the Free Software               //
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
//                                                                           //
// $Revision::                                                              $//
// $Date::                                                                  $//
 
#ifndef __VECTOR_H__
#define __VECTOR_H__
 
#include <vector>
#include <math.h>
#include "reference.h"
#include "geom_2d.h"
#include "defines.h"
 
namespace siscone{
 
class Cmomentum{
 public:
  Cmomentum();
 
  Cmomentum(double _px, double _py, double _pz, double _E);
 
  Cmomentum(double _eta, double _phi, Creference _ref);
 
  ~Cmomentum();
 
  inline double perp() const {return sqrt(perp2());}
 
  inline double perp2() const {return px*px+py*py;}
 
  inline double mass() const {return sqrt(mass2());}
 
  inline double mass2() const {return perpmass2()-perp2();}
 
  inline double perpmass() const {return sqrt((E-pz)*(E+pz));}
 
  inline double perpmass2() const {return (E-pz)*(E+pz);}
 
  inline double Et() const {return E/sqrt(1.0+pz*pz/perp2());}
 
  inline double Et2() const {return E*E/(1.0+pz*pz/perp2());}
 
  Cmomentum& operator = (const Cmomentum &v);
 
  const Cmomentum operator + (const Cmomentum &v);
 
  Cmomentum& operator += (const Cmomentum &v);
 
  Cmomentum& operator -= (const Cmomentum &v);
 
  void build_etaphi();
 
  double px;        
  double py;        
  double pz;        
  double E;         
 
  double eta;       
  double phi;       
  int parent_index; 
  int index;        
 
  // the following part is used for checksums //
  Creference ref;   
};
 
bool operator < (const Cmomentum &v1, const Cmomentum &v2);
 
bool momentum_eta_less(const Cmomentum &v1, const Cmomentum &v2);
 
bool momentum_pt_less(const Cmomentum &v1, const Cmomentum &v2);
 
 
// some handy utilities //
 
inline double get_distance(double eta, double phi, Cmomentum *v){
  double dx, dy;
 
  dx = eta - v->eta;
  dy = fabs(phi - v->phi);
  if (dy>M_PI) 
    dy -= twopi;
 
  return dx*dx+dy*dy;
}
 
}
 
#endif