lcio_doc/html/Operators_8h_source.html

 #ifndef LCIO_OPERATORS_H

 #define LCIO_OPERATORS_H 1


 // Define operators for convenient printing of LCIO objects.

 //

 //

 // @author J Engels, H. Hoelbe

 // @version $Id: Operators.h,v 1.8.2.1 2011-03-04 14:09:07 engels Exp $


 #include "EVENT/ReconstructedParticle.h"

 #include "EVENT/SimCalorimeterHit.h"

 #include "EVENT/MCParticle.h"

 #include "EVENT/SimTrackerHit.h"

 #include "EVENT/TrackerHit.h"

 #include "EVENT/TrackerHitPlane.h"

 #include "EVENT/TrackerHitZCylinder.h"

 #include "EVENT/Track.h"

 #include "EVENT/TrackState.h"

 #include "EVENT/Cluster.h"

 #include "EVENT/CalorimeterHit.h"

 #include "EVENT/LCFlag.h"

 #include "EVENT/LCIntVec.h"

 #include "EVENT/LCRunHeader.h"

 #include "EVENT/RawCalorimeterHit.h"

 //#include "EVENT/TPCHit.h"

 #include "EVENT/TrackerPulse.h"

 #include "EVENT/LCFloatVec.h"

 #include "EVENT/LCObject.h"

 #include "EVENT/TrackerRawData.h"

 #include "EVENT/LCCollection.h"

 #include "EVENT/LCGenericObject.h"

 #include "EVENT/LCParameters.h"

 #include "EVENT/TrackerData.h"

 #include "EVENT/LCEvent.h"

 #include "EVENT/LCIO.h"

 #include "EVENT/LCRelation.h"

 #include "EVENT/ParticleID.h"

 #include "EVENT/Vertex.h"

 //#include "EVENT/LCStrVec.h"


 #include <iostream>

 #include <iomanip>

 #include <string>

 #include <sstream>


 namespace UTIL{


   //template to enable the use of the operator << for a "one-line" output of an object.

   //since there are two ostream& << operators for sending an object to the output stream this

   //template works like a "wrapper class" so that the correct operator can be triggered for the

   //respective detailed/short output

 /*

   template <class T> struct lcio_short{

     const T* obj;

     lcio_short(const T* t) : obj(p) {}

   };

 */

   template <class T>

     class lcio_short{

         public:

             const T* obj;

             const EVENT::LCCollection* col;

             lcio_short(const T* t, const EVENT::LCCollection* b=NULL) : obj(t), col(b) {}

             //lcio_short(const T* t) : obj(t) {col = NULL;}

     };


   //template to enable a "one-line" output

   template <class T> lcio_short<T> lcshort( const T* t, const EVENT::LCCollection* b=NULL){ return lcio_short<T>(t,b); }


   const std::string& header(const EVENT::Vertex *);

   const std::string& tail(const EVENT::Vertex *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::Vertex>& sV);


 //hauke 2010 (start)

   const std::string& header( const EVENT::MCParticle *);

   const std::string& tail( const EVENT::MCParticle *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::MCParticle>& sV);


   const std::string& header( const EVENT::TrackerHit *);

   const std::string& tail( const EVENT::TrackerHit *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::TrackerHit>& sV);


   const std::string& header( const EVENT::TrackerHitPlane *);

   const std::string& tail( const EVENT::TrackerHitPlane *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::TrackerHitPlane>& sV);


   const std::string& header( const EVENT::TrackerHitZCylinder *);

   const std::string& tail( const EVENT::TrackerHitZCylinder *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::TrackerHitZCylinder>& sV);


   const std::string& header( const EVENT::SimTrackerHit *);

   const std::string& tail( const EVENT::SimTrackerHit *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::SimTrackerHit>& sV);


   const std::string& header( const EVENT::CalorimeterHit *);

   const std::string& tail( const EVENT::CalorimeterHit *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::CalorimeterHit>& sV);


   const std::string& header( const EVENT::SimCalorimeterHit *);

   const std::string& tail( const EVENT::SimCalorimeterHit *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::SimCalorimeterHit>& sV);


   const std::string& header( const EVENT::ReconstructedParticle *);

   const std::string& tail( const EVENT::ReconstructedParticle *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::ReconstructedParticle> & );


   const std::string& header( const EVENT::Track *);

   const std::string& tail( const EVENT::Track *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::Track> &);


   const std::string& header( const EVENT::TrackState *);

   const std::string& tail( const EVENT::TrackState *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::TrackState> &);


   const std::string& header( const EVENT::Cluster *);

   const std::string& tail( const EVENT::Cluster *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::Cluster> &);


   const std::string& header( const EVENT::LCRelation *);

   const std::string& tail( const EVENT::LCRelation *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::LCRelation> &);


   const std::string& header( const EVENT::LCFloatVec *);

   const std::string& tail( const EVENT::LCFloatVec *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::LCFloatVec> &);


   template <class T>

         const std::string & header(){return header((T*)(0)); }

   template <class T>

         const std::string & tail(){return tail((T)(0)); }


   template <class T>

   class LCIO_LONG{

         public:

             LCIO_LONG() = default ;

             LCIO_LONG(const LCIO_LONG& ) = default ;

             LCIO_LONG& operator=(const LCIO_LONG& ) = default ;

             LCIO_LONG(const T& o, const EVENT::LCCollection* c){ obj=&o; col=c;};

             const T *object(void) const {return(obj);};

             const EVENT::LCCollection *collection(void) const {return(col);};

         private:

             const T *obj{NULL};

             const EVENT::LCCollection *col{NULL};

   };


   //test:

   template <class T>

   LCIO_LONG<T> lcio_long(const T& o, const EVENT::LCCollection* c){return(LCIO_LONG<T>(o,c));}


   std::ostream& operator<<( std::ostream& out, const LCIO_LONG<EVENT::CalorimeterHit> l);

   std::ostream& operator<<( std::ostream& out, const LCIO_LONG<EVENT::Cluster> l);

   std::ostream& operator<<( std::ostream& out, const LCIO_LONG<EVENT::Track> l);

   std::ostream& operator<<( std::ostream& out, const LCIO_LONG<EVENT::TrackState> l);

   std::ostream& operator<<( std::ostream& out, const LCIO_LONG<EVENT::ReconstructedParticle> ll);

   std::ostream& operator<<( std::ostream& out, const LCIO_LONG<EVENT::SimCalorimeterHit> ll);

   std::ostream& operator<<( std::ostream& out, const LCIO_LONG<EVENT::TrackerHit> ll);

   std::ostream& operator<<( std::ostream& out, const LCIO_LONG<EVENT::TrackerHitPlane> ll);

   std::ostream& operator<<( std::ostream& out, const LCIO_LONG<EVENT::TrackerHitZCylinder> ll);

   std::ostream& operator<<( std::ostream& out, const LCIO_LONG<EVENT::SimTrackerHit> ll);

   std::ostream& operator<<( std::ostream& out, const LCIO_LONG<EVENT::MCParticle> ll);

   std::ostream& operator<<( std::ostream& out, const LCIO_LONG<EVENT::Vertex> ll);

   std::ostream& operator<<( std::ostream& out, const LCIO_LONG<EVENT::LCRelation> ll);

   std::ostream& operator<<( std::ostream& out, const LCIO_LONG<EVENT::LCFloatVec> ll);


   const std::string& header( const EVENT::LCCollection *);

   const std::string& tail( const EVENT::LCCollection *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::LCCollection> &);


   const std::string& header( const EVENT::LCEvent *);

   const std::string& tail( const EVENT::LCEvent *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::LCEvent> &);


   const std::string& header( const EVENT::LCFlag *);

   const std::string& tail( const EVENT::LCFlag *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::LCFlag> &);


   const std::string& header( const EVENT::LCGenericObject *, const EVENT::LCCollection *v = NULL);

   const std::string& tail( const EVENT::LCGenericObject *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::LCGenericObject> &);


   const std::string& header( const EVENT::LCIntVec *);

   const std::string& tail( const EVENT::LCIntVec *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::LCIntVec> &);


   const std::string& header( const EVENT::LCObject *);

   const std::string& tail( const EVENT::LCObject *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::LCObject> &);


   const std::string& header( const EVENT::LCParameters *);

   const std::string& tail( const EVENT::LCParameters *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::LCParameters> &);


   const std::string& header( const EVENT::LCRunHeader *);

   const std::string& tail( const EVENT::LCRunHeader *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::LCRunHeader> &);


 /*

   const std::string& header( const EVENT::LCStrVec &);

   const std::string& tail( const EVENT::LCStrVec &);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::LCStrVec> &);

   std::ostream& operator<<( std::ostream& out, const EVENT::LCStrVec &);

 */


   const std::string& header( const EVENT::ParticleID *);

   const std::string& tail( const EVENT::ParticleID *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::ParticleID> &);


   const std::string& header( const EVENT::RawCalorimeterHit *);

   const std::string& tail( const EVENT::RawCalorimeterHit *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::RawCalorimeterHit> &);


 //  const std::string& header( const EVENT::TPCHit &);

 //  const std::string& tail( const EVENT::TPCHit &);

 //  std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::TPCHit> &);

 //  std::ostream& operator<<( std::ostream& out, const EVENT::TPCHit &);


   const std::string& header( const EVENT::TrackerData *);

   const std::string& tail( const EVENT::TrackerData *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::TrackerData> &);


   const std::string& header( const EVENT::TrackerPulse *);

   const std::string& tail( const EVENT::TrackerPulse *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::TrackerPulse> &);


   const std::string& header( const EVENT::TrackerRawData *);

   const std::string& tail( const EVENT::TrackerRawData *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::TrackerRawData> &);


   const std::string& header( const EVENT::LCIO *);

   const std::string& tail( const EVENT::LCIO *);

   std::ostream& operator<<( std::ostream& out, const UTIL::lcio_short<EVENT::LCIO> &);


 /*

   template <class T>

   std::ostream& operator<<( std::ostream& out, const T obj) {

     out << lcio_long<T>( obj , NULL ) ;

     return out;

   }

 */


   template <class T>

   std::string toString(const T* obj) {

     std::stringstream ss ;

     ss << *obj ;

     return ss.str() ;

   }


 }//namespace


 // rete, 2019: Move stream operator overloads of EVENT

 // objects in namespace EVENT, where they should be ...

 // see: https://stackoverflow.com/questions/3623631/where-should-non-member-operator-overloads-be-placed

 namespace EVENT {


   std::ostream& operator<<( std::ostream& out, const EVENT::Vertex &v);

   std::ostream& operator<<( std::ostream& out, const EVENT::MCParticle &);

   std::ostream& operator<<( std::ostream& out, const EVENT::TrackerHit &);

   std::ostream& operator<<( std::ostream& out, const EVENT::TrackerHitPlane &);

   std::ostream& operator<<( std::ostream& out, const EVENT::TrackerHitZCylinder &);

   std::ostream& operator<<( std::ostream& out, const EVENT::SimTrackerHit &);

   std::ostream& operator<<( std::ostream& out, const EVENT::CalorimeterHit &);

   std::ostream& operator<<( std::ostream& out, const EVENT::ReconstructedParticle &);

   std::ostream& operator<<( std::ostream& out, const EVENT::SimCalorimeterHit &);

   std::ostream& operator<<( std::ostream& out, const EVENT::Track &);

   std::ostream& operator<<( std::ostream& out, const EVENT::TrackState &);

   std::ostream& operator<<( std::ostream& out, const EVENT::Cluster &);

   std::ostream& operator<<( std::ostream& out, const EVENT::LCRelation &);

   std::ostream& operator<<( std::ostream& out, const EVENT::LCFloatVec &);

   std::ostream& operator<<( std::ostream& out, const EVENT::LCCollection &);

   std::ostream& operator<<( std::ostream& out, const EVENT::LCEvent &);

   std::ostream& operator<<( std::ostream& out, const EVENT::LCFlag &);

   std::ostream& operator<<( std::ostream& out, const EVENT::LCGenericObject &);

   std::ostream& operator<<( std::ostream& out, const EVENT::LCIntVec &);

   std::ostream& operator<<( std::ostream& out, const EVENT::LCObject &);

   std::ostream& operator<<( std::ostream& out, const EVENT::LCParameters &);

   std::ostream& operator<<( std::ostream& out, const EVENT::LCRunHeader &);

   std::ostream& operator<<( std::ostream& out, const EVENT::ParticleID &);

   std::ostream& operator<<( std::ostream& out, const EVENT::RawCalorimeterHit &);

   std::ostream& operator<<( std::ostream& out, const EVENT::TrackerData &);

   std::ostream& operator<<( std::ostream& out, const EVENT::TrackerPulse &);

   std::ostream& operator<<( std::ostream& out, const EVENT::TrackerRawData &);

   std::ostream& operator<<( std::ostream& out, const EVENT::LCIO &);

 }


 #endif /* ifndef LCIO_OPERATORS_H */

EVENT::LCObject
The generic object that is held in an LCCollection.
Definition: LCObject.h:30

UTIL::lcio_short::lcio_short
lcio_short(const T *t, const EVENT::LCCollection *b=NULL)
Definition: Operators.h:68

UTIL::header
const std::string & header(const EVENT::Vertex *)
operator for detailed output of a vertex object (e.g.
Definition: Operators.cc:2756

EVENT::TrackerHit
A generic tracker hit to be used by pattern recognition.
Definition: TrackerHit.h:26

UTIL::LCIO_LONG::LCIO_LONG
LCIO_LONG(const T &o, const EVENT::LCCollection *c)
Definition: Operators.h:165

EVENT::SimCalorimeterHit
The generic simulated calorimeter hit.
Definition: SimCalorimeterHit.h:23

UTIL::LCIO_LONG
Definition: Operators.h:160

EVENT::Vertex
The Vertex class for LCIO.
Definition: Vertex.h:34

UTIL::toString
std::string toString(const T *obj)
Definition: Operators.h:288

RawCalorimeterHit.h

LCObject.h

ReconstructedParticle.h

EVENT::LCRunHeader
Interface for the run header.
Definition: LCRunHeader.h:23

UTIL::lcshort
lcio_short< T > lcshort(const T *t, const EVENT::LCCollection *b=NULL)
Definition: Operators.h:74

UTIL::lcio_short::col
const EVENT::LCCollection * col
Definition: Operators.h:67

UTIL::LCIO_LONG::operator=
LCIO_LONG & operator=(const LCIO_LONG &)=default

UTIL::lcio_short
Definition: Operators.h:64

iomanip

TrackerPulse.h

EVENT::TrackerHitPlane
A tracker hit on a planar surface - the hit is stored as:  x,y,z, u(theta, phi), v(theta,phi), du, dv   where (x,y,z) is the position in global cartesian coordinates, u,v are the the meassurement directions (unit vectors, spanning the plane) and du,dv are the measurement errors along these directions.
Definition: TrackerHitPlane.h:30

EVENT::SimTrackerHit
A generic simulated tracker hit.
Definition: SimTrackerHit.h:23

EVENT::TrackState
The LCIO TrackState class.
Definition: TrackState.h:26

UTIL::LCIO_LONG::obj
const T * obj
Definition: Operators.h:169

iostream

MCParticle.h

EVENT::TrackerData
TrackerData contains the corrected (calibrated) raw tracker data.
Definition: TrackerData.h:23

SimTrackerHit.h

LCIntVec.h

LCRelation.h

std::stringstream
STL class.

TrackerHit.h

std::string
STL class.

UTIL::LCIO_LONG::collection
const EVENT::LCCollection * collection(void) const
Definition: Operators.h:167

EVENT::TrackerPulse
Tracker pulses as computed from TrackerData objects or as directly measured by a specific subdetector...
Definition: TrackerPulse.h:26

LCGenericObject.h

EVENT::operator<<
std::ostream & operator<<(std::ostream &out, const EVENT::Vertex &v)
Definition: Operators.cc:2980

TrackerHitPlane.h

LCParameters.h

EVENT::LCParameters
Simple interface to store generic named parameters of type int, float and string. ...
Definition: LCParameters.h:28

UTIL::LCIO_LONG::object
const T * object(void) const
Definition: Operators.h:166

EVENT::Cluster
The LCIO cluster.
Definition: Cluster.h:30

EVENT::Track
The LCIO track class.
Definition: Track.h:33

LCCollection.h

std::stringstream::str
T str(T...args)

EVENT::LCIntVec
Int vector used for user extensions.
Definition: LCIntVec.h:24

sstream

EVENT::LCFloatVec
Float vector used for user extensions.
Definition: LCFloatVec.h:25

EVENT::LCGenericObject
Simple interface to store generic user data.
Definition: LCGenericObject.h:27

UTIL::LCIO_LONG::LCIO_LONG
LCIO_LONG()=default

string

ParticleID.h

UTIL::LCIO_LONG::col
const EVENT::LCCollection * col
Definition: Operators.h:170

Cluster.h

Vertex.h

TrackState.h

EVENT::ReconstructedParticle
The LCIO reconstructedParticle.
Definition: ReconstructedParticle.h:35

EVENT::MCParticle
The LCIO Monte Carlo particle.
Definition: MCParticle.h:27

EVENT::ParticleID
Persistent interface for LCIO ParticleIDs.
Definition: ParticleID.h:28

EVENT::LCRelation
A single weighted relationship between two LCObjects.
Definition: LCRelation.h:29

UTIL::tail
const std::string & tail(const EVENT::Vertex *)
Definition: Operators.cc:2761

EVENT::RawCalorimeterHit
The generic calorimeter hit for real data (or simulation thereof).
Definition: RawCalorimeterHit.h:31

UTIL::lcio_long
LCIO_LONG< T > lcio_long(const T &o, const EVENT::LCCollection *c)
Definition: Operators.h:175

EVENT::LCEvent
The main event interface.
Definition: LCEvent.h:31

EVENT::TrackerRawData
Generic class for raw tracker data.
Definition: TrackerRawData.h:24

EVENT::LCCollection
The generic collection used in LCIO.
Definition: LCCollection.h:29

EVENT::TrackerHitZCylinder
A tracker hit on a cylindrical surface that runs parallel to the z-axis - the hit is stored as:  x...
Definition: TrackerHitZCylinder.h:28

LCEvent.h

UTIL::lcio_short::obj
const T * obj
Definition: Operators.h:66

CalorimeterHit.h

SimCalorimeterHit.h

LCFlag.h

EVENT::LCFlag
Helper class to create and interpret the 32-bit flag word in LCCollections.
Definition: LCFlag.h:19

LCRunHeader.h

TrackerHitZCylinder.h

EVENT::CalorimeterHit
The generic calorimeter hit - created from SimCalorimeterHit or RawCalorimeterHit.
Definition: CalorimeterHit.h:34

Track.h

std::ostream
STL class.

TrackerData.h

TrackerRawData.h

LCFloatVec.h