Added new shower detector

	new file:   Shower2.cxx
	new file:   Shower2.h
	modified:   THcCherenkov.cxx
	modified:   THcCherenkov.h
	modified:   THcShowerArray.h
	modified:   include/HallC_LinkDef.h

src/Shower2.cxx

+#include "Shower2.h"
+
+#include "THcShower.h"
+#include "THcHallCSpectrometer.h"
+#include "THaEvData.h"
+#include "THaDetMap.h"
+#include "THcDetectorMap.h"
+#include "THcGlobals.h"
+#include "THaCutList.h"
+#include "THcParmList.h"
+#include "VarDef.h"
+#include "VarType.h"
+#include "THaTrack.h"
+#include "TClonesArray.h"
+#include "THaTrackProj.h"
+#include "TMath.h"
+
+#include <cstring>
+#include <cstdio>
+#include <cstdlib>
+#include <iostream>
+#include <numeric>
+
+#include "nlohmann/json.hpp" 
+
+using namespace std;
+
+namespace hcana {
+
+THaAnalysisObject::EStatus Shower2::Init(const TDatime &date) {
+
+  auto res = THcShower::Init(date);
+
+  LoadJsonCalibration(_run_number);
+ 
+  // hard coding cal_*_cal_const  to 0.001. 
+  // Not sure what their purpose is... 
+
+  for (UInt_t i=0; i<fNTotBlocks; i++) {
+    fPosGain[i] = 0.001 *  _pos_gain_cor[i];
+    fNegGain[i] = 0.001 *  _neg_gain_cor[i];
+  }
+
+  if(fHasArray) {
+    auto gains = fArray->GetGains();
+    for (Int_t i=0; i<fArray->GetNelem(); i++) {
+      gains[i] = 0.001 * _arr_gain_cor[i];
+    }
+  }
+
+  return fStatus = res;
+}
+
+void Shower2::LoadJsonCalibration(int rn, std::string fname) {
+  // file checks assumed already complete.
+  using nlohmann::json;
+  json j_database;
+  {
+    std::ifstream json_input_file(fname);
+    json_input_file >> j_database;
+  }
+
+  std::cout << " runs : ";
+  std::vector<int> runs;
+  for (json::iterator it = j_database.begin(); it != j_database.end(); ++it) {
+    std::cout << it.key() << ", ";
+    runs.push_back(std::stoi(it.key()));
+  }
+  std::cout << "\n";
+
+  auto closest = [](std::vector<int> const &vec, int value) {
+    auto it = std::lower_bound(vec.begin(), vec.end(), value);
+    if (*it > value) {
+      it = it - 1;
+    }
+    if (it == vec.end()) {
+      return -1;
+    }
+    return *it;
+  };
+  // auto best_run = std::upper_bound(runs.begin(), runs.end(), rn);
+  // std::cout << "using run upper " << rn << " :::: " << *best_run << "\n";
+  // auto best_run = std::lower_bound(runs.begin(), runs.end(), rn);
+  // std::cout << "using run lower " << rn << " :::: " << *(best_run) << "\n";
+
+  int best_run = closest(runs, rn);
+  std::cout << " closest " << best_run << std::endl;
+  json j = j_database[std::to_string(best_run)];
+  // std::cout << j_database[std::to_string(best_run)] << "\n";;
+  // std::cout << j.dump(-1) << "\n";
+
+
+  if (j.find("histogram") != j.end()) {
+  }
+  if (j.find("cal") != j.end()) {
+    json j_cal = j["cal"];
+    if (j_cal.find("neg_gain_cor") != j_cal.end()) {
+      // std::cout << " neg_gain_cor!!!\n";
+      _neg_gain_cor = j["cal"]["neg_gain_cor"].get<std::vector<double>>();
+    }
+    if (j_cal.find("pos_gain_cor") != j_cal.end()) {
+      _pos_gain_cor = j["cal"]["pos_gain_cor"].get<std::vector<double>>();
+    }
+    if (j_cal.find("arr_gain_cor") != j_cal.end()) {
+      _arr_gain_cor = j["cal"]["arr_gain_cor"].get<std::vector<double>>();
+    }
+  }
+}
+
+} // namespace hcana

src/Shower2.h

+#ifndef ROOT_hcana_Shower2
+#define ROOT_hcana_Shower2
+
+///////////////////////////////////////////////////////////////////////////////
+//                                                                           //
+// hcana::Shower                                                             //
+//                                                                           //
+///////////////////////////////////////////////////////////////////////////////
+
+#include "THcShower.h"
+#include "TObject.h"
+
+namespace hcana {
+
+class Shower2 : public THcShower {
+
+public:
+  Shower2(const char *name, const char *description = "",
+             THaApparatus *a = nullptr)
+      : THcShower(name, description, a) {}
+
+  virtual ~Shower2(){}
+
+  virtual THaAnalysisObject::EStatus Init(const TDatime &run_time);
+
+  int _run_number = 0;
+  std::vector<double> _neg_gain_cor;
+  std::vector<double> _pos_gain_cor;
+  std::vector<double> _arr_gain_cor;
+
+  void SetRunNumber(int rn) { _run_number = rn;}
+  void LoadJsonCalibration(int rn, std::string fname = "PARAM/SHMS/CAL/pcal_calib.json");
+
+  // virtual void 	     Clear( Option_t* opt="" );
+  // virtual Int_t      Decode( const THaEvData& );
+  // virtual Int_t      CoarseProcess( TClonesArray& tracks );
+  // virtual Int_t      FineProcess( TClonesArray& tracks );
+
+  ClassDef(Shower2, 1) // Shower counter detector
+};
+
+} // namespace hcana
+
+#endif

src/THcCherenkov.cxx

@@ -292,10 +292,8 @@ Int_t THcCherenkov::DefineVariables( EMode mode )
   RVarDef vars[] = {
     {"adcCounter",   "ADC counter numbers",            "frAdcPulseIntRaw.THcSignalHit.GetPaddleNumber()"},
     {"adcErrorFlag", "Error Flag for When FPGA Fails", "fAdcErrorFlag.THcSignalHit.GetData()"},
-
     {"numGoodAdcHits",    "Number of Good ADC Hits Per PMT", "fNumGoodAdcHits"},    // Cherenkov occupancy
     {"totNumGoodAdcHits", "Total Number of Good ADC Hits",   "fTotNumGoodAdcHits"}, // Cherenkov multiplicity
-
     {"numTracksMatched",    "Number of Tracks Matched Per Region",       "fNumTracksMatched"},
     {"numTracksFired",      "Number of Tracks that Fired Per Region",    "fNumTracksFired"},
     {"totNumTracksMatched", "Total Number of Tracks Matched Per Region", "fTotNumTracksMatched"},

src/THcCherenkov.h

@@ -15,6 +15,8 @@ class THcHodoscope;
 
 class THcCherenkov : public THaNonTrackingDetector, public THcHitList {
 
+  using vec = std::vector<Double_t>;
+
  public:
   THcCherenkov(const char* name, const char* description = "", THaApparatus* a = NULL);
   virtual ~THcCherenkov();
@@ -65,15 +67,15 @@ class THcCherenkov : public THaNonTrackingDetector, public THcHitList {
   vector<Int_t>    fNumGoodAdcHits;
   vector<Int_t>    fNumTracksMatched;
   vector<Int_t>    fNumTracksFired;
-  vector<Double_t> fGoodAdcPed;
-  vector<Double_t> fGoodAdcMult;
-  vector<Double_t> fGoodAdcHitUsed;
-  vector<Double_t> fGoodAdcPulseInt;
-  vector<Double_t> fGoodAdcPulseIntRaw;
-  vector<Double_t> fGoodAdcPulseAmp;
-  vector<Double_t> fGoodAdcPulseTime;
-  vector<Double_t> fGoodAdcTdcDiffTime;
-  vector<Double_t> fNpe;
+  vec fGoodAdcPed;
+  vec fGoodAdcMult;
+  vec fGoodAdcHitUsed;
+  vec fGoodAdcPulseInt;
+  vec fGoodAdcPulseIntRaw;
+  vec fGoodAdcPulseAmp;
+  vec fGoodAdcPulseTime;
+  vec fGoodAdcTdcDiffTime;
+  vec fNpe;
 
   Int_t     fNRegions;
   Int_t     fRegionsValueMax;

src/THcShowerArray.h

@@ -81,7 +81,9 @@ public:
 
   Double_t GetEarray() {
     return fEarray;
-  };
+  }
+
+  Double_t* GetGains(){ return fGain; }
 
   // Fiducial volume limits.
   Double_t fvXmin();

src/include/HallC_LinkDef.h

@@ -6,6 +6,14 @@
 #pragma link off all classes;
 #pragma link off all functions;
  
+
+#pragma link C++ nestedclass;
+#pragma link C++ nestedtypedef;
+
+#pragma link C++ namespace hallc;
+#pragma link C++ namespace hcana;
+
+
 #pragma link C++ global gHcParms;
 #pragma link C++ global gHcDetectorMap;
  
@@ -48,6 +56,7 @@
 #pragma link C++ class THcRawHit+;
 #pragma link C++ class THcRawHodoHit+;
 #pragma link C++ class THcRawShowerHit+;
+#pragma link C++ class THcRawShowerHit+;
 #pragma link C++ class THcRawTdcHit+;
 #pragma link C++ class THcReactionPoint+;
 #pragma link C++ class THcRun+;
@@ -66,5 +75,8 @@
 #pragma link C++ class THcTrigDet+;
 #pragma link C++ class THcTrigRawHit+;
 #pragma link C++ class Decoder::TIBlobModule+;
+
+#pragma link C++ class hcana::Shower2+;
+
 // Postamble for HallC_Linkdef.h file
 #endif