TypeVisitor.cxx

Go to the documentation of this file.

#include "AtlfastEvent/TypeVisitor.h"

#include "AtlfastEvent/ReconstructedParticle.h" 
#include "AtlfastEvent/Cell.h"
#include "AtlfastEvent/TwoCptCell.h"
#include "AtlfastEvent/Cluster.h"
#include "AtlfastEvent/KtCluster.h"
#include "AtlfastEvent/Jet.h"
#include "AtlfastEvent/SimpleKinematic.h"
#include "AtlfastEvent/Track.h"

#include <iostream>

namespace Atlfast{
  void TypeVisitor::reset() {
    m_cells.clear() ;
    m_twoCptCells.clear() ;
    m_clusters.clear() ;
    m_jets.clear() ;
    m_reconstructedParticles.clear() ;
    m_simpleKinematics.clear() ;
    m_tracks.clear() ;
    m_iKinematics.clear() ;
  }
    
  void TypeVisitor::operator()(const IAOO* iaoo){iaoo->accept(this);}
  
  void TypeVisitor::process(const Cell* t){
    m_cells.push_back(t);
  }
  void TypeVisitor::process(const Cluster* t){m_clusters.push_back(t);}
  void TypeVisitor::process(const KtCluster* t){m_ktClusters.push_back(t);}
  void TypeVisitor::process(const Jet* t){m_jets.push_back(t);}

  void TypeVisitor::process(const ReconstructedParticle* t){
    m_reconstructedParticles.push_back(t);
  }

  void TypeVisitor::process(const SimpleKinematic* t){
    m_simpleKinematics.push_back(t);
  }

  void TypeVisitor::process(const Track* t){m_tracks.push_back(t);}

  void TypeVisitor::process(const TwoCptCell* t){
    m_twoCptCells.push_back(t);
  }

  vector<const Cell*>       TypeVisitor::typeVector( const Cell&)      const {
    return m_cells ;
  } 
  vector<const TwoCptCell*> TypeVisitor::typeVector(const TwoCptCell&) const {
    return m_twoCptCells ;
  }
  vector<const Cluster*>    TypeVisitor::typeVector( const Cluster&)   const {
    return m_clusters ;
  }
  vector<const KtCluster*>    TypeVisitor::typeVector( const KtCluster&)   const {
    return m_ktClusters ;
  }
  vector<const Jet*>        TypeVisitor::typeVector( const Jet&)       const {
    return m_jets ;
  }
  vector<const SimpleKinematic*> 
                TypeVisitor::typeVector( const SimpleKinematic&)       const {
    return m_simpleKinematics ;
  }
  vector<const Track*>      TypeVisitor::typeVector( const Track& )    const {
    return m_tracks ;
  }
  vector<const ReconstructedParticle*> 
            TypeVisitor::typeVector( const ReconstructedParticle&)     const {
    return m_reconstructedParticles ;
  }
  std::vector<const IKinematic*> TypeVisitor::ikinematics() const {
    
    std::vector<const IKinematic*> iKinematics;
    std::copy(
              m_cells.begin(),             
              m_cells.end(),   
              back_inserter(iKinematics)
              );

    std::copy(
              m_twoCptCells.begin(), 
              m_twoCptCells.end(),   
              back_inserter(iKinematics)
              );
    
    std::copy(
              m_clusters.begin(),       
              m_clusters.end(),   
              back_inserter(iKinematics)
              );
    std::copy(
              m_jets.begin(),               
              m_jets.end(),   
              back_inserter(iKinematics)
              );
    std::copy(
              m_reconstructedParticles.begin(), 
              m_reconstructedParticles.end(), 
              back_inserter(iKinematics)
              );
    std::copy(
              m_simpleKinematics.begin(), 
              m_simpleKinematics.end(), 
              back_inserter(iKinematics)
              );
    
    std::copy(
              m_tracks.begin(), 
              m_tracks.end(), 
              back_inserter(iKinematics)
              );
    
    return iKinematics;
  }


  std::vector<const I4Momentum*> TypeVisitor::i4momenta() const {    

    std::vector<const I4Momentum*> i4s;
    std::copy(
              m_cells.begin(),             
              m_cells.end(),   
              back_inserter(i4s)
              );

    std::copy(
              m_twoCptCells.begin(), 
              m_twoCptCells.end(),   
              back_inserter(i4s)
              );
    
    std::copy(
              m_clusters.begin(),       
              m_clusters.end(),   
              back_inserter(i4s)
              );
    std::copy(
              m_jets.begin(),               
              m_jets.end(),   
              back_inserter(i4s)
              );
    std::copy(
              m_reconstructedParticles.begin(), 
              m_reconstructedParticles.end(), 
              back_inserter(i4s)
              );
    std::copy(
              m_simpleKinematics.begin(), 
              m_simpleKinematics.end(), 
              back_inserter(i4s)
              );
    
    std::copy(
              m_tracks.begin(), 
              m_tracks.end(), 
              back_inserter(i4s)
              );
    
    return i4s;
  }
}//namespace;

---