TpcPrototypeUnpacker.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file TpcPrototypeUnpacker.h

/*
 * TpcPrototypeUnpacker.h
 *
 *  Created on: Sep 19, 2018
 *      Author: jinhuang
 */

#ifndef CORESOFTWARE_OFFLINE_PACKAGES_TPCDAQ_TpcPrototypeUnpacker_H_
#define CORESOFTWARE_OFFLINE_PACKAGES_TPCDAQ_TpcPrototypeUnpacker_H_

#include <fun4all/SubsysReco.h>

#include <TObject.h>

#include <cstdint>
#include <cmath>
#include <map>
#include <set>
#include <string>
#include <utility>  // for pair
#include <vector>

class PHCompositeNode;
class Fun4AllHistoManager;
class TTree;
class TClonesArray;
class PHG4TpcPadPlane;
class PHG4CylinderCellGeomContainer;
class TrkrClusterContainer;
class TrkrHitSetContainer;

namespace TpcPrototypeDefs
{
namespace FEEv2
{
class SampleFit_PowerLawDoubleExp_PDFMaker;
}
}  // namespace TpcPrototypeDefs

class TpcPrototypeUnpacker : public SubsysReco
{
 public:
  TpcPrototypeUnpacker(const std::string &outputfilename =
                           "TpcPrototypeUnpacker.root");
  virtual ~TpcPrototypeUnpacker();

  int Init(PHCompositeNode *topNode);
  int InitRun(PHCompositeNode *topNode);
  int process_event(PHCompositeNode *topNode);
  int ResetEvent(PHCompositeNode *topNode);
  int End(PHCompositeNode *topNode);

  void setClusteringZeroSuppression(int threshold)
  {
    m_clusteringZeroSuppression = threshold;
  }

  void setNPostSample(int nPostSample)
  {
    m_nPostSample = nPostSample;
  }

  void setNPreSample(int nPreSample)
  {
    m_nPreSample = nPreSample;
  }

  void registerPadPlane(PHG4TpcPadPlane *padplane);

  void setEnableClustering(bool b) { enableClustering = b; }
  class EventHeader : public TObject
  {
   public:
    int run;
    int event;

    uint32_t bx_counter;
    bool bx_counter_consistent;

    int xray_x;
    int xray_y;

    EventHeader()
      : run(-1)
      , event(-1)
      , bx_counter(0)
      , bx_counter_consistent(true)
      , xray_x(-1)
      , xray_y(-1)
    {
    }

    ClassDefOverride(TpcPrototypeUnpacker::EventHeader, 1)
  };

  class PadPlaneData
  {
   public:
    PadPlaneData();
    void Reset();

    struct SampleID
    {
      int pad_azimuth;
      int pad_radial;
      int sample;

      void adjust(const SampleID &adjustment)
      {
        pad_azimuth += adjustment.pad_azimuth;
        pad_radial += adjustment.pad_radial;
        sample += adjustment.sample;
      }
    };

    static bool IsValidPad(const int pad_x, const int pad_y);
    std::vector<int> &getPad(const int pad_x, const int pad_y);
    int getSample(const SampleID &id);

    void Clustering(int zero_suppression, bool verbosity = false);


    const std::vector<std::vector<std::vector<int>>> &getData() const
    {
      return m_data;
    }

    const std::multimap<int, SampleID> &getGroups() const
    {
      return m_groups;
    }

   private:
    std::vector<std::vector<std::vector<int>>> m_data;

    std::multimap<int, SampleID> m_groups;

  };

  class ClusterData : public TObject
  {
   public:
    ClusterData()
      : clusterID(-1)
      , min_sample(-1)
      , max_sample(-1)
      , min_pad_azimuth(-1)
      , max_pad_azimuth(-1)
      , peak(NAN)
      , peak_sample(NAN)
      , pedstal(NAN)
      , avg_pad_radial(-1)
      , avg_pad_azimuth(NAN)
      , size_pad_radial(-1)
      , size_pad_azimuth(-1)
      , avg_pos_x(NAN)
      , avg_pos_y(NAN)
      , avg_pos_z(NAN)
      , delta_azimuth_bin(NAN)
      , delta_z(NAN)
    {
    }

    void Clear(Option_t * /*option*/ = "");

    int clusterID;

    std::set<int> pad_radials;
    std::set<int> pad_azimuths;
    std::set<int> samples;

    std::map<int, std::vector<double>> pad_radial_samples;
    std::map<int, std::vector<double>> pad_azimuth_samples;
    std::vector<double> sum_samples;

    int min_sample;
    int max_sample;
    int min_pad_azimuth;
    int max_pad_azimuth;

    double peak;
    double peak_sample;
    double pedstal;

    //    std::map<int, double> pad_radial_peaks; // radial always have size = 1 in this analysis
    std::map<int, double> pad_azimuth_peaks;

    int avg_pad_radial;
    double avg_pad_azimuth;

    int size_pad_radial;
    int size_pad_azimuth;

    double avg_pos_x;
    double avg_pos_y;
    double avg_pos_z;

    double delta_azimuth_bin;
    double delta_z;

    ClassDefOverride(TpcPrototypeUnpacker::ClusterData, 5);
  };

  class ChannelHeader : public TObject
  {
   public:
    int size;
    int packet_type;
    int bx_counter;
    int sampa_address;
    int sampa_channel;
    int fee_channel;

    int fee_id;

    int pad_x;
    int pad_y;

    int pedestal;
    int max;

    ChannelHeader()
      : size(-1)
      , packet_type(-1)
      , bx_counter(-1)
      , sampa_address(-1)
      , sampa_channel(-1)
      , fee_channel(-1)
      , fee_id(-1)
      , pad_x(-1)
      , pad_y(-1)
      , pedestal(-1)
      , max(-1)
    {
    }

    ClassDefOverride(TpcPrototypeUnpacker::ChannelHeader, 1)
  };

 private:
  PHG4TpcPadPlane *padplane;
  PHG4CylinderCellGeomContainer *tpcCylinderCellGeom;
  TrkrHitSetContainer *hitsetcontainer;
  TrkrClusterContainer *trkrclusters;

  int exportDSTCluster(ClusterData &cluster, const int i);

  int exportDSTHits();

  int InitField(PHCompositeNode *topNode);


  // IO stuff

  Fun4AllHistoManager *getHistoManager();

  std::string m_outputFileName;

  TTree *m_eventT;

  EventHeader m_eventHeader;
  EventHeader *m_peventHeader;  

  int m_nClusters;
  TClonesArray *m_IOClusters;

  TTree *m_chanT;

  ChannelHeader m_chanHeader;
  ChannelHeader *m_pchanHeader;  
  std::vector<uint32_t> m_chanData;

  // clustering stuff
  PadPlaneData m_padPlaneData;
  std::map<int, ClusterData> m_clusters;

  static std::pair<int, int> roughZeroSuppression(std::vector<int> &data);

  bool enableClustering;
  int Clustering(void);


  int m_clusteringZeroSuppression;
  int m_nPreSample;
  int m_nPostSample;
  int m_XRayLocationX;
  int m_XRayLocationY;

  TpcPrototypeDefs::FEEv2::SampleFit_PowerLawDoubleExp_PDFMaker *m_pdfMaker;
};

bool operator<(const TpcPrototypeUnpacker::PadPlaneData::SampleID &s1, const TpcPrototypeUnpacker::PadPlaneData::SampleID &s2);

#endif /* CORESOFTWARE_OFFLINE_PACKAGES_TPCDAQ_TpcPrototypeUnpacker_H_ */