siscone/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:: 163                                                          $//
// $Date:: 2007-04-26 22:31:02 +0200 (Thu, 26 Apr 2007)                     $//

#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