Esempio n. 1
0
void SvtxEvaluator::fillOutputNtuples(PHCompositeNode *topNode) {

  if (verbosity > 1) cout << "SvtxEvaluator::fillOutputNtuples() entered" << endl;

  SvtxVertexEval*   vertexeval = _svtxevalstack->get_vertex_eval();
  SvtxTrackEval*     trackeval = _svtxevalstack->get_track_eval();
  SvtxClusterEval* clustereval = _svtxevalstack->get_cluster_eval();
  SvtxHitEval*         hiteval = _svtxevalstack->get_hit_eval();
  SvtxTruthEval*     trutheval = _svtxevalstack->get_truth_eval();
  
  //-----------------------
  // fill the Vertex NTuple
  //-----------------------

  if (_ntp_vertex) {
    SvtxVertexMap* vertexmap = findNode::getClass<SvtxVertexMap>(topNode,"SvtxVertexMap");
    PHG4TruthInfoContainer* truthinfo = findNode::getClass<PHG4TruthInfoContainer>(topNode,"G4TruthInfo");
    if (vertexmap && truthinfo) {
      for (SvtxVertexMap::Iter iter = vertexmap->begin();
	   iter != vertexmap->end();
	   ++iter) {
	SvtxVertex* vertex = iter->second;
	PHG4VtxPoint* point = vertexeval->max_truth_point_by_ntracks(vertex);

	float vx         = vertex->get_x();
	float vy         = vertex->get_y();
	float vz         = vertex->get_z();
	float ntracks    = vertex->size_tracks();

	float gvx        = NAN;
	float gvy        = NAN;
	float gvz        = NAN;
	float gntracks   = truthinfo->GetNumPrimaryVertexParticles();
	float nfromtruth = NAN;
	
	if (point) {
	  gvx        = point->get_x();
	  gvy        = point->get_y();
	  gvz        = point->get_z();
	  gntracks   = truthinfo->GetNumPrimaryVertexParticles();
	  nfromtruth = vertexeval->get_ntracks_contribution(vertex,point);
	}
	  
	float vertex_data[10] = {_ievent,
				 vx,
				 vy,
				 vz,
				 ntracks,
				 gvx,
				 gvy,
				 gvz,
				 gntracks,
				 nfromtruth
	};

	_ntp_vertex->Fill(vertex_data);      
      }
    }
  }
  
  //-----------------------
  // fill the gpoint NTuple
  //-----------------------

  if (_ntp_gpoint) {
    SvtxVertexMap* vertexmap = findNode::getClass<SvtxVertexMap>(topNode,"SvtxVertexMap");
    PHG4TruthInfoContainer* truthinfo = findNode::getClass<PHG4TruthInfoContainer>(topNode,"G4TruthInfo");
    if (vertexmap && truthinfo) {

      PHG4VtxPoint* point =  truthinfo->GetPrimaryVtx(truthinfo->GetPrimaryVertexIndex());
      SvtxVertex* vertex = vertexeval->best_vertex_from(point);
    
      float gvx        = point->get_x();
      float gvy        = point->get_y();
      float gvz        = point->get_z();
      float gntracks   = truthinfo->GetNumPrimaryVertexParticles();
      float vx         = NAN;
      float vy         = NAN;
      float vz         = NAN;
      float ntracks    = NAN;
      float nfromtruth = NAN;

      if (vertex) {
	vx         = vertex->get_x();
	vy         = vertex->get_y();
	vz         = vertex->get_z();
	ntracks    = vertex->size_tracks();
	nfromtruth = vertexeval->get_ntracks_contribution(vertex,point);
      }
	
      float gpoint_data[10] = {_ievent,
			       gvx,
			       gvy,
			       gvz,
			       gntracks,
			       vx,
			       vy,
			       vz,
			       ntracks,
			       nfromtruth
      };

      _ntp_gpoint->Fill(gpoint_data);      
    }
  }
  
  //---------------------
  // fill the G4hit NTuple
  //---------------------

  if (_ntp_g4hit) {
    std::set<PHG4Hit*> g4hits = trutheval->all_truth_hits();
    for (std::set<PHG4Hit*>::iterator iter = g4hits.begin();
	 iter != g4hits.end();
	 ++iter) {
            
      PHG4Hit *g4hit = *iter;
      PHG4Particle *g4particle = trutheval->get_particle(g4hit);
      
      float g4hitID   = g4hit->get_hit_id();
      float gx        = 0.5*(g4hit->get_x(0)+g4hit->get_x(1));
      float gy        = 0.5*(g4hit->get_y(0)+g4hit->get_y(1));
      float gz        = 0.5*(g4hit->get_z(0)+g4hit->get_z(1));
      float gedep     = g4hit->get_edep();
      float glayer    = g4hit->get_layer();
  
      float gtrackID  = g4hit->get_trkid();


      float gflavor   = NAN;
      float gpx       = NAN;
      float gpy       = NAN;
      float gpz       = NAN;

      float gvx       = NAN;
      float gvy       = NAN;
      float gvz       = NAN;

      float gembed  = NAN;
      float gprimary = NAN;

      float gfpx      = NULL;
      float gfpy      = NULL;
      float gfpz      = NULL;
      float gfx       = NULL;
      float gfy       = NULL;
      float gfz       = NULL;

      if (g4particle) {

	gflavor   = g4particle->get_pid();
	gpx       = g4particle->get_px();
	gpy       = g4particle->get_py();
	gpz       = g4particle->get_pz();

	PHG4VtxPoint* vtx = trutheval->get_vertex(g4particle);	

	if (vtx) {
	  gvx       = vtx->get_x();
	  gvy       = vtx->get_y();
	  gvz       = vtx->get_z();
	}
    
	PHG4Hit* outerhit = trutheval->get_outermost_truth_hit(g4particle);	
	if (outerhit) {
	  gfpx      = outerhit->get_px(1);
	  gfpy      = outerhit->get_py(1);
	  gfpz      = outerhit->get_pz(1);
	  gfx       = outerhit->get_x(1);
	  gfy       = outerhit->get_y(1);
	  gfz       = outerhit->get_z(1);
	}
	
	gembed    = trutheval->get_embed(g4particle);
	gprimary  = trutheval->is_primary(g4particle);
      } //       if (g4particle)
      
      std::set<SvtxCluster*> clusters = clustereval->all_clusters_from(g4hit);  
      float nclusters = clusters.size();

      // best cluster reco'd
      SvtxCluster* cluster = clustereval->best_cluster_from(g4hit);

      float clusID     = NAN;
      float x          = NAN;
      float y          = NAN;
      float z          = NAN;
      float e          = NAN;
      float adc        = NAN;
      float layer      = NAN;
      float size       = NAN;
      float phisize    = NAN;
      float zsize      = NAN;
      float efromtruth = NAN;

      if (cluster) {
	clusID     = cluster->get_id();
	x          = cluster->get_x();
	y          = cluster->get_y();
	z          = cluster->get_z();
	e          = cluster->get_e();
	adc        = cluster->get_adc();
	layer      = cluster->get_layer();
	size       = cluster->size_hits();
	phisize    = cluster->get_phi_size();
	zsize      = cluster->get_z_size();
	if (g4particle) {
	  efromtruth = clustereval->get_energy_contribution(cluster,g4particle);
	}
      }

      float g4hit_data[35] = {_ievent,
			      g4hitID,
			      gx,
			      gy,
			      gz,
			      gedep,
			      glayer,
			      gtrackID,
			      gflavor,
			      gpx,
			      gpy,
			      gpz,
			      gvx,
			      gvy,
			      gvz,
			      gfpx,
			      gfpy,
			      gfpz,
			      gfx,
			      gfy,
			      gfz,
			      gembed,
			      gprimary,
			      nclusters,
			      clusID,  
			      x,      
			      y,      
			      z,      
			      e,      
			      adc,    
			      layer,  
			      size,   
			      phisize,
			      zsize,  
			      efromtruth
      };

      _ntp_g4hit->Fill(g4hit_data);
    }
  }
  
  //--------------------
  // fill the Hit NTuple
  //--------------------

  if (_ntp_hit) {
    // need things off of the DST...
    SvtxHitMap* hitmap = findNode::getClass<SvtxHitMap>(topNode,"SvtxHitMap");
    if (hitmap) {

      for (SvtxHitMap::Iter iter = hitmap->begin();
	   iter != hitmap->end();
	   ++iter) {

	SvtxHit* hit             = iter->second;
	PHG4Hit* g4hit           = hiteval->max_truth_hit_by_energy(hit);
	PHG4CylinderCell* g4cell = hiteval->get_cell(hit);
	PHG4Particle* g4particle = trutheval->get_particle(g4hit);

	float event  = _ievent;
	float hitID  = hit->get_id();
	float e      = hit->get_e();
	float adc    = hit->get_adc();
	float layer  = hit->get_layer();
	float cellID = hit->get_cellid();
	float ecell  = g4cell->get_edep();

	float g4hitID  = NAN;
	float gedep    = NAN;
	float gx       = NAN;
	float gy       = NAN;
	float gz       = NAN;
	float gtrackID = NAN;
	float gflavor  = NAN;
	float gpx      = NAN;
	float gpy      = NAN;
	float gpz      = NAN;
	float gvx      = NAN;
	float gvy      = NAN;
	float gvz      = NAN;
	float gfpx     = NAN;
	float gfpy     = NAN;
	float gfpz     = NAN;
	float gfx      = NAN;
	float gfy      = NAN;
	float gfz      = NAN;
	float glast    = NAN;
	float gembed   = NAN;
	float gprimary = NAN;
      
	float efromtruth = NAN;
      
	if (g4hit) {
	  g4hitID  = g4hit->get_hit_id();
	  gedep    = g4hit->get_edep();
	  gx       = 0.5*(g4hit->get_x(0)+g4hit->get_x(1));
	  gy       = 0.5*(g4hit->get_y(0)+g4hit->get_y(1));
	  gz       = 0.5*(g4hit->get_z(0)+g4hit->get_z(1));
	  gx       = g4hit->get_x(0);
	  gy       = g4hit->get_y(0);
	  gz       = g4hit->get_z(0);

	  if (g4particle) {

	    gtrackID = g4particle->get_track_id();
	    gflavor  = g4particle->get_pid();
	    gpx      = g4particle->get_px();
	    gpy      = g4particle->get_py();
	    gpz      = g4particle->get_pz();

	    PHG4VtxPoint* vtx = trutheval->get_vertex(g4particle);

	    if (vtx) {
	      gvx      = vtx->get_x();
	      gvy      = vtx->get_y();
	      gvz      = vtx->get_z();
	    }

	    PHG4Hit* outerhit = trutheval->get_outermost_truth_hit(g4particle);	
	    if (outerhit) {
	      gfpx     = outerhit->get_px(1);
	      gfpy     = outerhit->get_py(1);
	      gfpz     = outerhit->get_pz(1);
	      gfx      = outerhit->get_x(1);
	      gfy      = outerhit->get_y(1);
	      gfz      = outerhit->get_z(1);
	    }
	    glast    = NAN;
	    gembed   = trutheval->get_embed(g4particle);
	    gprimary = trutheval->is_primary(g4particle);
	  } //   if (g4particle){
	}      

	if (g4particle) {
	  efromtruth = hiteval->get_energy_contribution(hit,g4particle);
	}

	float hit_data[32] = {
	  event,
	  hitID,
	  e,
	  adc,
	  layer,
	  cellID,
	  ecell,
	  g4hitID,
	  gedep,
	  gx,
	  gy,
	  gz,
	  gtrackID,
	  gflavor,
	  gpx,
	  gpy,
	  gpz,
	  gvx,
	  gvy,
	  gvz,
	  gfpx,
	  gfpy,
	  gfpz,
	  gfx,
	  gfy,
	  gfz,
	  gembed,
	  gprimary,
	  efromtruth
	};
	  
	_ntp_hit->Fill(hit_data);     
      }
    }
  }
  
  //------------------------
  // fill the Cluster NTuple
  //------------------------

  if (_ntp_cluster) {
    // need things off of the DST...
    SvtxClusterMap* clustermap = findNode::getClass<SvtxClusterMap>(topNode,"SvtxClusterMap");
    if (clustermap) {

      for (SvtxClusterMap::Iter iter = clustermap->begin();
	   iter != clustermap->end();
	   ++iter) {
    
	SvtxCluster* cluster     = iter->second;   
	PHG4Hit *g4hit           = clustereval->max_truth_hit_by_energy(cluster); 
	PHG4Particle *g4particle = trutheval->get_particle(g4hit);
    
	float hitID    = cluster->get_id();
	float x        = cluster->get_x();
	float y        = cluster->get_y();
	float z        = cluster->get_z();
	float e        = cluster->get_e();
	float adc      = cluster->get_adc();
	float layer    = cluster->get_layer();
	float size     = cluster->size_hits();
	float phisize  = cluster->get_phi_size();
	float zsize    = cluster->get_z_size();

	float g4hitID  = NAN;
	float gx       = NAN;
	float gy       = NAN;
	float gz       = NAN;
	float gtrackID = NAN;
	float gflavor  = NAN;
	float gpx      = NAN;
	float gpy      = NAN;
	float gpz      = NAN;
	float gvx      = NAN;
	float gvy      = NAN;
	float gvz      = NAN;
	float gfpx     = NAN;
	float gfpy     = NAN;
	float gfpz     = NAN;
	float gfx      = NAN;
	float gfy      = NAN;
	float gfz      = NAN;
	float glast    = NAN;
	float gembed   = NAN;
	float gprimary = NAN;
    
	float nhits      = NAN;
	float efromtruth = NAN;
      
	if (g4hit) {
	  g4hitID  = g4hit->get_hit_id();
	  gx       = 0.5*(g4hit->get_x(0)+g4hit->get_x(1));
	  gy       = 0.5*(g4hit->get_y(0)+g4hit->get_y(1));
	  gz       = 0.5*(g4hit->get_z(0)+g4hit->get_z(1));
	  gx       = g4hit->get_x(0);
	  gy       = g4hit->get_y(0);
	  gz       = g4hit->get_z(0);

	  if (g4particle) {

	    gtrackID = g4particle->get_track_id();
	    gflavor  = g4particle->get_pid();
	    gpx      = g4particle->get_px();
	    gpy      = g4particle->get_py();
	    gpz      = g4particle->get_pz();

	    PHG4VtxPoint* vtx = trutheval->get_vertex(g4particle);
	    if (vtx) {
	      gvx      = vtx->get_x();
	      gvy      = vtx->get_y();
	      gvz      = vtx->get_z();
	    }

	    PHG4Hit* outerhit = trutheval->get_outermost_truth_hit(g4particle);	
	    if (outerhit) {
	      gfpx     = outerhit->get_px(1);
	      gfpy     = outerhit->get_py(1);
	      gfpz     = outerhit->get_pz(1);
	      gfx      = outerhit->get_x(1);
	      gfy      = outerhit->get_y(1);
	      gfz      = outerhit->get_z(1);
	    }
	    
	    glast    = NAN;
	    gembed   = trutheval->get_embed(g4particle);
	    gprimary = trutheval->is_primary(g4particle);
	  }      //   if (g4particle){
	} //  if (g4hit) {

	if (g4particle){
	  efromtruth = clustereval->get_energy_contribution(cluster,g4particle);
	}

	float cluster_data[33] = {_ievent,
				  hitID,
				  x,
				  y,
				  z,
				  e,
				  adc,
				  layer,
				  size,
				  phisize,
				  zsize,
				  g4hitID,
				  gx,
				  gy,
				  gz,
				  gtrackID,
				  gflavor,
				  gpx,
				  gpy,
				  gpz,
				  gvx,
				  gvy,
				  gvz,
				  gfpx,
				  gfpy,
				  gfpz,
				  gfx,
				  gfy,
				  gfz,
				  gembed,
				  gprimary,
				  nhits,
				  efromtruth};

	_ntp_cluster->Fill(cluster_data);
      }		  
    }
  }
  
  //------------------------
  // fill the Gtrack NTuple
  //------------------------

  // need things off of the DST...

  if (_ntp_gtrack) {
    PHG4TruthInfoContainer* truthinfo = findNode::getClass<PHG4TruthInfoContainer>(topNode,"G4TruthInfo");   
    SvtxClusterMap* clustermap = findNode::getClass<SvtxClusterMap>(topNode,"SvtxClusterMap");
    if (truthinfo) {

      PHG4TruthInfoContainer::ConstRange range = truthinfo->GetPrimaryParticleRange();
      for (PHG4TruthInfoContainer::ConstIterator iter = range.first;
	   iter != range.second; 
	 ++iter) {
	
	PHG4Particle* g4particle = iter->second;
    
	float gtrackID = g4particle->get_track_id();
	float gflavor  = g4particle->get_pid();
      
	std::set<PHG4Hit*> g4hits = trutheval->all_truth_hits(g4particle);     
	float ng4hits = g4hits.size();  
	float gpx      = g4particle->get_px();
	float gpy      = g4particle->get_py();
	float gpz      = g4particle->get_pz();

	PHG4VtxPoint* vtx = trutheval->get_vertex(g4particle);	
	float gvx      = vtx->get_x();
	float gvy      = vtx->get_y();
	float gvz      = vtx->get_z();

	float gfpx      = NULL;
	float gfpy      = NULL;
	float gfpz      = NULL;
	float gfx       = NULL;
	float gfy       = NULL;
	float gfz       = NULL;
    
	PHG4Hit* outerhit = trutheval->get_outermost_truth_hit(g4particle);	
	if (outerhit) {
	  gfpx      = outerhit->get_px(1);
	  gfpy      = outerhit->get_py(1);
	  gfpz      = outerhit->get_pz(1);
	  gfx       = outerhit->get_x(1);
	  gfy       = outerhit->get_y(1);
	  gfz       = outerhit->get_z(1);
	}
      
	float gembed   = trutheval->get_embed(g4particle);
	float gprimary = trutheval->is_primary(g4particle);

	SvtxTrack* track = trackeval->best_track_from(g4particle);

	float trackID       = NAN;
	float charge        = NAN;
	float quality       = NAN;
	float chisq         = NAN;
	float ndf           = NAN;
	float nhits         = NAN;
	unsigned int layers = 0x0;
	float dca           = NAN;
	float dca2d         = NAN;
	float dca2dsigma    = NAN;
	float px            = NAN;
	float py            = NAN;
	float pz            = NAN;
	float pcax          = NAN;
	float pcay          = NAN;
	float pcaz          = NAN;

	float nfromtruth    = NAN;

	if (track) {
	  trackID   = track->get_id();     
	  charge    = track->get_charge();
	  quality   = track->get_quality();
	  chisq     = track->get_chisq();
	  ndf       = track->get_ndf();
	  nhits     = track->size_clusters();
	  
	  for (SvtxTrack::ConstClusterIter iter = track->begin_clusters();
	       iter != track->end_clusters();
	       ++iter) {
	    unsigned int cluster_id = *iter;
	    SvtxCluster* cluster = clustermap->get(cluster_id);
	    unsigned int layer = cluster->get_layer();
	    if (layer < 32) layers |= (0x1 << layer);
	  }

	  dca       = track->get_dca();
	  dca2d     = track->get_dca2d();
	  dca2dsigma = track->get_dca2d_error();
	  px        = track->get_px();
	  py        = track->get_py();
	  pz        = track->get_pz();
	  pcax      = track->get_x();
	  pcay      = track->get_y();
	  pcaz      = track->get_z();

	  nfromtruth = trackeval->get_nclusters_contribution(track,g4particle);
	}
      
	float gtrack_data[34] = {_ievent,
				 gtrackID,
				 gflavor,
				 ng4hits,
				 gpx,
				 gpy,
				 gpz,
				 gvx,
				 gvy,
				 gvz,
				 gfpx,
				 gfpy,
				 gfpz,
				 gfx,
				 gfy,
				 gfz,
				 gembed,
				 gprimary,
				 trackID,
				 px,         
				 py,         
				 pz,  
				 charge,     
				 quality,    
				 chisq,      
				 ndf,        
				 nhits,      
				 layers,     
				 dca2d,      
				 dca2dsigma, 			       
				 pcax,       
				 pcay,       
				 pcaz,
				 nfromtruth
	};

	_ntp_gtrack->Fill(gtrack_data);
      }	     
    }
  }
  
  //------------------------
  // fill the Track NTuple
  //------------------------

  if (_ntp_track) {
    // need things off of the DST...
    SvtxTrackMap* trackmap = findNode::getClass<SvtxTrackMap>(topNode,"SvtxTrackMap");
    SvtxClusterMap* clustermap = findNode::getClass<SvtxClusterMap>(topNode,"SvtxClusterMap");
    if (trackmap) {

      for (SvtxTrackMap::Iter iter = trackmap->begin();
	   iter != trackmap->end();
	   ++iter) {
    
	SvtxTrack* track = iter->second;

	float trackID   = track->get_id();     
	float charge    = track->get_charge();
	float quality   = track->get_quality();
	float chisq     = track->get_chisq();
	float ndf       = track->get_ndf();
	float nhits     = track->size_clusters();

	unsigned int layers = 0x0;
	for (SvtxTrack::ConstClusterIter iter = track->begin_clusters();
	     iter != track->end_clusters();
	     ++iter) {
	  unsigned int cluster_id = *iter;
	  SvtxCluster* cluster = clustermap->get(cluster_id);
	  unsigned int layer = cluster->get_layer();
	  if (layer < 32) layers |= (0x1 << layer);
	}
      
	float dca2d     = track->get_dca2d();
	float dca2dsigma = track->get_dca2d_error();
	float px        = track->get_px();
	float py        = track->get_py();
	float pz        = track->get_pz();
	float pcax      = track->get_x();
	float pcay      = track->get_y();
	float pcaz      = track->get_z();

	float presdphi = track->get_cal_dphi(SvtxTrack::PRES);
	float presdeta = track->get_cal_deta(SvtxTrack::PRES);
	float prese3x3 = track->get_cal_energy_3x3(SvtxTrack::PRES);
	float prese    = track->get_cal_cluster_e(SvtxTrack::PRES);

	float cemcdphi = track->get_cal_dphi(SvtxTrack::CEMC);
	float cemcdeta = track->get_cal_deta(SvtxTrack::CEMC);
	float cemce3x3 = track->get_cal_energy_3x3(SvtxTrack::CEMC);
	float cemce    = track->get_cal_cluster_e(SvtxTrack::CEMC);

	float hcalindphi = track->get_cal_dphi(SvtxTrack::HCALIN);
	float hcalindeta = track->get_cal_deta(SvtxTrack::HCALIN);
	float hcaline3x3 = track->get_cal_energy_3x3(SvtxTrack::HCALIN);
	float hcaline    = track->get_cal_cluster_e(SvtxTrack::HCALIN);

	float hcaloutdphi = track->get_cal_dphi(SvtxTrack::HCALOUT);
	float hcaloutdeta = track->get_cal_deta(SvtxTrack::HCALOUT);
	float hcaloute3x3 = track->get_cal_energy_3x3(SvtxTrack::HCALOUT);
	float hcaloute    = track->get_cal_cluster_e(SvtxTrack::HCALOUT);

	float gtrackID = NAN;
	float gflavor  = NAN;     
	float ng4hits  = NAN;
	float gpx      = NAN;
	float gpy      = NAN;
	float gpz      = NAN;
	float gvx      = NAN;
	float gvy      = NAN;
	float gvz      = NAN;
	float gfpx     = NAN;
	float gfpy     = NAN;
	float gfpz     = NAN;
	float gfx      = NAN;
	float gfy      = NAN;
	float gfz      = NAN;
	float gembed   = NAN;
	float gprimary = NAN;

	float nfromtruth = NAN;
      
	PHG4Particle* g4particle = trackeval->max_truth_particle_by_nclusters(track);
      
	if (g4particle) {
	  gtrackID = g4particle->get_track_id();
	  gflavor  = g4particle->get_pid();
      
	  std::set<PHG4Hit*> g4hits = trutheval->all_truth_hits(g4particle);     
	  ng4hits = g4hits.size();  
	  gpx      = g4particle->get_px();
	  gpy      = g4particle->get_py();
	  gpz      = g4particle->get_pz();
	
	  PHG4VtxPoint* vtx = trutheval->get_vertex(g4particle);	
	  gvx      = vtx->get_x();
	  gvy      = vtx->get_y();
	  gvz      = vtx->get_z();

	  PHG4Hit* outerhit = trutheval->get_outermost_truth_hit(g4particle);	      
	  if (outerhit) {
	    gfpx     = outerhit->get_px(1);
	    gfpy     = outerhit->get_py(1);
	    gfpz     = outerhit->get_pz(1);
	    gfx      = outerhit->get_x(1);
	    gfy      = outerhit->get_y(1);
	    gfz      = outerhit->get_z(1);
	  }
	  gembed   = trutheval->get_embed(g4particle);
	  gprimary = trutheval->is_primary(g4particle);

	  nfromtruth = trackeval->get_nclusters_contribution(track,g4particle);
	}
      
	float track_data[50] = {_ievent,
				trackID, 
				px,        
				py,        
				pz,      
				charge,  
				quality, 
				chisq,   
				ndf,     
				nhits,   
				layers,
				dca2d,     
				dca2dsigma,      
				pcax,      
				pcay,      
				pcaz,      
				presdphi,
				presdeta,
				prese3x3,
				prese,   
				cemcdphi,
				cemcdeta,
				cemce3x3,
				cemce,   
				hcalindphi,
				hcalindeta,
				hcaline3x3,
				hcaline,   
				hcaloutdphi,
				hcaloutdeta,
				hcaloute3x3,
				hcaloute,
				gtrackID,
				gflavor,
				ng4hits,
				gpx,
				gpy,
				gpz,
				gvx,
				gvy,
				gvz,
				gfpx,
				gfpy,
				gfpz,
				gfx,
				gfy,
				gfz,
				gembed,
				gprimary,
				nfromtruth
	};
      
	_ntp_track->Fill(track_data);
      }
    }
  }
  
  return;
}
Esempio n. 2
0
void SvtxEvaluator::fillOutputNtuples(PHCompositeNode *topNode) {

  if (verbosity > 1) cout << "SvtxEvaluator::fillOutputNtuples() entered" << endl;

  SvtxVertexEval*   vertexeval = _svtxevalstack->get_vertex_eval();
  SvtxTrackEval*     trackeval = _svtxevalstack->get_track_eval();
  SvtxClusterEval* clustereval = _svtxevalstack->get_cluster_eval();
  SvtxHitEval*         hiteval = _svtxevalstack->get_hit_eval();
  SvtxTruthEval*     trutheval = _svtxevalstack->get_truth_eval();
  
  //-----------------------
  // fill the Vertex NTuple
  //-----------------------

  if (_ntp_vertex) {
    //cout << "Filling ntp_vertex " << endl;
    SvtxVertexMap* vertexmap = findNode::getClass<SvtxVertexMap>(topNode,"SvtxVertexMap");
    PHG4TruthInfoContainer* truthinfo = findNode::getClass<PHG4TruthInfoContainer>(topNode,"G4TruthInfo");
    if (vertexmap && truthinfo) {
      for (SvtxVertexMap::Iter iter = vertexmap->begin();
	   iter != vertexmap->end();
	   ++iter) {
	SvtxVertex* vertex = iter->second;
	PHG4VtxPoint* point = vertexeval->max_truth_point_by_ntracks(vertex);

	float vx         = vertex->get_x();
	float vy         = vertex->get_y();
	float vz         = vertex->get_z();
	float ntracks    = vertex->size_tracks();

	float gvx        = NAN;
	float gvy        = NAN;
	float gvz        = NAN;
	float gvt        = NAN;
	float gntracks   = truthinfo->GetNumPrimaryVertexParticles();
	float nfromtruth = NAN;
	
	if (point) {
	  gvx        = point->get_x();
	  gvy        = point->get_y();
	  gvz        = point->get_z();
	  gvt        = point->get_t();
	  gntracks   = truthinfo->GetNumPrimaryVertexParticles();
	  nfromtruth = vertexeval->get_ntracks_contribution(vertex,point);
	}
	  
	float vertex_data[11] = {(float) _ievent,
				 vx,
				 vy,
				 vz,
				 ntracks,
				 gvx,
				 gvy,
				 gvz,
				 gvt,
				 gntracks,
				 nfromtruth
	};

	/*
	cout << "vertex: " 
	     << " ievent " << vertex_data[0]
	     << " vx " << vertex_data[1]
	     << " vy " << vertex_data[2]
	     << " vz " << vertex_data[3]
	     << endl;
	*/

	_ntp_vertex->Fill(vertex_data);      
      }
    }
  }
  
  //-----------------------
  // fill the gpoint NTuple
  //-----------------------
  
  if (_ntp_gpoint) {
    //cout << "Filling ntp_gpoint " << endl;    
    SvtxVertexMap* vertexmap = findNode::getClass<SvtxVertexMap>(topNode,"SvtxVertexMap");
    PHG4TruthInfoContainer* truthinfo = findNode::getClass<PHG4TruthInfoContainer>(topNode,"G4TruthInfo");

    if (vertexmap && truthinfo) {

      PHG4VtxPoint* point =  truthinfo->GetPrimaryVtx(truthinfo->GetPrimaryVertexIndex());

      if (point) {
      
	SvtxVertex* vertex = vertexeval->best_vertex_from(point);
    
	float gvx        = point->get_x();
	float gvy        = point->get_y();
	float gvz        = point->get_z();
	float gvt        = point->get_t();
	float gntracks   = truthinfo->GetNumPrimaryVertexParticles();
	float vx         = NAN;
	float vy         = NAN;
	float vz         = NAN;
	float ntracks    = NAN;
	float nfromtruth = NAN;

	if (vertex) {
	  vx         = vertex->get_x();
	  vy         = vertex->get_y();
	  vz         = vertex->get_z();
	  ntracks    = vertex->size_tracks();
	  nfromtruth = vertexeval->get_ntracks_contribution(vertex,point);
	}
	
	float gpoint_data[11] = {(float) _ievent,
				 gvx,
				 gvy,
				 gvz,
				 gvt,
				 gntracks,
				 vx,
				 vy,
				 vz,
				 ntracks,
				 nfromtruth
	};

	_ntp_gpoint->Fill(gpoint_data);      
      }
    }
  }
  
  //---------------------
  // fill the G4hit NTuple
  //---------------------

  if (_ntp_g4hit) {
    //cout << "Filling ntp_g4hit " << endl;
    std::set<PHG4Hit*> g4hits = trutheval->all_truth_hits();
    for (std::set<PHG4Hit*>::iterator iter = g4hits.begin();
	 iter != g4hits.end();
	 ++iter) {
            
      PHG4Hit *g4hit = *iter;
      PHG4Particle *g4particle = trutheval->get_particle(g4hit);
      
      float g4hitID   = g4hit->get_hit_id();
      float gx        = g4hit->get_avg_x();
      float gy        = g4hit->get_avg_y();
      float gz        = g4hit->get_avg_z();
      float gt        = g4hit->get_avg_t();
      float gedep     = g4hit->get_edep();
      float glayer    = g4hit->get_layer();
  
      float gtrackID  = g4hit->get_trkid();

      float gflavor   = NAN;
      float gpx       = NAN;
      float gpy       = NAN;
      float gpz       = NAN;

      float gvx       = NAN;
      float gvy       = NAN;
      float gvz       = NAN;

      float gembed  = NAN;
      float gprimary = NAN;

      float gfpx      = 0.;
      float gfpy      = 0.;
      float gfpz      = 0.;
      float gfx       = 0.;
      float gfy       = 0.;
      float gfz       = 0.;

      if (g4particle) {

	if (_scan_for_embedded) {
	  if (trutheval->get_embed(g4particle) == 0) continue;
	}
	
	gflavor   = g4particle->get_pid();
	gpx       = g4particle->get_px();
	gpy       = g4particle->get_py();
	gpz       = g4particle->get_pz();

	PHG4VtxPoint* vtx = trutheval->get_vertex(g4particle);	

	if (vtx) {
	  gvx       = vtx->get_x();
	  gvy       = vtx->get_y();
	  gvz       = vtx->get_z();
	}
    
	PHG4Hit* outerhit = trutheval->get_outermost_truth_hit(g4particle);	
	if (outerhit) {
	  gfpx      = outerhit->get_px(1);
	  gfpy      = outerhit->get_py(1);
	  gfpz      = outerhit->get_pz(1);
	  gfx       = outerhit->get_x(1);
	  gfy       = outerhit->get_y(1);
	  gfz       = outerhit->get_z(1);
	}
	
	gembed    = trutheval->get_embed(g4particle);
	gprimary  = trutheval->is_primary(g4particle);
      } //       if (g4particle)
      
      std::set<SvtxCluster*> clusters = clustereval->all_clusters_from(g4hit);  
      float nclusters = clusters.size();

      // best cluster reco'd
      SvtxCluster* cluster = clustereval->best_cluster_from(g4hit);

      float clusID     = NAN;
      float x          = NAN;
      float y          = NAN;
      float z          = NAN;
      float e          = NAN;
      float adc        = NAN;
      float layer      = NAN;
      float size       = NAN;
      float phisize    = NAN;
      float zsize      = NAN;
      float efromtruth = NAN;

      if (cluster) {
	clusID     = cluster->get_id();
	x          = cluster->get_x();
	y          = cluster->get_y();
	z          = cluster->get_z();
	e          = cluster->get_e();
	adc        = cluster->get_adc();
	layer      = cluster->get_layer();
	size       = cluster->size_hits();
	phisize    = cluster->get_phi_size();
	zsize      = cluster->get_z_size();
	if (g4particle) {
	  efromtruth = clustereval->get_energy_contribution(cluster,g4particle);
	}
      }

      float g4hit_data[36] = {(float) _ievent,
			      g4hitID,
			      gx,
			      gy,
			      gz,
			      gt,
			      gedep,
			      glayer,
			      gtrackID,
			      gflavor,
			      gpx,
			      gpy,
			      gpz,
			      gvx,
			      gvy,
			      gvz,
			      gfpx,
			      gfpy,
			      gfpz,
			      gfx,
			      gfy,
			      gfz,
			      gembed,
			      gprimary,
			      nclusters,
			      clusID,  
			      x,      
			      y,      
			      z,      
			      e,      
			      adc,    
			      layer,  
			      size,   
			      phisize,
			      zsize,  
			      efromtruth
      };

      _ntp_g4hit->Fill(g4hit_data);
    }
  }
  
  //--------------------
  // fill the Hit NTuple
  //--------------------

  if (_ntp_hit) {
    //cout << "Filling ntp_hit " << endl;
    // need things off of the DST...
    SvtxHitMap* hitmap = findNode::getClass<SvtxHitMap>(topNode,"SvtxHitMap");
    if (hitmap) {

      for (SvtxHitMap::Iter iter = hitmap->begin();
	   iter != hitmap->end();
	   ++iter) {

	SvtxHit* hit             = iter->second;
	PHG4Hit* g4hit           = hiteval->max_truth_hit_by_energy(hit);
	PHG4CylinderCell* g4cell = hiteval->get_cell(hit);
	PHG4Particle* g4particle = trutheval->get_particle(g4hit);

	float event  = _ievent;
	float hitID  = hit->get_id();
	float e      = hit->get_e();
	float adc    = hit->get_adc();
	float layer  = hit->get_layer();
	float cellID = hit->get_cellid();
	float ecell  = g4cell->get_edep();

	float g4hitID  = NAN;
	float gedep    = NAN;
	float gx       = NAN;
	float gy       = NAN;
	float gz       = NAN;
	float gt       = NAN;
	float gtrackID = NAN;
	float gflavor  = NAN;
	float gpx      = NAN;
	float gpy      = NAN;
	float gpz      = NAN;
	float gvx      = NAN;
	float gvy      = NAN;
	float gvz      = NAN;
	float gfpx     = NAN;
	float gfpy     = NAN;
	float gfpz     = NAN;
	float gfx      = NAN;
	float gfy      = NAN;
	float gfz      = NAN;
	float gembed   = NAN;
	float gprimary = NAN;
      
	float efromtruth = NAN;
      
	if (g4hit) {
	  g4hitID  = g4hit->get_hit_id();
	  gedep    = g4hit->get_edep();
	  gx       = g4hit->get_avg_x();
	  gy       = g4hit->get_avg_y();
	  gz       = g4hit->get_avg_z();
	  gt       = g4hit->get_avg_t();

	  if (g4particle) {

	    if (_scan_for_embedded) {
	      if (trutheval->get_embed(g4particle) == 0) continue;
	    }
	    
	    gtrackID = g4particle->get_track_id();
	    gflavor  = g4particle->get_pid();
	    gpx      = g4particle->get_px();
	    gpy      = g4particle->get_py();
	    gpz      = g4particle->get_pz();

	    PHG4VtxPoint* vtx = trutheval->get_vertex(g4particle);

	    if (vtx) {
	      gvx      = vtx->get_x();
	      gvy      = vtx->get_y();
	      gvz      = vtx->get_z();
	    }

	    PHG4Hit* outerhit = trutheval->get_outermost_truth_hit(g4particle);	
	    if (outerhit) {
	      gfpx     = outerhit->get_px(1);
	      gfpy     = outerhit->get_py(1);
	      gfpz     = outerhit->get_pz(1);
	      gfx      = outerhit->get_x(1);
	      gfy      = outerhit->get_y(1);
	      gfz      = outerhit->get_z(1);
	    }
	    gembed   = trutheval->get_embed(g4particle);
	    gprimary = trutheval->is_primary(g4particle);
	  } //   if (g4particle){
	}      

	if (g4particle) {
	  efromtruth = hiteval->get_energy_contribution(hit,g4particle);
	}

	float hit_data[33] = {
	  event,
	  hitID,
	  e,
	  adc,
	  layer,
	  cellID,
	  ecell,
	  g4hitID,
	  gedep,
	  gx,
	  gy,
	  gz,
	  gt,
	  gtrackID,
	  gflavor,
	  gpx,
	  gpy,
	  gpz,
	  gvx,
	  gvy,
	  gvz,
	  gfpx,
	  gfpy,
	  gfpz,
	  gfx,
	  gfy,
	  gfz,
	  gembed,
	  gprimary,
	  efromtruth
	};
	  
	_ntp_hit->Fill(hit_data);     
      }
    }
  }
  
  //------------------------
  // fill the Cluster NTuple
  //------------------------

  //cout << "check for ntp_cluster" << endl;

  if (_ntp_cluster && !_scan_for_embedded) {
    //cout << "Filling ntp_cluster 1 " << endl;
    // need things off of the DST...
    SvtxClusterMap* clustermap = findNode::getClass<SvtxClusterMap>(topNode,"SvtxClusterMap");
    if (clustermap) {

      for (SvtxClusterMap::Iter iter = clustermap->begin();
	   iter != clustermap->end();
	   ++iter) {
    
	SvtxCluster* cluster     = iter->second;   
	SvtxTrack* track = trackeval->best_track_from(cluster);
	
	PHG4Hit *g4hit           = clustereval->max_truth_hit_by_energy(cluster); 
	PHG4Particle *g4particle = trutheval->get_particle(g4hit);
    
	float hitID    = cluster->get_id();
	float x        = cluster->get_x();
	float y        = cluster->get_y();
	float z        = cluster->get_z();

	float ex       = sqrt(cluster->get_error(0,0));
	float ey       = sqrt(cluster->get_error(1,1));
	float ez       = cluster->get_z_error();

	float ephi     = cluster->get_phi_error();
	
	float e        = cluster->get_e();
	float adc      = cluster->get_adc();
	float layer    = cluster->get_layer();
	float size     = cluster->size_hits();
	float phisize  = cluster->get_phi_size();
	float zsize    = cluster->get_z_size();

	float trackID  = NAN;
	if (track) trackID = track->get_id();

	float g4hitID  = NAN;
	float gx       = NAN;
	float gy       = NAN;
	float gz       = NAN;
	float gt       = NAN;
	float gtrackID = NAN;
	float gflavor  = NAN;
	float gpx      = NAN;
	float gpy      = NAN;
	float gpz      = NAN;
	float gvx      = NAN;
	float gvy      = NAN;
	float gvz      = NAN;
	float gfpx     = NAN;
	float gfpy     = NAN;
	float gfpz     = NAN;
	float gfx      = NAN;
	float gfy      = NAN;
	float gfz      = NAN;
	float gembed   = NAN;
	float gprimary = NAN;
    
	float efromtruth = NAN;
      
	if (g4hit) {
	  g4hitID  = g4hit->get_hit_id();
	  gx       = g4hit->get_avg_x();
	  gy       = g4hit->get_avg_y();
	  gz       = g4hit->get_avg_z();
	  gt       = g4hit->get_avg_t();

	  if (g4particle) {

	    gtrackID = g4particle->get_track_id();
	    gflavor  = g4particle->get_pid();
	    gpx      = g4particle->get_px();
	    gpy      = g4particle->get_py();
	    gpz      = g4particle->get_pz();

	    PHG4VtxPoint* vtx = trutheval->get_vertex(g4particle);
	    if (vtx) {
	      gvx      = vtx->get_x();
	      gvy      = vtx->get_y();
	      gvz      = vtx->get_z();
	    }

	    PHG4Hit* outerhit = trutheval->get_outermost_truth_hit(g4particle);	
	    if (outerhit) {
	      gfpx     = outerhit->get_px(1);
	      gfpy     = outerhit->get_py(1);
	      gfpz     = outerhit->get_pz(1);
	      gfx      = outerhit->get_x(1);
	      gfy      = outerhit->get_y(1);
	      gfz      = outerhit->get_z(1);
	    }
	    
	    gembed   = trutheval->get_embed(g4particle);
	    gprimary = trutheval->is_primary(g4particle);
	  }      //   if (g4particle){
	} //  if (g4hit) {

	if (g4particle){
	  efromtruth = clustereval->get_energy_contribution(cluster,g4particle);
	}

	float cluster_data[38] = {(float) _ievent,
				  hitID,
				  x,
				  y,
				  z,
				  ex,
				  ey,
				  ez,
				  ephi,
				  e,
				  adc,
				  layer,
				  size,
				  phisize,
				  zsize,
				  trackID,
				  g4hitID,
				  gx,
				  gy,
				  gz,
				  gt,
				  gtrackID,
				  gflavor,
				  gpx,
				  gpy,
				  gpz,
				  gvx,
				  gvy,
				  gvz,
				  gfpx,
				  gfpy,
				  gfpz,
				  gfx,
				  gfy,
				  gfz,
				  gembed,
				  gprimary,
				  efromtruth};

	_ntp_cluster->Fill(cluster_data);
      }		  
    }
    
  } else if (_ntp_cluster && _scan_for_embedded) {

    //cout << "Filling ntp_cluster 2 " << endl;

    // if only scanning embedded signals, loop over all the tracks from
    // embedded particles and report all of their clusters, including those
    // from other sources (noise hits on the embedded track)
    
    // need things off of the DST...
    SvtxTrackMap* trackmap = findNode::getClass<SvtxTrackMap>(topNode,"SvtxTrackMap");
    SvtxClusterMap* clustermap = findNode::getClass<SvtxClusterMap>(topNode,"SvtxClusterMap");
    if (trackmap) {
      
      for (SvtxTrackMap::Iter iter = trackmap->begin();
	   iter != trackmap->end();
	   ++iter) {
	
	SvtxTrack* track = iter->second;
	PHG4Particle* truth = trackeval->max_truth_particle_by_nclusters(track);
	if (truth) {	  
	  if (trutheval->get_embed(truth) == 0) continue;
	}
	
	for (SvtxTrack::ConstClusterIter iter = track->begin_clusters();
	     iter != track->end_clusters();
	     ++iter) {

	  unsigned int cluster_id = *iter;
	  SvtxCluster* cluster = clustermap->get(cluster_id);

	  PHG4Hit *g4hit           = clustereval->max_truth_hit_by_energy(cluster); 
	  PHG4Particle *g4particle = trutheval->get_particle(g4hit);
    
	  float hitID    = cluster->get_id();
	  float x        = cluster->get_x();
	  float y        = cluster->get_y();
	  float z        = cluster->get_z();

	  float ex       = sqrt(cluster->get_error(0,0));
	  float ey       = sqrt(cluster->get_error(1,1));
	  float ez       = cluster->get_z_error();

	  float ephi     = cluster->get_phi_error();
	  
	  float e        = cluster->get_e();
	  float adc      = cluster->get_adc();
	  float layer    = cluster->get_layer();
	  float size     = cluster->size_hits();
	  float phisize  = cluster->get_phi_size();
	  float zsize    = cluster->get_z_size();

	  float trackID  = NAN;
	  if (track) trackID = track->get_id();

	  float g4hitID  = NAN;
	  float gx       = NAN;
	  float gy       = NAN;
	  float gz       = NAN;
	  float gt       = NAN;
	  float gtrackID = NAN;
	  float gflavor  = NAN;
	  float gpx      = NAN;
	  float gpy      = NAN;
	  float gpz      = NAN;
	  float gvx      = NAN;
	  float gvy      = NAN;
	  float gvz      = NAN;
	  float gfpx     = NAN;
	  float gfpy     = NAN;
	  float gfpz     = NAN;
	  float gfx      = NAN;
	  float gfy      = NAN;
	  float gfz      = NAN;
	  float gembed   = NAN;
	  float gprimary = NAN;
    
	  float efromtruth = NAN;
      
	  if (g4hit) {
	    g4hitID  = g4hit->get_hit_id();
	    gx       = g4hit->get_avg_x();
	    gy       = g4hit->get_avg_y();
      gz       = g4hit->get_avg_z();
      gt       = g4hit->get_avg_t();

	    if (g4particle) {
	    
	      gtrackID = g4particle->get_track_id();
	      gflavor  = g4particle->get_pid();
	      gpx      = g4particle->get_px();
	      gpy      = g4particle->get_py();
	      gpz      = g4particle->get_pz();

	      PHG4VtxPoint* vtx = trutheval->get_vertex(g4particle);
	      if (vtx) {
		gvx      = vtx->get_x();
		gvy      = vtx->get_y();
		gvz      = vtx->get_z();
	      }

	      PHG4Hit* outerhit = trutheval->get_outermost_truth_hit(g4particle);	
	      if (outerhit) {
		gfpx     = outerhit->get_px(1);
		gfpy     = outerhit->get_py(1);
		gfpz     = outerhit->get_pz(1);
		gfx      = outerhit->get_x(1);
		gfy      = outerhit->get_y(1);
		gfz      = outerhit->get_z(1);
	      }
	    
	      gembed   = trutheval->get_embed(g4particle);
	      gprimary = trutheval->is_primary(g4particle);
	    }      //   if (g4particle){
	  } //  if (g4hit) {

	  if (g4particle){
	    efromtruth = clustereval->get_energy_contribution(cluster,g4particle);
	  }

	  float cluster_data[38] = {(float) _ievent,
				    hitID,
				    x,
				    y,
				    z,
				    ex,
				    ey,
				    ez,
				    ephi,
				    e,
				    adc,
				    layer,
				    size,
				    phisize,
				    zsize,
				    trackID,
				    g4hitID,
				    gx,
				    gy,
				    gz,
				    gt,
				    gtrackID,
				    gflavor,
				    gpx,
				    gpy,
				    gpz,
				    gvx,
				    gvy,
				    gvz,
				    gfpx,
				    gfpy,
				    gfpz,
				    gfx,
				    gfy,
				    gfz,
				    gembed,
				    gprimary,
				    efromtruth};

	  _ntp_cluster->Fill(cluster_data);
	}		  
      }
    }
  }
    
  //------------------------
  // fill the Gtrack NTuple
  //------------------------

  // need things off of the DST...

  //cout << "check for ntp_gtrack" << endl;

  if (_ntp_gtrack) {
    //cout << "Filling ntp_gtrack " << endl;

    PHG4TruthInfoContainer* truthinfo = findNode::getClass<PHG4TruthInfoContainer>(topNode,"G4TruthInfo");   
    SvtxClusterMap* clustermap = findNode::getClass<SvtxClusterMap>(topNode,"SvtxClusterMap");
    if (truthinfo) {

      PHG4TruthInfoContainer::ConstRange range = truthinfo->GetPrimaryParticleRange();
      for (PHG4TruthInfoContainer::ConstIterator iter = range.first;
	   iter != range.second; 
	 ++iter) {
	
	PHG4Particle* g4particle = iter->second;

	if (_scan_for_embedded) {
	  if (trutheval->get_embed(g4particle) == 0) continue;
	}
	
	float gtrackID = g4particle->get_track_id();
	float gflavor  = g4particle->get_pid();
      
	std::set<PHG4Hit*> g4hits = trutheval->all_truth_hits(g4particle);     
	float ng4hits = g4hits.size();  
	float gpx      = g4particle->get_px();
	float gpy      = g4particle->get_py();
	float gpz      = g4particle->get_pz();

	PHG4VtxPoint* vtx = trutheval->get_vertex(g4particle);	
	float gvx      = vtx->get_x();
	float gvy      = vtx->get_y();
	float gvz      = vtx->get_z();
	float gvt      = vtx->get_t();

	float gfpx      = 0.;
	float gfpy      = 0.;
	float gfpz      = 0.;
	float gfx       = 0.;
	float gfy       = 0.;
	float gfz       = 0.;
    
	PHG4Hit* outerhit = trutheval->get_outermost_truth_hit(g4particle);	
	if (outerhit) {
	  gfpx      = outerhit->get_px(1);
	  gfpy      = outerhit->get_py(1);
	  gfpz      = outerhit->get_pz(1);
	  gfx       = outerhit->get_x(1);
	  gfy       = outerhit->get_y(1);
	  gfz       = outerhit->get_z(1);
	}
      
	float gembed   = trutheval->get_embed(g4particle);
	float gprimary = trutheval->is_primary(g4particle);

	SvtxTrack* track = trackeval->best_track_from(g4particle);

	float trackID       = NAN;
	float charge        = NAN;
	float quality       = NAN;
	float chisq         = NAN;
	float ndf           = NAN;
	float nhits         = NAN;
	unsigned int layers = 0x0;
	float dca2d         = NAN;
	float dca2dsigma    = NAN;
	float px            = NAN;
	float py            = NAN;
	float pz            = NAN;
	float pcax          = NAN;
	float pcay          = NAN;
	float pcaz          = NAN;

	float nfromtruth    = NAN;
	float layersfromtruth = NAN;

	if (track) {
	  trackID   = track->get_id();     
	  charge    = track->get_charge();
	  quality   = track->get_quality();
	  chisq     = track->get_chisq();
	  ndf       = track->get_ndf();
	  nhits     = track->size_clusters();
	  
	  for (SvtxTrack::ConstClusterIter iter = track->begin_clusters();
	       iter != track->end_clusters();
	       ++iter) {
	    unsigned int cluster_id = *iter;
	    SvtxCluster* cluster = clustermap->get(cluster_id);
	    unsigned int layer = cluster->get_layer();
	    if (layer < 32) layers |= (0x1 << layer);
	  }

	  dca2d     = track->get_dca2d();
	  dca2dsigma = track->get_dca2d_error();
	  px        = track->get_px();
	  py        = track->get_py();
	  pz        = track->get_pz();
	  pcax      = track->get_x();
	  pcay      = track->get_y();
	  pcaz      = track->get_z();

	  nfromtruth = trackeval->get_nclusters_contribution(track,g4particle);
	  layersfromtruth = trackeval->get_nclusters_contribution_by_layer(track,g4particle);
	}
      
	float gtrack_data[36] = {(float) _ievent,
				 gtrackID,
				 gflavor,
				 ng4hits,
				 gpx,
				 gpy,
				 gpz,
				 gvx,
				 gvy,
				 gvz,
				 gvt,
				 gfpx,
				 gfpy,
				 gfpz,
				 gfx,
				 gfy,
				 gfz,
				 gembed,
				 gprimary,
				 trackID,
				 px,         
				 py,         
				 pz,  
				 charge,     
				 quality,    
				 chisq,      
				 ndf,        
				 nhits,      
				 (float) layers,     
				 dca2d,      
				 dca2dsigma, 			       
				 pcax,       
				 pcay,       
				 pcaz,
				 nfromtruth,
				 layersfromtruth
	};

	/*
	cout << " ievent " << _ievent
	     << " gtrackID " << gtrackID
	     << " gflavor " << gflavor
	     << " ng4hits " << ng4hits
	     << endl;
	*/

	_ntp_gtrack->Fill(gtrack_data);

      }	     
    }
  }
  
  //------------------------
  // fill the Track NTuple
  //------------------------



  if (_ntp_track) {
    //cout << "Filling ntp_track " << endl;

    // need things off of the DST...
    SvtxTrackMap* trackmap = findNode::getClass<SvtxTrackMap>(topNode,"SvtxTrackMap");
    SvtxClusterMap* clustermap = findNode::getClass<SvtxClusterMap>(topNode,"SvtxClusterMap");
    if (trackmap) {

      for (SvtxTrackMap::Iter iter = trackmap->begin();
	   iter != trackmap->end();
	   ++iter) {
    
	SvtxTrack* track = iter->second;

	float trackID   = track->get_id();     
	float charge    = track->get_charge();
	float quality   = track->get_quality();
	float chisq     = track->get_chisq();
	float ndf       = track->get_ndf();
	float nhits     = track->size_clusters();

	unsigned int layers = 0x0;
	for (SvtxTrack::ConstClusterIter iter = track->begin_clusters();
	     iter != track->end_clusters();
	     ++iter) {
	  unsigned int cluster_id = *iter;
	  SvtxCluster* cluster = clustermap->get(cluster_id);
	  unsigned int layer = cluster->get_layer();
	  if (layer < 31) layers |= (0x1 << layer);
	}
      
	float dca2d     = track->get_dca2d();
	float dca2dsigma = track->get_dca2d_error();
	float px        = track->get_px();
	float py        = track->get_py();
	float pz        = track->get_pz();
	float pcax      = track->get_x();
	float pcay      = track->get_y();
	float pcaz      = track->get_z();

	float presdphi = track->get_cal_dphi(SvtxTrack::PRES);
	float presdeta = track->get_cal_deta(SvtxTrack::PRES);
	float prese3x3 = track->get_cal_energy_3x3(SvtxTrack::PRES);
	float prese    = track->get_cal_cluster_e(SvtxTrack::PRES);

	float cemcdphi = track->get_cal_dphi(SvtxTrack::CEMC);
	float cemcdeta = track->get_cal_deta(SvtxTrack::CEMC);
	float cemce3x3 = track->get_cal_energy_3x3(SvtxTrack::CEMC);
	float cemce    = track->get_cal_cluster_e(SvtxTrack::CEMC);

	float hcalindphi = track->get_cal_dphi(SvtxTrack::HCALIN);
	float hcalindeta = track->get_cal_deta(SvtxTrack::HCALIN);
	float hcaline3x3 = track->get_cal_energy_3x3(SvtxTrack::HCALIN);
	float hcaline    = track->get_cal_cluster_e(SvtxTrack::HCALIN);

	float hcaloutdphi = track->get_cal_dphi(SvtxTrack::HCALOUT);
	float hcaloutdeta = track->get_cal_deta(SvtxTrack::HCALOUT);
	float hcaloute3x3 = track->get_cal_energy_3x3(SvtxTrack::HCALOUT);
	float hcaloute    = track->get_cal_cluster_e(SvtxTrack::HCALOUT);

	float gtrackID = NAN;
	float gflavor  = NAN;     
	float ng4hits  = NAN;
	float gpx      = NAN;
	float gpy      = NAN;
	float gpz      = NAN;
	float gvx      = NAN;
	float gvy      = NAN;
	float gvz      = NAN;
	float gvt      = NAN;
	float gfpx     = NAN;
	float gfpy     = NAN;
	float gfpz     = NAN;
	float gfx      = NAN;
	float gfy      = NAN;
	float gfz      = NAN;
	float gembed   = NAN;
	float gprimary = NAN;

	float nfromtruth = NAN;
	float layersfromtruth = NAN;
      
	PHG4Particle* g4particle = trackeval->max_truth_particle_by_nclusters(track);	
	
	if (g4particle) {

	  if (_scan_for_embedded) {
	    if (trutheval->get_embed(g4particle) == 0) continue;
	  }
	  
	  gtrackID = g4particle->get_track_id();
	  gflavor  = g4particle->get_pid();
      
	  std::set<PHG4Hit*> g4hits = trutheval->all_truth_hits(g4particle);     
	  ng4hits = g4hits.size();  
	  gpx      = g4particle->get_px();
	  gpy      = g4particle->get_py();
	  gpz      = g4particle->get_pz();
	
	  PHG4VtxPoint* vtx = trutheval->get_vertex(g4particle);	
	  gvx      = vtx->get_x();
	  gvy      = vtx->get_y();
	  gvz      = vtx->get_z();
	  gvt      = vtx->get_t();

	  PHG4Hit* outerhit = trutheval->get_outermost_truth_hit(g4particle);	      
	  if (outerhit) {
	    gfpx     = outerhit->get_px(1);
	    gfpy     = outerhit->get_py(1);
	    gfpz     = outerhit->get_pz(1);
	    gfx      = outerhit->get_x(1);
	    gfy      = outerhit->get_y(1);
	    gfz      = outerhit->get_z(1);
	  }
	  gembed   = trutheval->get_embed(g4particle);
	  gprimary = trutheval->is_primary(g4particle);

	  nfromtruth = trackeval->get_nclusters_contribution(track,g4particle);
	  layersfromtruth = trackeval->get_nclusters_contribution_by_layer(track,g4particle);
	}
      
	float track_data[52] = {(float) _ievent,
				trackID, 
				px,        
				py,        
				pz,      
				charge,  
				quality, 
				chisq,   
				ndf,     
				nhits,   
				(float) layers,
				dca2d,     
				dca2dsigma,      
				pcax,      
				pcay,      
				pcaz,      
				presdphi,
				presdeta,
				prese3x3,
				prese,   
				cemcdphi,
				cemcdeta,
				cemce3x3,
				cemce,   
				hcalindphi,
				hcalindeta,
				hcaline3x3,
				hcaline,   
				hcaloutdphi,
				hcaloutdeta,
				hcaloute3x3,
				hcaloute,
				gtrackID,
				gflavor,
				ng4hits,
				gpx,
				gpy,
				gpz,
				gvx,
				gvy,
				gvz,
				gvt,
				gfpx,
				gfpy,
				gfpz,
				gfx,
				gfy,
				gfz,
				gembed,
				gprimary,
				nfromtruth,
				layersfromtruth
	};

	/*
	cout << "ievent " << _ievent
	     << " trackID " << trackID
	     << " nhits " << nhits
	     << " px " << px
	     << " py " << py
	     << " pz " << pz
	     << " gembed " << gembed
	     << " gprimary " << gprimary 
	     << endl;
	*/
	_ntp_track->Fill(track_data);
      }
    }
  }
  
  return;
}
int SimpleTrackingAnalysis::process_event(PHCompositeNode *topNode)
{

  // --- This is the class process_event method
  // --- This is where the bulk of the analysis is done
  // --- Here we get the various data nodes we need to do the analysis
  // --- Then we use variables (accessed through class methods) to perform calculations

  if ( verbosity > -1 )
    {
      cout << endl;
      cout << "------------------------------------------------------------------------------------" << endl;
      cout << "Now processing event number " << nevents << endl; // would be good to add verbosity switch
    }

  ++nevents; // You may as youtself, why ++nevents (pre-increment) rather
  // than nevents++ (post-increment)?  The short answer is performance.
  // For simple types it probably doesn't matter, but it can really help
  // for complex types (like the iterators below).


  // --- Truth level information
  PHG4TruthInfoContainer* truthinfo = findNode::getClass<PHG4TruthInfoContainer>(topNode,"G4TruthInfo");
  if ( !truthinfo )
    {
      cerr << PHWHERE << " ERROR: Can't find G4TruthInfo" << endl;
      exit(-1);
    }

  // --- SvtxTrackMap
  SvtxTrackMap* trackmap = findNode::getClass<SvtxTrackMap>(topNode,"SvtxTrackMap");
  if ( !trackmap )
    {
      cerr << PHWHERE << " ERROR: Can't find SvtxTrackMap" << endl;
      exit(-1);
    }

  // --- SvtxVertexMap
  SvtxVertexMap* vertexmap = findNode::getClass<SvtxVertexMap>(topNode,"SvtxVertexMap");
  if ( !vertexmap )
    {
      cerr << PHWHERE << " ERROR: Can't find SvtxVertexMap" << endl;
      exit(-1);
    }



  // --- Create SVTX eval stack
  SvtxEvalStack svtxevalstack(topNode);
  // --- Get evaluator objects from the eval stack
  SvtxVertexEval*   vertexeval = svtxevalstack.get_vertex_eval();
  SvtxTrackEval*     trackeval = svtxevalstack.get_track_eval();
  SvtxTruthEval*     trutheval = svtxevalstack.get_truth_eval();



  if ( verbosity > 0 ) cout << "Now going to loop over truth partcles..." << endl; // need verbosity switch

  // --- Loop over all truth particles
  PHG4TruthInfoContainer::Range range = truthinfo->GetPrimaryParticleRange();
  for ( PHG4TruthInfoContainer::ConstIterator iter = range.first; iter != range.second; ++iter )
    {
      PHG4Particle* g4particle = iter->second; // You may ask yourself, why second?
      // In C++ the iterator is a map, which has two members
      // first is the key (analogous the index of an arry),
      // second is the value (analogous to the value stored for the array index)
      int particleID = g4particle->get_pid();

      if ( trutheval->get_embed(g4particle) <= 0 && fabs(particleID) == 11 && verbosity > 0 )
        {
          cout << "NON EMBEDDED ELECTRON!!!  WHEE!!! " << particleID << " " << iter->first << endl;
        }

      if ( trutheval->get_embed(g4particle) <= 0 ) continue; // only look at embedded particles // no good for hits files
      bool iselectron = fabs(particleID) == 11;
      bool ispion = fabs(particleID) == 211;
      if ( verbosity > 0 ) cout << "embedded particle ID is " << particleID << " ispion " << ispion << " iselectron " << iselectron << " " << iter->first << endl;

      set<PHG4Hit*> g4hits = trutheval->all_truth_hits(g4particle);
      float ng4hits = g4hits.size();

      float truept = sqrt(pow(g4particle->get_px(),2)+pow(g4particle->get_py(),2));
      float true_energy = g4particle->get_e();

      // --- Get the reconsructed SvtxTrack based on the best candidate from the truth info
      SvtxTrack* track = trackeval->best_track_from(g4particle);
      if (!track) continue;
      float recopt = track->get_pt();
      float recop = track->get_p();

      if ( verbosity > 0 )
	{
	  cout << "truept is " << truept << endl;
	  cout << "recopt is " << recopt << endl;
	  cout << "true energy is " << true_energy << endl;
	}

      // --- energy variables directly from the track object
      float emc_energy_track = track->get_cal_energy_3x3(SvtxTrack::CEMC);
      float hci_energy_track = track->get_cal_energy_3x3(SvtxTrack::HCALIN);
      float hco_energy_track = track->get_cal_energy_3x3(SvtxTrack::HCALOUT);

      if ( verbosity > 0 )
	{
	  cout << "emc_energy_track is " << emc_energy_track << endl;
	  cout << "hci_energy_track is " << hci_energy_track << endl;
	  cout << "hco_energy_track is " << hco_energy_track << endl;
	}

      // -------------------------------------------------------------------------------------
      // --- IMPORTANT NOTE: according to Jin, dphi and deta will not work correctly in HIJING

      float emc_dphi_track = track->get_cal_dphi(SvtxTrack::CEMC);
      float hci_dphi_track = track->get_cal_dphi(SvtxTrack::HCALIN);
      float hco_dphi_track = track->get_cal_dphi(SvtxTrack::HCALOUT);

      float emc_deta_track = track->get_cal_deta(SvtxTrack::CEMC);
      float hci_deta_track = track->get_cal_deta(SvtxTrack::HCALIN);
      float hco_deta_track = track->get_cal_deta(SvtxTrack::HCALOUT);

      float assoc_dphi = 0.1; // adjust as needed, consider class set method
      float assoc_deta = 0.1; // adjust as needed, consider class set method
      bool good_emc_assoc = fabs(emc_dphi_track) < assoc_dphi && fabs(emc_deta_track) < assoc_deta;
      bool good_hci_assoc = fabs(hci_dphi_track) < assoc_dphi && fabs(hci_deta_track) < assoc_deta;
      bool good_hco_assoc = fabs(hco_dphi_track) < assoc_dphi && fabs(hco_deta_track) < assoc_deta;

      // ------------------------------------------------------------------------------------------


      float hct_energy_track = 0;
      if ( hci_energy_track >= 0 ) hct_energy_track += hci_energy_track;
      if ( hco_energy_track >= 0 ) hct_energy_track += hco_energy_track;

      float total_energy_dumb = 0;
      if ( emc_energy_track >= 0 ) total_energy_dumb += emc_energy_track;
      if ( hci_energy_track >= 0 ) total_energy_dumb += hci_energy_track;
      if ( hco_energy_track >= 0 ) total_energy_dumb += hco_energy_track;

      float total_energy_smart = 0;
      if ( good_emc_assoc ) total_energy_smart += emc_energy_track;
      if ( good_hci_assoc ) total_energy_smart += hci_energy_track;
      if ( good_hco_assoc ) total_energy_smart += hco_energy_track;



      // ----------------------------------------------------------------------
      // ----------------------------------------------------------------------
      // ----------------------------------------------------------------------

      //cout << "starting the main part of the truth analysis" << endl;

      // examine truth particles that leave all (7 or 8 depending on design) detector hits
      if ( ng4hits == nlayers )
	{
	  _truept_particles_leavingAllHits->Fill(truept);

	  unsigned int nfromtruth = trackeval->get_nclusters_contribution(track,g4particle);

	  unsigned int ndiff = abs((int)nfromtruth-(int)nlayers);
	  if ( ndiff <= 2 ) _truept_particles_recoWithin2Hits->Fill(truept);
	  if ( ndiff <= 1 ) _truept_particles_recoWithin1Hit->Fill(truept);
	  if ( ndiff == 0 ) _truept_particles_recoWithExactHits->Fill(truept);

	  float diff = fabs(recopt-truept)/truept;
	  if ( diff < 0.05 ) _truept_particles_recoWithin5Percent->Fill(truept);
	  if ( diff < 0.04 )
	    {
	      _truept_particles_recoWithin4Percent->Fill(truept);
	      _truept_quality_particles_recoWithin4Percent->Fill(truept,track->get_quality());
	    }
	  if ( diff < 0.03 ) _truept_particles_recoWithin3Percent->Fill(truept);

          double good_energy = total_energy_dumb - 3.14;


          double eoverp = good_energy/recop;
          double sigmapt = 0.011 + 0.0008*recopt;
          th2d_truept_particles_withcalocuts_leavingAllHits->Fill(truept,eoverp);
          if ( ndiff <= 2 ) th2d_truept_particles_withcalocuts_recoWithin2Hits->Fill(truept,eoverp);
          if ( ndiff <= 1 ) th2d_truept_particles_withcalocuts_recoWithin1Hit->Fill(truept,eoverp);
          if ( ndiff == 0 ) th2d_truept_particles_withcalocuts_recoWithExactHits->Fill(truept,eoverp);
          if ( diff < 0.05 ) th2d_truept_particles_withcalocuts_recoWithin5Percent->Fill(truept,eoverp);
          if ( diff < 0.04 ) th2d_truept_particles_withcalocuts_recoWithin4Percent->Fill(truept,eoverp);
          if ( diff < 0.03 ) th2d_truept_particles_withcalocuts_recoWithin3Percent->Fill(truept,eoverp);
          if ( diff < 1.0*sigmapt ) th2d_truept_particles_withcalocuts_recoWithin1Sigma->Fill(recopt,eoverp);
          if ( diff < 2.0*sigmapt ) th2d_truept_particles_withcalocuts_recoWithin2Sigma->Fill(recopt,eoverp);
          if ( diff < 3.0*sigmapt ) th2d_truept_particles_withcalocuts_recoWithin3Sigma->Fill(recopt,eoverp);


	} // end of requirement of ng4hits == nlayers

    } // end of loop over truth particles



  // loop over all reco particles
  int ntracks = 0;
  for ( SvtxTrackMap::Iter iter = trackmap->begin(); iter != trackmap->end(); ++iter )
    {

      // --- Get the StxTrack object (from the iterator)
      SvtxTrack* track = iter->second;
      float recopt = track->get_pt();
      float recop = track->get_p();

      // --- Get the truth particle from the evaluator
      PHG4Particle* g4particle = trackeval->max_truth_particle_by_nclusters(track);
      float truept = sqrt(pow(g4particle->get_px(),2)+pow(g4particle->get_py(),2));
      int particleID = g4particle->get_pid();
      if ( verbosity > 5 ) cout << "particle ID is " << particleID << endl;
      bool iselectron = fabs(particleID) == 11;
      bool ispion = fabs(particleID) == 211;

      // ---------------------
      // --- calorimeter stuff
      // ---------------------

      // --- get the energy values directly from the track
      float emc_energy_track = track->get_cal_energy_3x3(SvtxTrack::CEMC);
      float hci_energy_track = track->get_cal_energy_3x3(SvtxTrack::HCALIN);
      float hco_energy_track = track->get_cal_energy_3x3(SvtxTrack::HCALOUT);

      float total_energy = 0;
      if ( emc_energy_track > 0 ) total_energy += emc_energy_track;
      if ( hci_energy_track > 0 ) total_energy += hci_energy_track;
      if ( hco_energy_track > 0 ) total_energy += hco_energy_track;

      if ( verbosity > 2 ) cout << "total calo energy is " << total_energy << endl;

      if (trutheval->get_embed(g4particle) > 0)
	{
	  // embedded results (quality or performance measures)
	  _truept_dptoverpt->Fill(truept,(recopt-truept)/truept);
	  _truept_dca->Fill(truept,track->get_dca2d());
	  _recopt_quality->Fill(recopt,track->get_quality());
          if ( verbosity > 0 ) cout << "embedded particle ID is " << particleID << " ispion " << ispion << " iselectron " << iselectron << endl;
          // ---
	} // end if (embedded results)
      else
	{
          // electron and pion (hadron) id

	  // non-embedded results (purity measures)
	  _recopt_tracks_all->Fill(recopt);
	  _recopt_quality_tracks_all->Fill(recopt,track->get_quality());

	  unsigned int nfromtruth = trackeval->get_nclusters_contribution(track,g4particle);

	  unsigned int ndiff = abs((int)nfromtruth-(int)nlayers);
	  if ( ndiff <= 2 ) _recopt_tracks_recoWithin2Hits->Fill(recopt);
	  if ( ndiff <= 1 ) _recopt_tracks_recoWithin1Hit->Fill(recopt);
	  if ( ndiff == 0 ) _recopt_tracks_recoWithExactHits->Fill(recopt);

	  float diff = fabs(recopt-truept)/truept;
	  if ( diff < 0.05 ) _recopt_tracks_recoWithin5Percent->Fill(recopt);
	  if ( diff < 0.04 )
	    {
	      _recopt_tracks_recoWithin4Percent->Fill(recopt);
	      _recopt_quality_tracks_recoWithin4Percent->Fill(recopt,track->get_quality());
	    }
	  if ( diff < 0.03 ) _recopt_tracks_recoWithin3Percent->Fill(recopt);


	  // --------------------------------------
	  // --- same but now with calorimeter cuts
	  // --------------------------------------

          double good_energy = total_energy - 3.14;

          double eoverp = good_energy/recop;
          double sigmapt = 0.011 + 0.0008*recopt;
          th2d_recopt_tracks_withcalocuts_all->Fill(recopt,eoverp);
          if ( ndiff <= 2 ) th2d_recopt_tracks_withcalocuts_recoWithin2Hits->Fill(recopt,eoverp);
          if ( ndiff <= 1 ) th2d_recopt_tracks_withcalocuts_recoWithin1Hit->Fill(recopt,eoverp);
          if ( ndiff == 0 ) th2d_recopt_tracks_withcalocuts_recoWithExactHits->Fill(recopt,eoverp);
          if ( diff < 0.05 ) th2d_recopt_tracks_withcalocuts_recoWithin5Percent->Fill(recopt,eoverp);
          if ( diff < 0.04 ) th2d_recopt_tracks_withcalocuts_recoWithin4Percent->Fill(recopt,eoverp);
          if ( diff < 0.03 ) th2d_recopt_tracks_withcalocuts_recoWithin3Percent->Fill(recopt,eoverp);
          if ( diff < 1.0*sigmapt ) th2d_recopt_tracks_withcalocuts_recoWithin1Sigma->Fill(recopt,eoverp);
          if ( diff < 2.0*sigmapt ) th2d_recopt_tracks_withcalocuts_recoWithin2Sigma->Fill(recopt,eoverp);
          if ( diff < 3.0*sigmapt ) th2d_recopt_tracks_withcalocuts_recoWithin3Sigma->Fill(recopt,eoverp);

	  // --- done with reco tracks

	} // else (non-embedded results)

      ++ntracks;
    } // loop over reco tracks


  hmult->Fill(ntracks);

  // --- Get the leading vertex
  SvtxVertex* maxvertex = NULL;
  unsigned int maxtracks = 0;
  for ( SvtxVertexMap::Iter iter = vertexmap->begin(); iter != vertexmap->end(); ++iter )
    {
      SvtxVertex* vertex = iter->second;
      if ( vertex->size_tracks() > maxtracks )
	{
	  maxvertex = vertex;
	  maxtracks = vertex->size_tracks();
	}
    }
  if ( !maxvertex )
    {
      cerr << PHWHERE << " ERROR: cannot get reconstructed vertex (event number " << nevents << ")" << endl;
      ++nerrors;
      return Fun4AllReturnCodes::DISCARDEVENT;
    }

  // --- Get the coordinates for the vertex from the evaluator
  PHG4VtxPoint* point = vertexeval->max_truth_point_by_ntracks(maxvertex);
  if ( !point )
    {
      cerr << PHWHERE << " ERROR: cannot get truth vertex (event number " << nevents << ")" << endl;
      ++nerrors;
      return Fun4AllReturnCodes::DISCARDEVENT;
    }
  _dx_vertex->Fill(maxvertex->get_x() - point->get_x());
  _dy_vertex->Fill(maxvertex->get_y() - point->get_y());
  _dz_vertex->Fill(maxvertex->get_z() - point->get_z());

  hmult_vertex->Fill(ntracks);



  return Fun4AllReturnCodes::EVENT_OK;

}