KVINDRA.cpp

/***************************************************************************
$Id: KVINDRA.cpp,v 1.68 2009/01/21 10:05:51 franklan Exp $
                          kvindra.cpp  -  description
                             -------------------
    begin                : Mon May 20 2002
    copyright            : (C) 2002 by J.D. Frankland
    email                : frankland@ganil.fr
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#include "KVINDRA.h"
#include "KVDataSet.h"
#include "KVMaterial.h"
#include "KVDetector.h"
#include "KVIDTelescope.h"
#include "KVIDSiCsI.h"
#include "KVIDINDRACsI.h"
#include "KVIDChIoSi.h"
#include "KVIDChIoCsI.h"
#include "KVIDChIoSi75.h"
#include "KVIDSi75SiLi.h"
#include "KVIDPhoswich.h"
#include "KVGroup.h"
#include "KVChIo.h"
#include "KVCsI.h"
#include "KVDetectorEvent.h"
#include "TEnv.h"
#include "INDRAGeometryBuilder.h"
#include "KVGeoNavigator.h"
#include "KVGeoImportINDRA.h"
#ifdef WITH_BUILTIN_GRU
#include <KVGANILDataReader.h>
#endif
#include <KVDBChIoPressures.h>
#include <KVGeoImport.h>
#include <KVRangeTableGeoNavigator.h>
#include <KVRawDataReader.h>
#ifdef WITH_MFM
#include "KVMFMDataFileReader.h"
#include "MFMEbyedatFrame.h"
#ifdef WITH_MESYTEC
#include "MFMMesytecMDPPFrame.h"
#include "mesytec_buffer_reader.h"
#endif
#endif
#include "KVGeoImportINDRA.h"
#include "KVINDRAGroupReconstructor.h"
#include <cassert>
 
using namespace std;
 
ClassImp(KVINDRA)
 
//Use this static array to translate EBaseIndra_type
//signal type to a string giving the signal type
 
 
Char_t KVINDRA::SignalTypes[][3] = {
   "",                          //dummy for index=0
   "GG", "PG", "T",
   "GG", "PG", "T",
   "R", "L", "T",
   "GG", "PG", "T",
   "GG", "PG", "T"
};
 
 
#define KV_DEBUG 1
 
KVINDRA* gIndra;
 
 
KVINDRA::KVINDRA()
{
   //Default constructor
   //Set up lists of ChIo, Si, CsI, Phoswich
   fChIo.SetCleanup(kTRUE);
   fSi.SetCleanup(kTRUE);
   fCsI.SetCleanup(kTRUE);
   fPhoswich.SetCleanup(kTRUE);
   fTrigger = 0;
   gIndra = this;
   fPHDSet = kFALSE;
   fSelecteur = nullptr;
   fMesytecData = kFALSE;
   fEbyedatData = kFALSE;
}
 
 
 
 
KVINDRA::~KVINDRA()
{
   //Resets global gIndra pointer.
 
   if (gIndra == this) gIndra = nullptr;
}
 
 
 
 
 
void KVINDRA::Build(Int_t run)
{
   // Correspondance between CsI detectors and pin lasers is set up if known.
 
   if (run != -1) {
      fCurrentRun = run;
   }
   BuildGeometry();
 
   if (fCloseGeometryNow) {
      PerformClosedROOTGeometryOperations();
   }
}
 
 
 
 
void KVINDRA::FillListsOfDetectorsByType()
{
   //Fill lists of ChIo, Si, CsI and phoswich
 
   fChIo.Clear();
   fSi.Clear();
   fCsI.Clear();
   fPhoswich.Clear();
   TIter next_det(GetDetectors());
   KVDetector* kvd;
   while ((kvd = (KVDetector*) next_det())) {
      kvd->SetNameOfArray("INDRA");
      if (kvd->InheritsFrom("KVChIo")) {
         fChIo.Add(kvd);
      }
      if (kvd->InheritsFrom("KVSilicon")) {
         fSi.Add(kvd);
      }
      if (kvd->InheritsFrom("KVCsI")) {
         fCsI.Add(kvd);
      }
      if (kvd->InheritsFrom("KVPhoswich")) {
         fPhoswich.Add(kvd);
      }
   }
}
 
 
 
 
KVChIo* KVINDRA::GetChIoOf(const Char_t* detname)
{
 
   //Returns a pointer to the Ionisation Chamber placed directly in front of the
   //detector "detname". If no ChIo is present, a null pointer is returned.
 
   KVINDRADetector* kvd;
   kvd = dynamic_cast<KVINDRADetector*>(GetDetector(detname));
   return (kvd ? (KVChIo*)kvd->GetChIo() : NULL);
}
 
 
 
 
 
KVLayer* KVINDRA::GetChIoLayer(void)
{
   //Return pointer to layer in INDRA structure corresponding to ionisation
   //chambers.
 
   return (KVLayer*)GetStructure("LAYER", "CHIO");
}
 
 
 
 
 
void KVINDRA::SetTrigger(UChar_t trig)
{
   // Define multiplicity trigger used for acquisition and filter.
   // Events with multipicity >= trig are OK.
 
   fTrigger = trig;
}
 
 
 
 
KVINDRADetector* KVINDRA::GetDetectorByType(UInt_t cou, UInt_t mod, UInt_t type) const
{
   //Find a detector based on the old BaseIndra type definitions:
   //
//enum EBaseIndra_type {
//      ChIo_GG=1,
//      ChIo_PG,//=2
//      ChIo_T,//=3
//      Si_GG,//=4
//      Si_PG,//=5
//      Si_T,//=6
//      CsI_R,//=7
//      CsI_L,//=8
//      CsI_T,//=9
//      Si75_GG,//=10
//      Si75_PG,//=11
//      Si75_T,//=12
//      SiLi_GG,//=13
//      SiLi_PG,//=14
//      SiLi_T//=15
//};
//enum EBaseIndra_typePhos {
//      Phos_R=1,
//      Phos_L,//=2
//      Phos_T,//=3
//};
 
   KVINDRADetector* det = 0;
 
   char nom_det[20];
   if (cou == 1) {
      if (type >= Phos_R && type <= Phos_T) {
         sprintf(nom_det, "PHOS_%02d", mod);
         det =
            (KVINDRADetector*) GetListOfPhoswich()->FindObjectByName(nom_det);
      }
   }
   if (det)
      return det;
   else if (type >= ChIo_GG && type <= ChIo_T) {
      sprintf(nom_det, "CI_%02d%02d", cou, mod);
      det = (KVINDRADetector*) GetListOfChIo()->FindObject(nom_det);
      return det;
   }
   else if (type >= Si_GG && type <= Si_T) {
      sprintf(nom_det, "SI_%02d%02d", cou, mod);
      det = (KVINDRADetector*) GetListOfSi()->FindObject(nom_det);
      return det;
   }
   else if (type >= SiLi_GG && type <= SiLi_T) {
      sprintf(nom_det, "SILI_%02d", cou);
      det = (KVINDRADetector*) GetListOfSi()->FindObject(nom_det);
      return det;
   }
   else if (type >= Si75_GG && type <= Si75_T) {
      sprintf(nom_det, "SI75_%02d", cou);
      det = (KVINDRADetector*) GetListOfSi()->FindObject(nom_det);
      return det;
   }
   else if (type >= CsI_R && type <= CsI_T) {
      sprintf(nom_det, "CSI_%02d%02d", cou, mod);
      det = (KVINDRADetector*) GetListOfCsI()->FindObject(nom_det);
      return det;
   }
   return 0;
}
 
 
 
 
void KVINDRA::SetNamesOfIDTelescopes() const
{
   // Change default names of ID telescopes to INDRA standard
   //
   // This method also sets the types of the ID telescopes
 
   TIter it(GetListOfIDTelescopes());
   KVIDTelescope* idt;
   const TString etalon_numbers[] = {"1002", "1102", "1202", "1304", "1403", "1503", "1602", "1702"};
   while ((idt = (KVIDTelescope*)it())) {
      KVString N = idt->GetDetector(1)->GetName();
      N.Begin("_");
      KVString de_type = N.Next();
      KVString de_number = N.Next();
      if (idt->GetSize() == 1) {
         if (de_type == "PHOS") {
            idt->SetName(Form("%s_R_L_%s", de_type.Data(), de_number.Data()));
            idt->SetType(Form("%s_R_L", de_type.Data()));
         }
         else if(de_type == "SI")
         {
            idt->SetName(idt->GetDetector(1)->GetName());
            idt->SetType("SI");
         }
         else {
            // CsI identification telescopes are called either CSI_R_L_RRMM (before 2021)
            // or CSI_RRMM (for datasets from 2021 onwards)
            auto csi_id_name_fmt = KVBase::GetDataSetEnv<TString>(fDataSet, "INDRA.CSI.IDTelescopeNameFormat", "CSI_%s");
            idt->SetName(Form(csi_id_name_fmt, de_number.Data()));
            // similarly, the type of CSI identifications was CSI_R_L before 2021, CSI from 2021 onwards
            if (csi_id_name_fmt.Contains("R_L")) {
               idt->SetType("CSI_R_L");
               KVINDRAGroupReconstructor::CSI_ID_TYPE = "CSI_R_L";
            }
            else idt->SetType("CSI");
         }
      }
      else {
         N = idt->GetDetector(2)->GetName();
         N.Begin("_");
         KVString e_type = N.Next();
         KVString e_number = N.Next();
         if (e_type == "SILI" || e_type == "SI75") {
            e_number = etalon_numbers[dynamic_cast<KVINDRADetector*>(idt->GetDetector(2))->GetRingNumber() - 10];
         }
         idt->SetName(Form("%s_%s_%s", de_type.Data(), e_type.Data(), e_number.Data()));
         idt->SetType(Form("%s_%s", de_type.Data(), e_type.Data()));
      }
   }
   // changed names of all id telescope objects in hashlist: must rehash
   dynamic_cast<KVHashList*>(GetListOfIDTelescopes())->Rehash();
}
 
 
 
 
void KVINDRA::PerformClosedROOTGeometryOperations()
{
   // Finalise the ROOT geometry description by performing operations which can
   // only be done once the geometry is closed
 
   KVGeoImportINDRA gimp(gGeoManager, KVMaterial::GetRangeTable(), this);
   gimp.SetNameCorrespondanceList("INDRA.names");
   // INDRAGeometryBuilder instance holds list of directions to test for import which
   // corresponds to detectors which are actually present in array
   gimp.ImportGeometry(fIGB->GetDirectionsToTestForImport());
   fIGB->CheckImportResults(GetDetectors());
 
   FillListsOfDetectorsByType();
 
   SetNamesOfIDTelescopes();
 
   SetIdentifications();
 
   //set flag to say Build() was called
   SetBit(kIsBuilt);
 
   SetPinLasersForCsI();
 
   SetExpectedDetectorSignalNames();
 
   // link EBYEDAT parameter names to detectors
   TIter next_det(GetDetectors());
   KVDetector* det;
   while ((det = (KVDetector*)next_det())) {
      TString det_name(det->GetName());
      if (det_name.BeginsWith("CI") || det_name.BeginsWith("SI")) {
         fEbyedatParamDetMap.SetValue(det_name + "_PG", det_name);
         fEbyedatParamDetMap.SetValue(det_name + "_GG", det_name);
      }
      else if (det_name.BeginsWith("CSI")) {
         fEbyedatParamDetMap.SetValue(det_name + "_R", det_name);
         fEbyedatParamDetMap.SetValue(det_name + "_L", det_name);
      }
      // handle change of "time marker" parameter type for certain experiments
      auto time_marker_type = gDataSet->GetDataSetEnv<TString>(Form("KVACQParam.%s.T", det_name.Data()), "T");
      time_marker_type.Prepend("_");
      fEbyedatParamDetMap.SetValue(det_name + time_marker_type, det_name);
   }
}
 
 
 
 
void KVINDRA::handle_ebyedat_raw_data_parameter(const char* param_name, uint16_t val)
{
   KVString detname;
   KVDetector* det = nullptr;
   KVString sig_type;
   // use look-up table parname => detectorname
   if (fEbyedatParamDetMap.HasParameter(param_name)) {
      det = GetDetector(fEbyedatParamDetMap.GetStringValue(param_name));
      detname = det->GetName();
      // parameter type given by whatever comes after final '_'
      std::string lab(param_name);
      sig_type = lab.substr(lab.rfind('_') + 1);
   }
   else {   // no detector associated to parameter
      sig_type = param_name;
   }
   add_and_set_detector_signal(det, detname, val, sig_type);
}
 
 
 
 
void KVINDRA::copy_fired_parameters_to_recon_param_list()
{
   // Put values of all fired detector signals into the parameter list which will be copied
   // into the reconstructed event.
   //
   // If Mesytec data is being read, we set the parameter "INDRA.MESYTEC", or if Ebyedat data, "INDRA.EBYEDAT".
   // Note that in old reconstructed data these parameters did not exist, therefore in their
   // absence EBYEDAT is assumed.
 
   if (fMesytecData) fReconParameters.SetValue("INDRA.MESYTEC", kTRUE);
   else if (fEbyedatData) fReconParameters.SetValue("INDRA.EBYEDAT", kTRUE);
   KVMultiDetArray::copy_fired_parameters_to_recon_param_list();
}
 
 
 
 
void KVINDRA::ReadChIoPressures(KVExpDB* db)
{
   // Read ChIo pressures from a file with the following format:
   //
   //~~~
   //PressureSet: A
   //A.RunList: 1-22
   //A.CI_02: 50.0
   //A.CI_04: 30.0
   //A.CI_06: 20.0
   //
   //+PressureSet: B
   //B.Units: torr
   //B.RunList: 23-50
   //B.CI_08: 33.0
   //B.CI_13: 11.6
   //~~~
   //
   // `Units` can be either `mbar` or `torr`: `mbar` is used by default (e.g. for set `A` in the example).
   //
   // The different ionization chambers are designated by `CI_02`, `CI_04`, `CI_06`, `CI_08`, `CI_13`
   // The same pressure will be applied to all cells of each ChIo which are present in the current geometry.
   //
   // If `RunList` is not given, the pressures will be applied to all runs in the database.
 
   TString fullpath;
   if (!db->FindCalibFile("Pressures", fullpath, "INDRA")) return;
   Info("ReadChIoPressures()", "Reading INDRA ChIo pressures used during runs...");
 
   auto pressure_table = db->AddTable("INDRA.ChIo Pressures", "INDRA ChIo gas pressures");
 
   KVString the_chios[] = {"CI_02", "CI_04", "CI_06", "CI_08", "CI_13"};
 
   TEnv env;
   env.ReadFile(fullpath.Data(), kEnvAll);
   KVString pressure_sets = env.GetValue("PressureSet", "");
   pressure_sets.Begin(" ");
   while (!pressure_sets.End()) {
      auto pressure_set = pressure_sets.Next();
      // set units
      auto units = KVUnits::mbar;
      if (KVString(env.GetValue(Form("%s.Units", pressure_set.Data()), "mbar")) != "mbar")
         units = KVUnits::torr;
      // set runlist if given
      KVNumberList runlist(env.GetValue(Form("%s.RunList", pressure_set.Data()), ""));
      if (runlist.IsEmpty()) runlist = db->GetRunList();
      // get and set pressures
      auto dbp = new KVDBChIoPressures;
      int ichio = 0;
      for (auto& chio : the_chios) {
         Float_t P = 0;
         if ((P = env.GetValue(Form("%s.%s", pressure_set.Data(), chio.Data()), 0.0)) > 0.0) {
            dbp->SetPressure(ichio, P * units);
         }
         ++ichio;
      }
      pressure_table->AddRecord(dbp);
      db->LinkRecordToRunRange(dbp, runlist);
   }
}
 
 
 
 
void KVINDRA::SetChIoPressures(KVDBRun* kvrun)
{
   //Update ChIo pressures for this run with values in database (if any)
   //
   //Any ChIo with zero pressure has KVDetector::IsDetecting() set to false
   //(and hence KVDetector::IsOK() will also return false).
 
   KVRList* param_list = kvrun->GetLinks("INDRA.ChIo Pressures");
   if (!param_list) {
      return;
   }
   KVChIo* kvd;
   KVDBChIoPressures* kvps;
   TIter next_ps(param_list);
   auto chios = GetListOfChIo();
   if (!chios) {
      Error("SetChIoPressures",
            "GetListOfChIo() returns null list pointer");
      return;
   }
   cout << "--> Setting ChIo pressures" << endl;
   TIter next_chio(chios);
   while ((kvps = (KVDBChIoPressures*) next_ps())) {
      if (kvps->GetPressure(CHIO_2_3))
         cout << "       Ring 2/3: " << kvps->
              GetPressure(CHIO_2_3) / KVUnits::mbar << " mbar" << endl;
      if (kvps->GetPressure(CHIO_4_5))
         cout << "       Ring 4/5: " << kvps->
              GetPressure(CHIO_4_5) / KVUnits::mbar << " mbar" << endl;
      if (kvps->GetPressure(CHIO_6_7))
         cout << "       Ring 6/7: " << kvps->
              GetPressure(CHIO_6_7) / KVUnits::mbar << " mbar" << endl;
      if (kvps->GetPressure(CHIO_8_12))
         cout << "      Ring 8/12: " << kvps->
              GetPressure(CHIO_8_12) / KVUnits::mbar << " mbar" << endl;
      if (kvps->GetPressure(CHIO_13_17))
         cout << "     Ring 13/17: " << kvps->
              GetPressure(CHIO_13_17) / KVUnits::mbar << " mbar" << endl;
      while ((kvd = (KVChIo*) next_chio())) {
         if (!strcmp(kvd->GetType(), "CI")) {
            //check detector type: ="CI" for standard INDRA chio
            if (kvd->GetRingNumber() == 2)
               kvd->SetPressure(kvps->GetPressure(CHIO_2_3) / KVUnits::mbar);
            if (kvd->GetRingNumber() == 4)
               kvd->SetPressure(kvps->GetPressure(CHIO_4_5) / KVUnits::mbar);
            if (kvd->GetRingNumber() == 6)
               kvd->SetPressure(kvps->GetPressure(CHIO_6_7) / KVUnits::mbar);
            if (kvd->GetRingNumber() >= 8 && kvd->GetRingNumber() <= 12)
               kvd->SetPressure(kvps->GetPressure(CHIO_8_12) / KVUnits::mbar);
            if (kvd->GetRingNumber() >= 13 && kvd->GetRingNumber() <= 17)
               kvd->SetPressure(kvps->GetPressure(CHIO_13_17) / KVUnits::mbar);
            if (kvd->GetPressure() == 0.0) {
               kvd->SetDetecting(kFALSE);
            }
            else {
               kvd->SetDetecting(kTRUE);
            }
         }
      }
      next_chio.Reset();
   }
}
 
 
 
 
void KVINDRA::SetDetectorParametersForRun(KVDBRun* dbr, const TString& myname)
{
   // Override base method in order to set ChIo pressures (if defined)
   KVMultiDetArray::SetDetectorParametersForRun(dbr, myname);
   SetChIoPressures(dbr);
}
 
 
 
 
void KVINDRA::BuildGeometry()
{
   CreateGeoManager();
 
   fIGB.reset(new INDRAGeometryBuilder(fDataSet, fCurrentRun));
   fIGB->Build(kFALSE, fCloseGeometryNow);
 
   SetName(fIGB->GetName());
   SetTitle(fIGB->GetTitle());
}
 
 
#ifdef WITH_BUILTIN_GRU
 
 
Bool_t KVINDRA::handle_raw_data_event_ebyedat(KVGANILDataReader& rdr)
{
   // Set raw data in detectors/array coming from a GANIL EBYEDAT format
   // acquisition file.
 
   fEbyedatData = kTRUE;
   // loop over fired data parameters
   TIter nxt_frd(&rdr.GetFiredDataParameters());
   KVEBYEDAT_ACQParam* eby_par;
   while ((eby_par = (KVEBYEDAT_ACQParam*)nxt_frd())) {
      handle_ebyedat_raw_data_parameter(eby_par->GetName(), eby_par->GetData());
   }
 
   return kTRUE;
}
 
#endif
 
#ifdef WITH_MFM
 
 
Bool_t KVINDRA::handle_raw_data_event_mfmframe_ebyedat(const MFMEbyedatFrame& f)
{
   // General method for reading raw data in MFM-encapsulated ebyedat format
   // Fills list of hit acquisition parameters.
   // Returns kTRUE if at least one parameter belonging to the array is present.
   //
   // Any unknown parameters in the event (i.e. ones for which no KVACQParam object
   // has been defined) are written in the fReconParameters list with names
   //    "ACQPAR.[array name].[parameter name]"
   //
   // Retrieve CENTRUM timestamp from data if present.
   // It will be added to fReconParameters as a 64-bit value "INDRA.TS" (if != 0)
   // Event number is retrieved and stored as "INDRA.EN" (if != 0)
   // Any parameter which appears as [name] and [name]_UP is an unsigned 32-bit value
   // split into two 16-bit words. We replace the two parameters with a 64-bit
   // value (to hold correctly all unsigned 32-bit values) with [name].
 
   fEbyedatData = kTRUE;
 
   uint16_t val;
   std::string lab;
 
   for (int i = 0; i < f.GetNbItems(); ++i) {
      f.GetDataItem(i, lab, val);
      handle_ebyedat_raw_data_parameter(lab.c_str(), val);
   }
 
   ULong64_t ts = f.GetCENTRUMTimestamp();
   if (ts != 0) fReconParameters.SetValue64bit("INDRA.TS", ts);
   ULong64_t en = f.GetEventNumber();
   if (en != 0) fReconParameters.SetValue64bit("INDRA.EN", en);
   int npars = fReconParameters.GetNpar();
   std::vector<TString> names;
   for (int i = 0; i < npars; ++i) {
      TString name = fReconParameters.GetParameter(i)->GetName();
      if (name.EndsWith("_UP")) names.push_back(name);
   }
   if (names.size()) {
      for (std::vector<TString>::iterator it = names.begin(); it != names.end(); ++it) {
         TString name = (*it);
         name.Remove(name.Index("_UP"), 3);
         TString name_up = (*it);
         ULong64_t par_up = fReconParameters.GetIntValue(name_up);
         ULong64_t par = fReconParameters.GetIntValue(name);
         UInt_t par32 = (par_up << 16) + par;
         fReconParameters.RemoveParameter(name_up);
         fReconParameters.RemoveParameter(name);
         fReconParameters.SetValue64bit(name, par32);
      }
   }
   return kTRUE;
}
 
#endif
 
 
 
void KVINDRA::SetIDCodeForIDTelescope(KVIDTelescope* idt) const
{
   // Set the INDRA-specific general identification code for the given telescope
 
   if (idt->IsType("PHOS_R_L")) idt->SetIDCode(IDCodes::ID_PHOSWICH);
   else if (idt->IsType("CSI_R_L") || idt->IsType("CSI")) idt->SetIDCode(IDCodes::ID_CSI_PSA);
   else if (idt->IsType("SI_CSI")) idt->SetIDCode(IDCodes::ID_SI_CSI);
   else if (idt->IsType("SI")) idt->SetIDCode(IDCodes::ID_SI_PSA);
   else if (idt->IsType("CI_SI")) idt->SetIDCode(IDCodes::ID_CI_SI);
   else if (idt->IsType("CI_CSI")) idt->SetIDCode(IDCodes::ID_CI_CSI);
   else if (idt->IsType("CI_SI75")) idt->SetIDCode(IDCodes::ID_CI_SI75);
   else if (idt->IsType("SI75_SILI")) idt->SetIDCode(IDCodes::ID_SI75_SILI);
   else if (idt->IsType("SILI_CSI")) idt->SetIDCode(IDCodes::ID_SILI_CSI);
   else {
      Error("SetIDCodeForIDTelescope", "Request for telescope name=%s of unknown class=%s",
            idt->GetName(), idt->IsA()->GetName());
   }
}
 
 
 
 
TString KVINDRA::GetCsIIDType() const
{
   return KVINDRAGroupReconstructor::CSI_ID_TYPE;
}
 
 
 
 
void KVINDRA::SetPinLasersForCsI()
{
   // Sets the KVCsI::fPinLaser member of each CsI detector with the number of the
   // pin laser associated for the stability control of these detectors.
   //
   // We look for a file with the following format:
   //
   // CSI_0101     1
   // CSI_0102     1
   // CSI_0103     1
   // CSI_0104     1
   // etc.
   //
   // i.e. 'name of CsI detector'   'number of pin laser (1-8)'
   // Comment lines must begin with '#'
   //
   // The default name of this file is defined in .kvrootrc by
   //
   // INDRADB.CsIPinCorr:          CsI_PILA.dat
   //
   // Dataset-specific version can be specified:
   //
   // INDRA_e999.INDRADB.CsIPinCorr:    CorrCsIPin_2054.dat
   //
   // This file should be in the directory corresponding to the current dataset,
   // i.e. in $KVROOT/KVFiles/name_of_dataset
 
   ifstream pila_file;
   if (gDataSet->OpenDataSetFile(gDataSet->GetDataSetEnv<TString>("INDRADB.CsIPinCorr"), pila_file)) {
 
      Info("SetPinLasersForCsI", "Setting correspondance CsI-PinLaser using file %s.",
           gDataSet->GetDataSetEnv<TString>("INDRADB.CsIPinCorr").Data());
      // read file, set correspondance
      KVString line;
      line.ReadLine(pila_file);
      while (pila_file.good()) {
         if (!line.BeginsWith("#")) {
            line.Begin(" ");
            KVString detname = line.Next(kTRUE);
            KVCsI* det = (KVCsI*)GetDetector(detname.Data());
            Int_t pila = line.Next(kTRUE).Atoi();
            if (det) {
               det->SetPinLaser(pila);
            }
         }
         line.ReadLine(pila_file);
      }
      pila_file.close();
   }
}
 
 
 
 
 
void KVINDRA::GetDetectorEvent(KVDetectorEvent* detev, const TSeqCollection* fired_dets)
{
   // Overrides KVASMultiDetArray::GetDetectorEvent.
   // If the list of fired detectors is given (meaning we are reading raw data)
   // then we check that what we have read is in fact an INDRA event
   // (see KVINDRATriggerInfo::IsINDRAEvent()) : if not, we do not try to find the hit groups.
 
   if (((fired_dets && fired_dets->GetEntries()) || fFiredDetectors.GetEntries())
         && (GetTriggerInfo() && !GetTriggerInfo()->IsINDRAEvent())) return;
   KVMultiDetArray::GetDetectorEvent(detev, fired_dets);
}
 
 
 
 
 
KVGroupReconstructor* KVINDRA::GetReconstructorForGroup(const KVGroup* g) const
{
   // Special INDRA group reconstructors:
   //
   // * for data:
   //    - KVINDRAForwardGroupReconstructor       rings 1-9
   //    - KVINDRABackwardGroupReconstructor      rings 10-17
   //    - KVINDRAEtalonGroupReconstructor        for groups with etalon telescopes
   //
   // * for filtered simulations:
   //    - KVINDRAFilterGroupReconstructor
   //    - KVINDRAFilterEtalonGroupReconstructor for groups with etalon telescopes
 
   KVGroupReconstructor* gr(nullptr);
   if (GetGroup(g->GetName())) { // make sure group belongs to us
      // etalons ?
      if (g->GetDetectorByType("SILI") || g->GetDetectorByType("SI75")) {
         if (IsSimMode())
            gr = KVGroupReconstructor::Factory("INDRA.etalonFilter", g);
         else
            gr = KVGroupReconstructor::Factory("INDRA.etalon", g);
      }
      else {
         if (IsSimMode()) return KVGroupReconstructor::Factory("INDRA.Filter", g);
         KVINDRADetector* id = (KVINDRADetector*)g->GetDetectors()->First();
         if (id->GetRingNumber() < 10) {
            gr = KVGroupReconstructor::Factory("INDRA.forward", g);
         }
         else {
            gr = KVGroupReconstructor::Factory("INDRA.backward", g);
         }
      }
   }
   return gr;
}
 
 
 
 
void KVINDRA::SetReconParametersInEvent(KVReconstructedEvent* e) const
{
   // If "INDRA.EN" parameter has been set, we use it to set the event number
 
   KVMultiDetArray::SetReconParametersInEvent(e);
   if (GetReconParameters().HasValue64bit("INDRA.EN")) e->SetNumber(GetReconParameters().GetValue64bit("INDRA.EN"));
}
 
 
 
 
void KVINDRA::SetRawDataFromReconEvent(KVNameValueList& l)
{
   // Overrides base method in KVMultiDetArray.
   //
   // If we are reading old reconstructed data with EBYEDAT parameters, we need special
   // treatment to decode the detector name & signal type.
 
   if (!l.GetBoolValue("INDRA.MESYTEC") && !l.GetBoolValue("INDRA.EBYEDAT")) {
      // assume we are reading old recon data with parameters in list such as "ACQPAR.INDRA.SI_0201_PG"
      fMesytecData = kFALSE;
      fEbyedatData = kTRUE;
      prepare_to_handle_new_raw_data();
 
      int N = l.GetNpar();
      for (int i = 0; i < N; ++i) {
         KVNamedParameter* np = l.GetParameter(i);
 
         KVString name(np->GetName());
         if (name.BeginsWith("ACQPAR")) {
            // 2 '.' => 3 values
            int dots = name.GetNValues(".");
            assert(dots == 3); // sanity check
            name.Begin(".");
            name.Next(); // "ACQPAR"
            if (name.Next() != "INDRA") continue; // check name of array - somebody else's parameter ?
            std::string parname(name.Next());
            KVString detname;
            KVString sig_type;
            KVDetector* det = nullptr;
            if (parname.find('_') != kNPOS) {
               // try to split into '[detname]_[partype]'
               detname = parname.substr(0, parname.rfind('_'));
               sig_type = parname.substr(parname.rfind('_') + 1);
               det = GetDetector(detname);
            }
            else {
               sig_type = parname;
            }
            add_and_set_detector_signal(det, detname, np->GetDouble(), sig_type);
         }
      }
   }
   else {
      fMesytecData = l.GetBoolValue("INDRA.MESYTEC");
      fEbyedatData = l.GetBoolValue("INDRA.EBYEDAT");
      KVMultiDetArray::SetRawDataFromReconEvent(l);
   }
}
 
 
 
 
void KVINDRA::MakeCalibrationTables(KVExpDB* db)
{
   // Override base method in order to read ChIo pressures for each run
   KVMultiDetArray::MakeCalibrationTables(db);
   // if the actual database class inherits from KVINDRADB (historic INDRA data),
   // the ChIo pressures have already been read (& from a file with a different format)
   if (!db->InheritsFrom("KVINDRADB")) ReadChIoPressures(db);
}
 
 
 
 
void KVINDRA::InitialiseRawDataReading(KVRawDataReader* r)
{
   // Call this method just after opening a raw data file in order to perform any
   // necessary initialisations, depending on the type of data
   //
   // Mesytec data:
   // =============
   // Reading data from Mesytec DAQ requires crate map & detector-channel correspondence files,
   // the latter of which may be run-dependent.
   //
   // Each dataset has to provide the necessary files, as well as a file containing the run-dependent
   // list of detector-channel correspondence files.
   //
   // The names of the files are given by the following dataset variables, if defined:
   //~~~
   //[dataset].MesytecCrateConf:         [name of crate map file:default="mesytec_crate_map.dat"]
   //[dataset].MesytecChannelsConf:      [name of detector-channel correspondence file:default="mesytec_detector_correspondence.dat"]
   //[dataset].MesytecChannelsConfList:  [list of run-dependent detector-channel correspondence files:default="mesytec_conf_list.dat"]
   //~~~
   //
   // If given, the run-dependent list of configuration files should be like:
   //~~~
   //File: [file1]
   //[file1].RunList: [list of runs]
   //
   //+File: [file2]
   //[file2]:RunList: [list of runs]
   //~~~
   // If not given we assume the same crate map and detector-channel correspondence for all runs.
   //
   // If the required files are not found for the dataset, an exception will be thrown.
 
   KVMultiDetArray::InitialiseRawDataReading(r);
 
   fMesytecData = kFALSE;
   fEbyedatData = kFALSE;
#ifdef WITH_MESYTEC
#ifdef WITH_MFM
   if (r->GetDataFormat() == "MFM") {
      auto crate = gDataSet->GetDataSetEnv<TString>("MesytecCrateConf", "mesytec_crate_map.dat");
 
      // check file exists for dataset
      if(!gDataSet->FindDataSetFile(crate))
         throw std::runtime_error(Form("in <KVINDRA::InitialiseRawDataReading>: Mesytec crate map file %s not found in dataset directory %s",
                                       crate.Data(), gDataSet->GetDataSetDir()));
 
      Info("InitialiseRawDataReading", "Setting Mesytec crate config for run %d, raw run number=%d",
           GetCurrentRunNumber(), r->GetRunNumberReadFromFile());
 
      auto raw_run_number = r->GetRunNumberReadFromFile()>0 ? r->GetRunNumberReadFromFile() : GetCurrentRunNumber();
      auto channel_conf_list = gDataSet->GetDataSetEnv<TString>("MesytecChannelsConfList","mesytec_conf_list.dat");
      // do we have a run-dependent detector-channel correspondence ?
      if(gDataSet->FindDataSetFile(channel_conf_list))
      {
         TEnv conf_list;
         conf_list.ReadFile(gDataSet->GetFullPathToDataSetFile(channel_conf_list), kEnvUser);
         KVString files = conf_list.GetValue("File", "");
         files.Begin(" ");
         while (!files.End()) {
            KVString next_file = files.Next(kTRUE);
            KVNumberList runlist = conf_list.GetValue(Form("%s.RunList", next_file.Data()), "");
            if (runlist.Contains(raw_run_number)) {
               // check file exists
               if(!gDataSet->FindDataSetFile(next_file))
                  throw std::runtime_error(Form("in <KVINDRA::InitialiseRawDataReading>: Mesytec detector-channel correspondence file %s not found in dataset directory %s",
                                                next_file.Data(), gDataSet->GetDataSetDir()));
               // found file for this run
               Info("InitialiseRawDataReading", "Using file %s for raw run number %d",
                    next_file.Data(), raw_run_number);
               dynamic_cast<KVMFMDataFileReader*>(r)->InitialiseMesytecConfig(
                        gDataSet->GetFullPathToDataSetFile(crate).Data(),
                        gDataSet->GetFullPathToDataSetFile(next_file).Data()
                        );
            }
         }
      }
      else
      {
         // single detector-correspondence for all runs of dataset
         auto conf = gDataSet->GetDataSetEnv<TString>("MesytecChannelsConf","mesytec_detector_correspondence.dat");
         // check file exists for dataset
         if(!gDataSet->FindDataSetFile(conf))
            throw std::runtime_error(Form("in <KVINDRA::InitialiseRawDataReading>: Mesytec detector-channel correspondence file %s not found in dataset directory %s",
                                          conf.Data(), gDataSet->GetDataSetDir()));
         Info("InitialiseRawDataReading", "Using file %s for raw run number %d",
              conf.Data(), raw_run_number);
         dynamic_cast<KVMFMDataFileReader*>(r)->InitialiseMesytecConfig(
                  gDataSet->GetFullPathToDataSetFile(crate).Data(),
                  gDataSet->GetFullPathToDataSetFile(conf).Data());
      }
   }
#endif
#endif
}
 
 
#ifdef WITH_MFM
 
 
#ifdef WITH_MESYTEC
Bool_t KVINDRA::handle_raw_data_event_mfmframe_mesytec_mdpp(const MFMMesytecFrame& f)
{
   // Read a raw data event from a Mesytec MFM Frame.
   //
   // All data is transferred to KVDetectorSignal objects, either associated to detectors of the
   // array (if they can be identified), either associated more globally with the array/event
   // itself. The latter are created as needed and go into the fExtraRawDataSignals list.
 
   if (!fMesytecData) {
      // first time we read data, we tweak the parameter names
      mesytec::module::set_data_type_alias("qdc_long", "TotLight"); // => CsI
      mesytec::module::set_data_type_alias("qdc_short", "R"); // => like old CsI 'R' (rapide) parameter
      mesytec::module::set_data_type_alias("tdc", "T"); // => like old 'marqueur de temps' parameters
      mesytec::module::set_data_type_alias("adc", "ADC"); // => Si or ChIo signals
 
      fMesytecData = kTRUE;
   }
   fReconParameters.SetValue64bit("INDRA.TS", f.GetTimeStamp());
   auto mfmfilereader = dynamic_cast<KVMFMDataFileReader*>(fRawDataReader);
   mfmfilereader->GetMesytecBufferReader().read_event_in_buffer(
      (const uint8_t*)f.GetPointUserData(), f.GetBlobSize(),
   [ = ](const mesytec::event & evt, const mesytec::experimental_setup & setup) {
      // loop over module data in event, set data in detectors when possible
 
      for (auto& mdat : evt.get_module_data()) {
         auto mod_id = mdat.get_module_id();
         auto& current_module = setup.get_module(mod_id);
         if (current_module.is_mdpp_module()) {
            // data for detectors from MDPP module
            for (auto& voie : mdat.get_channel_data()) {
               KVString detname(setup.get_detector(mod_id, voie.get_channel_number()));
               KVString sig_type(current_module.get_data_type_name(voie.get_data_type()));
               Double_t sig_data = voie.get_data();
               // convert time markers to nanoseconds
               if(voie.get_data_type()==mesytec::module::datatype_t::TDC)
               {
                  sig_data *= current_module.get_tdc_resolution();
               }
               add_and_set_detector_signal(GetDetector(detname), detname, sig_data, sig_type);
               if(voie.has_trace())
               {
                  // signal trace data from MDPP - assume fixed 12.5 ns time step
                  add_and_set_detector_signal_trace(GetDetector(detname), voie.get_trace(), 12.5);
               }
            }
         }
         else if (current_module.is_mvlc_scaler()) {
            // data from 64 bit scalers in MVLC
            //
            // 4 data words of 16 bits (least significant is first word) => 64 bit scaler
            if (mdat.get_channel_data().size() == 4) {
               ULong64_t x = 0;
               int i = 0;
               for (auto& d : mdat.get_channel_data()) x += ((uint64_t)d.get_data_word()) << (16 * (i++));
               fReconParameters.SetValue64bit(current_module.name.c_str(), x);
            }
         }
      }
   },
   f.GetRevision()
   );
   return kTRUE;
}
 
#endif
#endif
 
 
 
void KVINDRA::set_detector_thicknesses(const TString& fullpath)
{
   // Use file given by fullpath to set the real thicknesses of the detectors.
   //
   // Any detector which is not in the file will be left with its nominal thickness.
   //
   // See KVMultiDetArray::set_detector_thicknesses() for more info on file format.
   // Unlike KVMultiDetArray::set_detector_thicknesses() however, here only the active layer thickness
   // for different detectors can be specified, not the full set of asbsorber thicknesses for a multi-layer
   // detector.
   //
   // NOTE: KVINDRA::SetDetectorThicknesses() will not actually change the thickness of any
   // detector (unlike KVMultiDetArray::SetDetectorThicknesses() which changes directly both the
   // the KVDetector thicknesses and the size of the associated TGeoShape in the geometry).
   // As it is too difficult to modify the INDRA geometry after it is built, all detector thicknesses
   // have to be known before the geometry is created. Therefore this method is called to read in and
   // store any informations in the INDRAGeometryBuilder before building the geometry.
 
   TEnv thickdat;
   if (thickdat.ReadFile(fullpath, kEnvUser) != 0) {
      Error("SetDetectorThicknesses", "Problem opening file %s", fullpath.Data());
      return;
   }
   Info("SetDetectorThicknesses", "Reading thicknesses of detectors from file %s", fullpath.Data());
 
   TIter it(thickdat.GetTable());
   TEnvRec* rec;
   while ((rec = (TEnvRec*)it())) {
      KVString val = rec->GetValue();
      if (!val.IsFloat()) {
         Warning("SetDetectorThicknesses", "Non-numeric value %s given for thickness of detector %s : no change",
                 val.Data(), rec->GetName());
      }
      else {
         if (TString(rec->GetName()).BeginsWith("SI")) // "SI", "SI75", "SILI" thicknesses given in microns
            fIGB->SetDetectorThickness(rec->GetName(), val.Atof()*KVUnits::um);
         else
            fIGB->SetDetectorThickness(rec->GetName(), val.Atof());
      }
   }
}