SRawEventEmbed.cxx

Go to the documentation of this file.

/*
 * SRawEventEmbed.C
 *
 *  Created on: Oct 29, 2017
 *      Author: yuhw@nmsu.edu
 */
 
 
#include "SRawEventEmbed.h"
 
#include <interface_main/SQHit.h>
#include <interface_main/SQHit_v1.h>
#include <interface_main/SQMCHit_v1.h>
#include <interface_main/SQHitMap_v1.h>
#include <interface_main/SQHitVector_v1.h>
#include <interface_main/SQEvent_v1.h>
#include <interface_main/SQRun_v1.h>
#include <interface_main/SQSpill_v1.h>
#include <interface_main/SQSpillMap_v1.h>
 
#include <ktracker/SRecEvent.h>
 
#include <geom_svc/GeomSvc.h>
 
#include <fun4all/Fun4AllReturnCodes.h>
#include <fun4all/PHTFileServer.h>
#include <phool/PHNodeIterator.h>
#include <phool/PHIODataNode.h>
#include <phool/getClass.h>
#include <phool/PHRandomSeed.h>
 
#include <g4main/PHG4TruthInfoContainer.h>
#include <g4main/PHG4HitContainer.h>
#include <g4main/PHG4Hit.h>
#include <g4main/PHG4Particle.h>
#include <g4main/PHG4HitDefs.h>
#include <g4main/PHG4VtxPoint.h>
 
#include <TFile.h>
#include <TTree.h>
 
#include <cstring>
#include <cmath>
#include <cfloat>
#include <stdexcept>
#include <limits>
#include <tuple>
#include <memory>
 
// gsl
#include <gsl/gsl_randist.h>
#include <gsl/gsl_rng.h>
 
#include <boost/lexical_cast.hpp>
 
using namespace std;
 
SRawEventEmbed::SRawEventEmbed(const std::string& name) :
SubsysReco(name),
_hit_container_type("Vector"),
_noise_rate(),
_event(0),
_hit_map(nullptr),
_hit_vector(nullptr),
_in_name("digit_016070_R007.root"),
_in_tree_name("save"),
_tin(nullptr),
_tree_entry(0),
_trigger_bit(-1),
_out_name("SRawEventEmbedEval.root")
{
}
 
int SRawEventEmbed::Init(PHCompositeNode* topNode) {
        return Fun4AllReturnCodes::EVENT_OK;
}
 
int SRawEventEmbed::InitRun(PHCompositeNode* topNode) {
 
        ResetEvalVars();
        InitEvalTree();
 
        p_geomSvc = GeomSvc::instance();
 
        int ret = GetNodes(topNode);
        if(ret != Fun4AllReturnCodes::EVENT_OK) return ret;
 
        _fin = TFile::Open(_in_name.c_str(), "READ");
        if(!_fin) {
                LogInfo("!fin");
                return Fun4AllReturnCodes::ABORTRUN;
        }
 
        _tin = (TTree*) _fin->Get(_in_tree_name.c_str());
        if(!_tin) {
                LogInfo("!_tin");
                return Fun4AllReturnCodes::ABORTRUN;
        }
 
  _srawevent = new SRawEvent();
        _tin->SetBranchAddress("rawEvent", &_srawevent);
 
        return Fun4AllReturnCodes::EVENT_OK;
}
 
int SRawEventEmbed::process_event(PHCompositeNode* topNode) {
 
        if(Verbosity() >= Fun4AllBase::VERBOSITY_SOME)
                std::cout << "Entering SRawEventEmbed::process_event: " << _event << std::endl;
 
        ResetEvalVars();
 
  if(!_hit_vector and _hit_container_type.find("Vector") == std::string::npos) {
        LogInfo("!_hit_vector and _hit_container_type.find(\"Vector\") == std::string::npos");
        return Fun4AllReturnCodes::ABORTRUN;
  }
 
  // Next entry until triggered, warp using
  //_fin->cd();
  while (true) {
    try {
      _tin->GetEntry(_tree_entry);
          ++_tree_entry;
    } catch (...) {
      LogInfo("FAIL: _tin->GetEntry(_tree_entry);");
      return Fun4AllReturnCodes::ABORTRUN;
    }
    if(Verbosity() >= Fun4AllBase::VERBOSITY_A_LOT) {
        LogInfo("_event: " << _event);
        LogInfo("_tree_entry: " << _tree_entry);
        LogInfo(_srawevent);
    }
    if(!_srawevent) {
      LogInfo("!_srawevent");
      continue;
    }
        if((_srawevent->getTriggerBits()&_trigger_bit) > 0) break;
        if(_tree_entry >=  _tin->GetEntries()) _tree_entry=0;
  }
 
  for(Hit hit : _srawevent->getAllHits()) {
 
//    if(Verbosity() >= Fun4AllBase::VERBOSITY_A_LOT) {
//      LogInfo("");
//      hit.print();
//    }
 
                auto up_digiHit = std::unique_ptr<SQMCHit_v1> (new SQMCHit_v1());
                auto digiHit = up_digiHit.get();
 
                digiHit->set_hit_id(_hit_vector->size());
 
                digiHit->set_detector_id(hit.detectorID);
                digiHit->set_element_id(hit.elementID);
                digiHit->set_drift_distance(hit.driftDistance);
 
                digiHit->set_pos(p_geomSvc->getMeasurement(digiHit->get_detector_id(), digiHit->get_element_id()));
 
                // FIXME figure this out
                digiHit->set_in_time(hit.isInTime());
                digiHit->set_hodo_mask(hit.isHodoMask());
 
                digiHit->set_track_id(std::numeric_limits<int>::max());
                digiHit->set_g4hit_id(std::numeric_limits<int>::max());
 
                digiHit->set_truth_x(std::numeric_limits<float>::max());
                digiHit->set_truth_y(std::numeric_limits<float>::max());
                digiHit->set_truth_z(std::numeric_limits<float>::max());
 
//    if(Verbosity() >= Fun4AllBase::VERBOSITY_A_LOT) {
//      LogInfo("");
//      digiHit->identify();
//    }
 
                _hit_vector->push_back(digiHit);
  }
 
  _tout->Fill();
 
  if(Verbosity() >= Fun4AllBase::VERBOSITY_SOME)
    std::cout << "Leaving SRawEventEmbed::process_event: " << _event << std::endl;
  ++_event;
 
  return Fun4AllReturnCodes::EVENT_OK;
}
 
int SRawEventEmbed::End(PHCompositeNode* topNode) {
  if(Verbosity() >= Fun4AllBase::VERBOSITY_SOME)
    std::cout << "SRawEventEmbed::End" << std::endl;
 
  PHTFileServer::get().cd(_out_name.c_str());
  _tout->Write();
 
  return Fun4AllReturnCodes::EVENT_OK;
}
 
int SRawEventEmbed::InitEvalTree() {
  PHTFileServer::get().open(_out_name.c_str(), "RECREATE");
 
  _tout = new TTree("T", "SRawEventEmbed");
 
  return 0;
}
 
int SRawEventEmbed::ResetEvalVars() {
  return 0;
}
 
int SRawEventEmbed::GetNodes(PHCompositeNode* topNode) {
 
  if(_hit_container_type.find("Map") != std::string::npos) {
    _hit_map = findNode::getClass<SQHitMap>(topNode, "SQHitMap");
    if (!_hit_map) {
      LogInfo("!_hit_map");
      return Fun4AllReturnCodes::ABORTEVENT;
    }
  }
 
  if(_hit_container_type.find("Vector") != std::string::npos) {
    _hit_vector = findNode::getClass<SQHitVector>(topNode, "SQHitVector");
    if (!_hit_vector) {
        LogInfo("!_hit_vector");
      return Fun4AllReturnCodes::ABORTEVENT;
    }
  }
 
  return Fun4AllReturnCodes::EVENT_OK;
}