---

mMuiEvalFramework.cxx

Go to the documentation of this file.

//
// Description: compare MUIOO and MUI output
//              

// MUIOO headers
//
#include <mMuiEvalFramework.h>
#include <mMuiEvalFrameworkPar.h>
#include <TMutNode.h>
#include <TMuiHitMapO.h>
#include <TMuiClusterMapO.h>
#include <PHException.h>
#include <MUIOO.h>
#include <PHTimer.h>

// MUI headers
//
#include<dMuiRawWrapper.h>


// PHENIX headers
//

// STL/BOOST
//
#include <iostream>
#include <string>

// Constructor
mMuiEvalFramework::mMuiEvalFramework() : 
  _timer(PHTimeServer::get()->insert_new("mMuiEvalFramework") )
{
  name = "mMuiEvalFramework";
  MUIOO::TRACE("initializing module " + std::string(name.getString()));  
}

// Destructor
mMuiEvalFramework::~mMuiEvalFramework() { }


// Event method.
PHBoolean 
mMuiEvalFramework::event(PHCompositeNode* top_node)
{
  _timer.get()->restart(); 
  
  try {
    
    set_interface_ptrs(top_node);
    if (_mod_par->get_eval_unpack()) eval_unpacker();
    if (_mod_par->get_eval_cluster()) eval_cluster();
    if (_mod_par->get_eval_findroad()) eval_findroad();
  } 
  catch (std::exception& e) {
    MUIOO::TRACE(e.what());
    return False;
  }
  
  // Timer
  _timer.get()->stop();
  _timer.get()->print(); 
  return True;
}

void 
mMuiEvalFramework::set_interface_ptrs(PHCompositeNode* top_node){  
  
  // module runtime parameters
  //
  _mod_par = TMutNode<mMuiEvalFrameworkPar>::find_node(top_node,"mMuiEvalFrameworkPar");
  
  // hit map pointer (IOC)
  //
  _hit_map = TMutNode<TMuiHitMapO>::find_node(top_node,"TMuiHitMapO");  
  
  // cluster map pointer (IOC)
  //
  _cluster_map = TMutNode<TMuiClusterMapO>::find_node(top_node,"TMuiClusterMapO");  

  // hit wrapped STAF table 
  //  
  if(_mod_par->get_eval_unpack()) {
    _hit_table = TMutNode<dMuiRawWrapper>::find_io_node(top_node,"dMuiRaw");
  }
  // cluster wrapped STAF table 
  //
  if(_mod_par->get_eval_cluster()){
    _cluster_table = TMutNode<dMuiClustersWrapper>::find_io_node(top_node,"dMuiClusters");
  }
  // cluster wrapped STAF table 
  //
  if(_mod_par->get_eval_findroad()){
    _road_table = TMutNode<dMuiRoadsWrapper>::find_io_node(top_node,"dMuiRoads");
  }
} 


void 
mMuiEvalFramework::eval_unpacker()
{
  // back in STAF-land
  //
  TABLE_HEAD_ST dMuiRaw_h = _hit_table->TableHeader();
  DMUIRAW_ST* dMuiRaw   = _hit_table->TableData();
  
  MUIOO::PRINT(std::cout, "MUI unpack summary statistics");
  std::cout << "TMuiHitMapO: total hits = " << _hit_map->size() << std::endl;
  std::cout << "dMuiRaw: total hits = " << dMuiRaw_h.nok << std::endl;
  MUIOO::PRINT(std::cout, "**");
  
  for(int i=0;i<dMuiRaw_h.nok;i++){
    unsigned short arm = dMuiRaw[i].arm;
    unsigned short plane = dMuiRaw[i].plane;
    unsigned short panel = dMuiRaw[i].panel;
    unsigned short orientation = dMuiRaw[i].orientation;
    unsigned short twopack = dMuiRaw[i].twopack;
    TMuiHitMapO::const_iterator hit_iter = _hit_map->get(arm,
                                                         plane,
                                                         panel,
                                                         orientation,
                                                         twopack);
    bool found_match = false;
    if (hit_iter.count() == 0) found_match = true;
    if(!found_match){
      std::cout << "TMuiHitMapO/dMuiRaw mismatch" << std::endl;
    }
  }
}

void mMuiEvalFramework::eval_cluster(){
  
  // back in STAF-land
  //
  TABLE_HEAD_ST dMuiClusters_h = _cluster_table->TableHeader();
  DMUICLUSTERS_ST* dMuiClusters   = _cluster_table->TableData();
  
  int nmatch=0;
  const double max_diff_match = 10.; 

  for(int i=0; i<dMuiClusters_h.nok;i++){

    unsigned short arm = dMuiClusters[i].arm;
    unsigned short plane = dMuiClusters[i].plane;
    unsigned short panel = dMuiClusters[i].panel;
    unsigned short orient = dMuiClusters[i].orientation;
    
    float cpos_staf[3];
    for (int j = 0; j<3; j++) {
      cpos_staf[j] = dMuiClusters[i].CentroidPos[j];;
    }

    TMuiClusterMapO::const_iterator cluster_iter = _cluster_map->get(arm,
                                                                     plane,
                                                                     panel,
                                                                     orient);
    bool found_match = false;
    while(TMuiClusterMapO::const_pointer cluster_ptr = cluster_iter.next()){
      
      PHPoint cpos_oo = cluster_ptr->get()->get_centroidpos();
      double diffX = cpos_oo.getX() - cpos_staf[0];
      double diffY = cpos_oo.getY() - cpos_staf[1];
      double diffZ = cpos_oo.getZ() - cpos_staf[2];
      double diff = sqrt(diffX*diffX + diffY*diffY + diffZ*diffZ);
      if (diff < max_diff_match) {
        found_match = true;
      }
    }
    if(!found_match){
      MUIOO::PRINT(std::cout,"No matching cluster found");
      print_cluster(&dMuiClusters[i]);
      MUIOO::PRINT(std::cout,"**");
    }
    else {
      nmatch++;
    }
  }
  MUIOO::PRINT(std::cout,"Summary Comparison");
  std::cout << " ntot " << dMuiClusters_h.nok
            << " nmatch " << nmatch << std::endl;
  MUIOO::PRINT(std::cout,"**");
}

void 
mMuiEvalFramework::eval_findroad()
{
  // TBI
  return;
}

void 
mMuiEvalFramework::print_raw(const DMUIRAW_ST* raw_ptr)
{
  // TBI
  return;
}

void 
mMuiEvalFramework::print_cluster(const DMUICLUSTERS_ST* clus_ptr)
{
  MUIOO::PRINT(std::cout,"dMuiClusters");
  std::cout << " arm: " << clus_ptr->arm << std::endl;
  std::cout << " plane: " << clus_ptr->plane << std::endl;
  std::cout << " panel: " << clus_ptr->panel << std::endl;
  std::cout << " orientation: " << clus_ptr->orientation << std::endl;
  std::cout << " size: " << clus_ptr->size << std::endl;
  std::cout << " index: " << clus_ptr->dMuiClusterIndex << std::endl;
  MUIOO::PRINT(std::cout,"**");
}

void 
mMuiEvalFramework::print_road(const DMUIROADS_ST* raw_ptr)
{
  // TBI
  return;
}

---