FilterEventsUpsilon/src/FilterEventsUpsilon.cc

0001
0002 #include "FilterEventsUpsilon.h"
0003
0004 #include <cstdlib>
0005 #include <cstdio>
0006 #include <iostream>
0007 #include <iomanip>
0008 #include <fstream>
0009
0010 #include <TFile.h>
0011
0012 #include <trackbase_historic/SvtxTrack.h>
0013 #include <trackbase_historic/SvtxTrackMap.h>
0014 #include <trackbase_historic/SvtxTrackMap_v2.h>
0015 #include <trackbase_historic/SvtxVertex.h>
0016 #include <trackbase_historic/SvtxVertexMap.h>
0017 #include <trackbase_historic/TrackSeed.h>
0018 #include <trackbase_historic/TrackSeed_v1.h>
0019 #include <trackbase_historic/SvtxTrackSeed_v1.h>
0020 #include <trackbase_historic/TrackSeedContainer.h>
0021 #include <trackbase/TrkrDefs.h>
0022 #include <trackbase/TrkrCluster.h>
0023 #include <trackbase/TrkrClusterv4.h>
0024 #include <trackbase/TrkrClusterContainer.h>
0025 #include <g4vertex/GlobalVertexMap.h>
0026 #include <g4vertex/GlobalVertex.h>
0027 #include <calobase/RawClusterContainer.h>
0028 #include <calobase/RawCluster.h>
0029 #include <calobase/RawClusterv1.h>
0030
0031 #include <phool/getClass.h>
0032 #include <phool/recoConsts.h>
0033 #include <phool/PHCompositeNode.h>
0034 #include <phool/PHIODataNode.h>
0035 #include <phool/PHNodeIterator.h>
0036 #include <phool/PHRandomSeed.h>
0037 #include <fun4all/Fun4AllReturnCodes.h>
0038
0039 typedef PHIODataNode<PHObject> PHObjectNode_t;
0040
0041 using namespace std;
0042
0043 //==============================================================
0044
0045 FilterEventsUpsilon::FilterEventsUpsilon(const std::string &name) : SubsysReco(name)
0046 {
0047   outnodename_trackmap = "SvtxTrackMap_ee";
0048   outnodename_cemc_clusters = "CLUSTER_CEMC_ee";
0049   EventNumber=0;
0050   goodEventNumber=0;
0051 }
0052
0053 //-------------------------------------------------------------------------------
0054
0055 int FilterEventsUpsilon::Init(PHCompositeNode *topNode)
0056 {
0057
0058 cout << "FilterEventsUpsilon::Init started..." << endl;
0059
0060   PHNodeIterator iter(topNode);
0061   //PHCompositeNode *dstNode = dynamic_cast<PHCompositeNode *>(iter.findFirst("PHCompositeNode", "DST"));
0062   PHCompositeNode *dstNode = static_cast<PHCompositeNode *>(iter.findFirst("PHCompositeNode", "DST"));
0063   if (!dstNode) { cerr << PHWHERE << " ERROR: DST node not found." << endl; return Fun4AllReturnCodes::ABORTEVENT; }
0064
0065 //  PHNodeIterator dstiter(dstNode);
0066 //  PHCompositeNode *svtxNode = dynamic_cast<PHCompositeNode *>(dstiter.findFirst("PHCompositeNode", "SVTX"));
0067 //  if (!svtxNode) { cerr << PHWHERE << " ERROR: SVTX node not found." << endl; return Fun4AllReturnCodes::ABORTEVENT; }
0068 //
0069 //  PHCompositeNode *cemcNode = dynamic_cast<PHCompositeNode *>(dstiter.findFirst("PHCompositeNode", "CEMC"));
0070 //  if (!cemcNode) { cerr << PHWHERE << " ERROR: CEMC node not found." << endl; return Fun4AllReturnCodes::ABORTEVENT; }
0071
0072   SvtxTrackMap_v2* trackmap = new SvtxTrackMap_v2();
0073   PHCompositeNode *trackmapNode = dynamic_cast<PHCompositeNode *>(iter.findFirst("PHCompositeNode", outnodename_trackmap));
0074   if (!trackmapNode)
0075   {
0076     PHObjectNode_t *trackmapNode = new PHIODataNode<PHObject>(trackmap,outnodename_trackmap.c_str(),"PHObject");
0077       dstNode->addNode(trackmapNode);
0078     //svtxNode->addNode(trackmapNode);
0079     cout << PHWHERE << " INFO: added " << outnodename_trackmap << " node." << endl;
0080   }
0081   else { cout << PHWHERE << " INFO: " << outnodename_trackmap << " node already exists." << endl; }
0082
0083   _cemc_clusters_ee = new RawClusterContainer();
0084   PHIODataNode<PHObject> *clusterNode = new PHIODataNode<PHObject>(_cemc_clusters_ee, outnodename_cemc_clusters, "PHObject");
0085   dstNode->addNode(clusterNode);
0086   //cemcNode->addNode(clusterNode);
0087
0088 //  PHCompositeNode *cemcclusNode = dynamic_cast<PHCompositeNode *>(iter.findFirst("PHCompositeNode", outnodename_cemc_clusters));
0089 //  if (!cemcclusNode)
0090 //  {
0091 //    PHObjectNode_t *cemcclusNode = new PHIODataNode<PHObject>(cemc_clusters,outnodename_cemc_clusters.c_str(),"PHObject");
0092 //    dstNode->addNode(cemcclusNode);
0093 //    cout << PHWHERE << " INFO: added " << outnodename_cemc_clusters << " node." << endl;
0094 //  }
0095 //  else { cout << PHWHERE << " INFO: " << outnodename_cemc_clusters << " node already exists." << endl; }
0096
0097 cout << "FilterEventsUpsilon::Init ended." << endl;
0098   return Fun4AllReturnCodes::EVENT_OK;
0099 }
0100
0101 //--------------------------------------------------------------------------------
0102
0103 int FilterEventsUpsilon::InitRun(PHCompositeNode *topNode)
0104 {
0105   return Fun4AllReturnCodes::EVENT_OK;
0106 }
0107
0108 //--------------------------------------------------------------------------------
0109
0110 int FilterEventsUpsilon::GetNodes(PHCompositeNode *topNode)
0111 {
0112
0113   _topNode = topNode;
0114
0115   //topNode->print();
0116
0117   _trackmap_ee = findNode::getClass<SvtxTrackMap>(topNode, outnodename_trackmap);
0118   if(!_trackmap_ee) { cerr << PHWHERE << "ERROR: Output SvtxTrackMap_ee node not found." << endl; return Fun4AllReturnCodes::ABORTEVENT; }
0119 //    else {cout << "Found SvtxTrackMap_ee node." << endl; }
0120
0121   _cemc_clusters_ee = findNode::getClass<RawClusterContainer>(topNode, outnodename_cemc_clusters);
0122   if(!_cemc_clusters_ee) { cerr << PHWHERE << "ERROR: CLUSTER_CEMC_ee node not found." << endl; return Fun4AllReturnCodes::ABORTEVENT; }
0123 //    else {cout << "Found CLUSTER_CEMC_ee node." << endl; }
0124
0125   _trackmap = findNode::getClass<SvtxTrackMap>(topNode, "SvtxTrackMap");
0126   if(!_trackmap) { cerr << PHWHERE << "ERROR: SvtxTrackMap node not found." << endl; return Fun4AllReturnCodes::ABORTEVENT; }
0127
0128 //  _vtxmap = findNode::getClass<SvtxVertexMap>(topNode, "SvtxVertexMap");
0129 //  if(!_vtxmap) { cout << "ERROR: SvtxVertexMap node not found!" << endl; return Fun4AllReturnCodes::ABORTEVENT; }
0130
0131   _trackseedcontainer_svtx = findNode::getClass<TrackSeedContainer>(topNode, "SvtxTrackSeedContainer");
0132   if(!_trackseedcontainer_svtx) { cerr << PHWHERE << "ERROR: SvtxTrackSeedContainer node not found." << endl; return Fun4AllReturnCodes::ABORTEVENT; }
0133
0134   _trackseedcontainer_silicon = findNode::getClass<TrackSeedContainer>(topNode, "SiliconTrackSeedContainer");
0135   if(!_trackseedcontainer_silicon) { cerr << PHWHERE << "ERROR: SiliconTrackSeedContainer node not found." << endl; return Fun4AllReturnCodes::ABORTEVENT; }
0136
0137   _trackseedcontainer_tpc = findNode::getClass<TrackSeedContainer>(topNode, "TpcTrackSeedContainer");
0138   if(!_trackseedcontainer_tpc) { cerr << PHWHERE << "ERROR: TpcTrackSeedContainer node not found." << endl; return Fun4AllReturnCodes::ABORTEVENT; }
0139
0140   _trkrclusters  = findNode::getClass<TrkrClusterContainer>(topNode, "TRKR_CLUSTER");
0141   if(!_trkrclusters) { cerr << PHWHERE << "ERROR: TRKR_CLUSTER node not found." << endl; return Fun4AllReturnCodes::ABORTEVENT; }
0142
0143   _cemc_clusters = findNode::getClass<RawClusterContainer>(topNode, "CLUSTER_CEMC");
0144   if(!_cemc_clusters) { cerr << PHWHERE << "ERROR: CLUSTER_CEMC node not found." << endl; return Fun4AllReturnCodes::ABORTEVENT; }
0145
0146   return Fun4AllReturnCodes::EVENT_OK;
0147 }
0148
0149 //--------------------------------------------------------------------
0150
0151 TVector3 FilterEventsUpsilon::GetProjectionCEMC(SvtxTrack* track) {
0152
0153   TVector3 projection; // 0,0,0
0154
0155   vector<double> proj;
0156   for (SvtxTrack::StateIter stateiter = track->begin_states(); stateiter != track->end_states(); ++stateiter)
0157   {
0158     SvtxTrackState *trackstate = stateiter->second;
0159     if(trackstate) { proj.push_back(trackstate->get_pathlength()); }
0160   }
0161   double pathlength = proj[proj.size()-3]; // CEMC is next next to last, usually 93.5
0162
0163   SvtxTrackState* trackstate = track->get_state(pathlength); // at CEMC inner face
0164   if(trackstate) {
0165     double track_x = trackstate->get_x();
0166     double track_y = trackstate->get_y();
0167     double track_z = trackstate->get_z();
0168     projection.SetX(track_x);
0169     projection.SetY(track_y);
0170     projection.SetZ(track_z);
0171   }
0172
0173   return projection;
0174 }
0175
0176 //--------------------------------------------------------------------
0177
0178 RawCluster* FilterEventsUpsilon::MatchClusterCEMC(SvtxTrack* track, RawClusterContainer* cemc_clusters, double &dphi, double &deta, double Zvtx) {
0179
0180   RawCluster* returnCluster = NULL;
0181   double track_eta = 99999.;
0182   double track_phi = 99999.;
0183   dphi = 99999.;
0184   deta = 99999.;
0185
0186   vector<double> proj;
0187   for (SvtxTrack::StateIter stateiter = track->begin_states(); stateiter != track->end_states(); ++stateiter)
0188   {
0189     SvtxTrackState *trackstate = stateiter->second;
0190     if(trackstate) { proj.push_back(trackstate->get_pathlength()); }
0191   }
0192   double pathlength = proj[proj.size()-3]; // CEMC is next next to last
0193
0194   SvtxTrackState* trackstate = track->get_state(pathlength); // at CEMC inner face
0195   if(trackstate) {
0196     double track_x = trackstate->get_x();
0197     double track_y = trackstate->get_y();
0198     double track_z = trackstate->get_z() - Zvtx;
0199     double track_r = sqrt(track_x*track_x+track_y*track_y);
0200     track_eta = asinh( track_z / track_r );
0201     track_phi = atan2( track_y, track_x );
0202   } else { return returnCluster; }
0203
0204   if(track_eta == 99999. || track_phi == 99999.) { return returnCluster; }
0205   double dist = 99999.;
0206
0207     RawClusterContainer::Range begin_end = cemc_clusters->getClusters();
0208     RawClusterContainer::Iterator iter;
0209     for (iter = begin_end.first; iter != begin_end.second; ++iter)
0210     {
0211       RawCluster* cluster = iter->second;
0212       if(!cluster) continue;
0213       else {
0214         double cemc_ecore = cluster->get_ecore();
0215         if(cemc_ecore<1.0) continue;
0216         double cemc_x = cluster->get_x();
0217         double cemc_y = cluster->get_y();
0218         double cemc_z = cluster->get_z() - Zvtx;
0219         double cemc_r = cluster->get_r();
0220         double cemc_eta = asinh( cemc_z / cemc_r );
0221         double cemc_phi = atan2( cemc_y, cemc_x );
0222         double tmpdist = sqrt(pow((cemc_eta-track_eta),2)+pow((cemc_phi-track_phi),2));
0223         if(tmpdist<dist) {
0224           dist = tmpdist; returnCluster = cluster; dphi = fabs(cemc_phi-track_phi); deta = fabs(cemc_eta-track_eta);
0225         }
0226       }
0227     }
0228
0229   return returnCluster;
0230 }
0231
0232 //--------------------------------------------------------------------------------
0233
0234 int FilterEventsUpsilon::process_event(PHCompositeNode *topNode) {
0235
0236   EventNumber++;
0237   int ngood = 0;
0238   bool goodevent = false;
0239
0240 cout << "getting nodes..." << endl;
0241   GetNodes(topNode);
0242
0243   GlobalVertexMap* _global_vtxmap = findNode::getClass<GlobalVertexMap>(topNode, "GlobalVertexMap");
0244   if(!_global_vtxmap) { cerr << PHWHERE << "ERROR: GlobalVertexMap node not found." << endl; return Fun4AllReturnCodes::ABORTEVENT; }
0245
0246   double Zvtx = 0.;
0247   for (GlobalVertexMap::Iter iter = _global_vtxmap->begin(); iter != _global_vtxmap->end(); ++iter)
0248   {
0249     GlobalVertex *vtx = iter->second;
0250     if(vtx->get_id()==1) { Zvtx = vtx->get_z(); } // BBC vertex
0251   }
0252   cout << "Global BBC vertex Z = " << Zvtx << endl;
0253
0254   std::vector<RawCluster *> goodclusters;
0255   std::vector<TrkrCluster*> vclussilicon;
0256   std::vector<TrkrCluster*> vclustpc;
0257   std::vector<TrkrDefs::cluskey> vcluskeysilicon;
0258   std::vector<TrkrDefs::cluskey> vcluskeytpc;
0259   std::vector<SvtxTrackSeed_v1*> v_svtx_trackseed;
0260   std::vector<TrackSeed*> v_silicon_trackseed;
0261   std::vector<TrackSeed*> v_tpc_trackseed;
0262
0263   cout << "Total number of tracks = " << _trackmap->size() << endl;
0264   cout << "Total number of CEMC clusters = " << _cemc_clusters->size() << endl;
0265   cout << "Total number of svtx track seeds: " << _trackseedcontainer_svtx->size() << endl;
0266   cout << "Total number of silicon track seeds: " << _trackseedcontainer_silicon->size() << endl;
0267   cout << "Total number of tpc track seeds: " << _trackseedcontainer_tpc->size() << endl;
0268   cout << "Total number of TRKR clusters: " << _trkrclusters->size() << endl;
0269
0270 // Start loop over tracks;
0271   for (SvtxTrackMap::Iter iter = _trackmap->begin(); iter != _trackmap->end(); ++iter)
0272   {
0273     SvtxTrack *track = iter->second;
0274
0275     double px = track->get_px();
0276     double py = track->get_py();
0277     double pz = track->get_pz();
0278     double pt = sqrt(px * px + py * py);
0279       if(pt<2.0) continue;
0280     double mom = sqrt(px * px + py * py + pz * pz);
0281
0282     double cemc_dphi = 99999.;
0283     double cemc_deta = 99999.;
0284     RawCluster* clus = MatchClusterCEMC(track, _cemc_clusters, cemc_dphi, cemc_deta, Zvtx);
0285       if(!clus) continue;
0286     double cemc_ecore = clus->get_ecore();
0287       if(cemc_ecore/mom < 0.7) continue;
0288
0289     ngood++;
0290     goodevent = true;
0291     SvtxTrack* tmp =_trackmap_ee->insert(track);
0292     if(!tmp) cout << "ERROR: Failed to insert a track." << endl;
0293
0294     cout << " Track: " << pt << endl;
0295
0296     TrackSeed* trackseed_silicon = track->get_silicon_seed();
0297     double trackseed_silicon_pt = trackseed_silicon->get_pt();
0298     cout << "   Silicon seed: " << trackseed_silicon << " " << trackseed_silicon_pt << " " << trackseed_silicon->size_cluster_keys() << endl;
0299     TrackSeed_v1* tmpseedsilicon = (TrackSeed_v1*)trackseed_silicon->CloneMe();
0300     v_silicon_trackseed.push_back(tmpseedsilicon);
0301
0302     TrackSeed* trackseed_tpc = track->get_tpc_seed();
0303     double trackseed_tpc_pt = trackseed_tpc->get_pt();
0304     cout << "   TPC seed: " << trackseed_tpc << " "  << trackseed_tpc_pt << " " << trackseed_tpc->size_cluster_keys() << endl;
0305     TrackSeed_v1* tmpseedtpc = (TrackSeed_v1*)trackseed_tpc->CloneMe();
0306     v_tpc_trackseed.push_back(tmpseedtpc);
0307
0308 // Find SVTX seed for this track
0309     for(TrackSeedContainer::ConstIter seediter = _trackseedcontainer_svtx->begin(); seediter != _trackseedcontainer_svtx->end(); ++seediter)
0310     {
0311       SvtxTrackSeed_v1* seed = (SvtxTrackSeed_v1*)*seediter;
0312       //TrackSeed* seed = *seediter;
0313       bool foundsiliconseed = false;
0314       bool foundtpcseed = false;
0315       unsigned int siliconid = seed->get_silicon_seed_index();
0316       unsigned int tpcid = seed->get_tpc_seed_index();
0317       //cout << "   SVTX seed: " << seed << " " << siliconid << " " << tpcid << endl;
0318       TrackSeed* tmptpcseed  = _trackseedcontainer_tpc->get(tpcid);
0319       double tmptpcseed_pt = tmptpcseed->get_pt();
0320       TrackSeed* tmpsiliconseed  = _trackseedcontainer_silicon->get(siliconid);
0321       double tmpsiliconseed_pt = tmpsiliconseed->get_pt();
0322       if(tmpsiliconseed_pt == trackseed_silicon_pt) {foundsiliconseed = true; cout << "   Found silicon seed " << tmpsiliconseed << endl;}
0323       if(tmptpcseed_pt == trackseed_tpc_pt) {foundtpcseed = true; cout << "   Found tpc seed " << tmptpcseed << endl;}
0324       if(foundsiliconseed && foundtpcseed) {
0325         cout << "     THIS IS THE ONE: " << seed << " " << siliconid << " " << tpcid << endl;
0326         SvtxTrackSeed_v1* tmpseed = (SvtxTrackSeed_v1*)seed->CloneMe();
0327         v_svtx_trackseed.push_back(tmpseed);
0328       }
0329     }
0330
0331 // Find all TRKR clusters for this track
0332     for(auto clusiter = trackseed_tpc->begin_cluster_keys(); clusiter != trackseed_tpc->end_cluster_keys(); ++clusiter)
0333     {
0334       //auto key = *clusiter;
0335       TrkrDefs::cluskey key = *clusiter;
0336       TrkrCluster* clus = _trkrclusters->findCluster(key);
0337       bool isinserted = false;
0338       for(unsigned int i=0; i<vclustpc.size(); i++) {if(clus==vclustpc[i]) {isinserted=true; break;}}
0339       if(!isinserted) {TrkrCluster* newclus = (TrkrClusterv4*)clus->CloneMe(); vclustpc.push_back(newclus); vcluskeytpc.push_back(key);}
0340     }
0341     for(auto clusiter = trackseed_silicon->begin_cluster_keys(); clusiter != trackseed_silicon->end_cluster_keys(); ++clusiter)
0342     {
0343       //auto key = *clusiter;
0344       TrkrDefs::cluskey key = *clusiter;
0345       TrkrCluster* clus = _trkrclusters->findCluster(key);
0346       bool isinserted = false;
0347       for(unsigned int i=0; i<vclussilicon.size(); i++) {if(clus==vclussilicon[i]) {isinserted=true; break;}}
0348       if(!isinserted) {TrkrCluster* newclus = (TrkrClusterv4*)clus->CloneMe(); vclussilicon.push_back(newclus); vcluskeysilicon.push_back(key);}
0349     }
0350
0351     TVector3 proj = GetProjectionCEMC(track);
0352     double track_x = proj(0);
0353     double track_y = proj(1);
0354     double track_z = proj(2) - Zvtx;
0355     double track_r = sqrt(track_x*track_x+track_y*track_y);
0356     double track_eta = asinh( track_z / track_r );
0357     double track_phi = atan2( track_y, track_x );
0358
0359 // Find all CEMC clusters around this track projection
0360       RawClusterContainer::Range begin_end = _cemc_clusters->getClusters();
0361       RawClusterContainer::Iterator clusiter;
0362       for (clusiter = begin_end.first; clusiter != begin_end.second; ++clusiter)
0363       {
0364         RawCluster* cluster = clusiter->second;
0365         if(!cluster) { cout << "ERROR: bad cluster pointer = " << cluster << endl; continue; }
0366         else {
0367           double cemc_ecore = cluster->get_ecore();
0368           if(cemc_ecore<1.0) continue;
0369           double cemc_x = cluster->get_x();
0370           double cemc_y = cluster->get_y();
0371           double cemc_z = cluster->get_z() - Zvtx;
0372           double cemc_r = cluster->get_r();
0373           double cemc_eta = asinh( cemc_z / cemc_r );
0374           double cemc_phi = atan2( cemc_y, cemc_x );
0375           double dist = sqrt(pow(cemc_phi-track_phi,2)+pow(cemc_eta-track_eta,2));
0376           if(dist<0.1) {
0377             bool isinserted = false;
0378             for(unsigned int i=0; i<goodclusters.size(); i++) {if(cluster==goodclusters[i]) {isinserted=true; break;}}
0379             if(!isinserted) {RawCluster* newcluster = (RawClusterv1*)cluster->CloneMe(); goodclusters.push_back(newcluster);}
0380           }
0381         }
0382       } // end loop over cemc clusters
0383
0384   } // end loop over tracks
0385
0386   cout << "   Number of CEMC clusters for output = " << goodclusters.size() << endl;
0387   cout << "   Number of svtx seeds for output = " << v_svtx_trackseed.size() << endl;
0388   cout << "   Number of tpc seeds for output = " << v_tpc_trackseed.size() << endl;
0389   cout << "   Number of silicon seeds for output = " << v_silicon_trackseed.size() << endl;
0390
0391 // Fill in selected CEMC clusters
0392   _cemc_clusters->Reset();
0393   for (unsigned int cl = 0; cl < goodclusters.size(); cl++) { _cemc_clusters->AddCluster(goodclusters[cl]); }
0394
0395
0396   cout << "   Number of TRKR clusters for output: " << vclussilicon.size() << " " << vclustpc.size() << endl;
0397   cout << "   Number of TRKR cluster keys for output: " << vcluskeysilicon.size() << " " << vcluskeytpc.size() << endl;
0398   _trkrclusters->Reset();
0399   for(unsigned int cl = 0; cl < vclussilicon.size(); cl++)
0400      { _trkrclusters->addClusterSpecifyKey(vcluskeysilicon[cl], vclussilicon[cl]); }
0401   for(unsigned int cl = 0; cl < vclustpc.size(); cl++)
0402      { _trkrclusters->addClusterSpecifyKey(vcluskeytpc[cl], vclustpc[cl]); }
0403   cout << "   New TRKR_CLUSTER size = " << _trkrclusters->size() << endl;
0404
0405
0406   _trackseedcontainer_svtx->Reset();
0407   for(unsigned int cl = 0; cl < v_svtx_trackseed.size(); cl++)
0408     { _trackseedcontainer_svtx->insert(v_svtx_trackseed[cl]); }
0409
0410 /*
0411   _trackseedcontainer_silicon->Reset();
0412   for(unsigned int cl = 0; cl < v_silicon_trackseed.size(); cl++)
0413     { _trackseedcontainer_silicon->insert(v_silicon_trackseed[cl]); }
0414   _trackseedcontainer_tpc->Reset();
0415   for(unsigned int cl = 0; cl < v_tpc_trackseed.size(); cl++)
0416     { _trackseedcontainer_tpc->insert(v_tpc_trackseed[cl]); }
0417 */
0418
0419   cout << "      New numbers of seeds = " << _trackseedcontainer_svtx->size() << " " << _trackseedcontainer_silicon->size() << " " << _trackseedcontainer_tpc->size() << endl;
0420   if(ngood>=2) { goodEventNumber++; }
0421
0422   cout << ngood << " " << EventNumber << " " << goodEventNumber << endl;
0423   if(goodevent) {return Fun4AllReturnCodes::EVENT_OK;}  else {return Fun4AllReturnCodes::ABORTEVENT;}
0424 }
0425
0426 //---------------------------------------------------------------------------
0427
0428 int FilterEventsUpsilon::End(PHCompositeNode *topNode)
0429 {
0430   cout << "Number of scanned events = " << EventNumber << endl;
0431   cout << "Number of good events = " << goodEventNumber << endl;
0432   return Fun4AllReturnCodes::EVENT_OK;
0433 }
0434