* Adding Data and Physics class for RIBF Plastic

NPLib/Detectors/BigRIPS/BigRIPSPlasticVariables.h

+#ifndef BIGRIPSPlasticVariables_H
+#define BIGRIPSPlasticVariables_H
+
+/*****************************************************************************
+ * Copyright (C) 2009-2020    this file is part of the NPTool Project        *
+ *                                                                           *
+ * For the licensing terms see $NPTOOL/Licence/NPTool_Licence                *
+ * For the list of contributors see $NPTOOL/Licence/Contributors             *
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Original Author: Freddy Flavigny  contact: flavigny@lpccaen.in2p3.fr      *
+ *                                                                           *
+ * Creation Date  : October 2020                                             *
+ * Last update    :                                                          *
+ *---------------------------------------------------------------------------*
+ * Decription:                                                               *
+ *  This class aims at holding Plastic data after pretreatment               *
+ *                                                                           *
+ *---------------------------------------------------------------------------*
+ * Comment:                                                                  *
+ *                                                                           *  
+ *  Intermediate class necessary to hold all variables per detector per event*
+ *  Different from TPlasticData whose variable (vectors) are independent     *
+ *                                                                           *
+ *****************************************************************************/
+
+#include <iostream>
+using namespace std;
+
+class BigRIPSPlasticVariables{
+  public:
+   BigRIPSPlasticVariables(){Clear();};  
+   ~BigRIPSPlasticVariables(){};  
+
+  public:
+    std::vector<double> FTL;
+    std::vector<double> FTR;
+    std::vector<double> FQL;
+    std::vector<double> FQR;
+    int FmultiHit[4];
+
+    void Clear(){
+        FTL.clear();
+        FTR.clear();
+        FQL.clear();
+        FQR.clear();
+        for(int i=0; i<4; i++) FmultiHit[i]=0;
+    };
+
+    void Print(){
+        //cout << "XXXXXXXXXXXXXXXXXXXXXXXX Plastic Event XXXXXXXXXXXXXXXXX" << endl;
+        cout << "FTL_Mult = " << FTL.size();
+        for (UShort_t i = 0; i < FTL.size(); i++){cout << "\tFTL: " << FTL[i] << endl;}
+        cout << "FTR_Mult = " << FTR.size();
+        for (UShort_t i = 0; i < FTR.size(); i++){cout << "\tFTR: " << FTR[i] << endl;}
+        cout << "FQL_Mult = " << FQL.size();
+        for (UShort_t i = 0; i < FQL.size(); i++){cout << "\tFQL: " << FQL[i] << endl;}
+        cout << "FQR_Mult = " << FQR.size();
+        for (UShort_t i = 0; i < FQR.size(); i++){cout << "\tFQR: " << FQR[i] << endl;}
+        cout << "MultHit = " <<endl;
+        for (UShort_t i = 0; i <4; i++){cout << FmultiHit[i] << endl;}
+    }
+
+    bool HasTLandQL(){
+        if(FTL.size()==1 && FQL.size()==1){return true;}
+        else{return false;}
+    }
+    bool HasTRandQR(){
+        if(FTR.size()==1 && FQR.size()==1){return true;}
+        else{return false;}
+    }
+    bool HasTLandTR(){
+        if(FTL.size()==1 && FTR.size()==1){return true;}
+        else{return false;}
+    }
+    bool HasQLandQR(){
+        if(FQL.size()==1 && FQR.size()==1){return true;}
+        else{return false;}
+    }
+    bool HasEverything(){
+        if(FTL.size()==1 && FTR.size()==1 &&
+           FQL.size()==1 && FQR.size()==1){
+            return true;
+        }else{return false;}
+    }
+  };
+
+#endif

NPLib/Detectors/BigRIPS/CMakeLists.txt

@@ -2,8 +2,12 @@ add_custom_command(OUTPUT TBigRIPSPPACDataDict.cxx COMMAND ${CMAKE_BINARY_DIR}/s
 
 add_custom_command(OUTPUT TBigRIPSPPACPhysicsDict.cxx COMMAND ${CMAKE_BINARY_DIR}/scripts/build_dict.sh TBigRIPSPPACPhysics.h TBigRIPSPPACPhysicsDict.cxx TBigRIPSPPACPhysics.rootmap libNPBigRIPS.dylib DEPENDS TBigRIPSPPACPhysics.h)
 
-add_library(NPBigRIPS SHARED TBigRIPSPPACData.cxx TBigRIPSPPACDataDict.cxx TBigRIPSPPACPhysics.cxx TBigRIPSPPACPhysicsDict.cxx)
+add_custom_command(OUTPUT TBigRIPSPlasticDataDict.cxx COMMAND ${CMAKE_BINARY_DIR}/scripts/build_dict.sh TBigRIPSPlasticData.h TBigRIPSPlasticDataDict.cxx TBigRIPSPlasticData.rootmap libNPBigRIPS.dylib DEPENDS TBigRIPSPlasticData.h)
+
+add_custom_command(OUTPUT TBigRIPSPlasticPhysicsDict.cxx COMMAND ${CMAKE_BINARY_DIR}/scripts/build_dict.sh TBigRIPSPlasticPhysics.h TBigRIPSPlasticPhysicsDict.cxx TBigRIPSPlasticPhysics.rootmap libNPBigRIPS.dylib DEPENDS TBigRIPSPlasticPhysics.h)
+
+add_library(NPBigRIPS SHARED TBigRIPSPPACData.cxx TBigRIPSPPACDataDict.cxx TBigRIPSPPACPhysics.cxx TBigRIPSPPACPhysicsDict.cxx TBigRIPSPlasticData.cxx TBigRIPSPlasticDataDict.cxx TBigRIPSPlasticPhysics.cxx TBigRIPSPlasticPhysicsDict.cxx )
 
 target_link_libraries(NPBigRIPS ${ROOT_LIBRARIES} NPCore NPTrackReconstruction) 
-install(FILES TBigRIPSPPACData.h TBigRIPSPPACPhysics.h  DESTINATION ${CMAKE_INCLUDE_OUTPUT_DIRECTORY})
+install(FILES TBigRIPSPPACData.h TBigRIPSPPACPhysics.h TBigRIPSPlasticData.h TBigRIPSPPACPhysics.h DESTINATION ${CMAKE_INCLUDE_OUTPUT_DIRECTORY})
 

NPLib/Detectors/BigRIPS/TBigRIPSPlasticData.cxx

+#include "TBigRIPSPlasticData.h"
+#include <iostream>
+
+TBigRIPSPlasticData::TBigRIPSPlasticData(){};
+TBigRIPSPlasticData::~TBigRIPSPlasticData(){};
+
+
+////////////////////////////////////////////////////////////////////////////////
+void TBigRIPSPlasticData::Clear(){
+  fPlastic_TL.clear(); 
+  fPlastic_TR.clear(); 
+  fPlastic_QL.clear(); 
+  fPlastic_QR.clear(); 
+
+  fPlastic_TL_ID.clear(); 
+  fPlastic_TR_ID.clear(); 
+  fPlastic_QL_ID.clear(); 
+  fPlastic_QR_ID.clear(); 
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void TBigRIPSPlasticData::Print(){
+  using namespace std;
+
+  cout << " -- Event:" << endl;
+  //cout << "   - Multiplicity: " << Mult() << endl;
+
+}
+ClassImp(TBigRIPSPlasticData); 

NPLib/Detectors/BigRIPS/TBigRIPSPlasticData.h

+#ifndef TBigRIPSPlasticData_H
+#define TBigRIPSPlasticData_H
+#include "TObject.h"
+#include <vector>
+class TBigRIPSPlasticData: public TObject{
+  public:
+    TBigRIPSPlasticData();
+    ~TBigRIPSPlasticData();
+
+  private:
+    std::vector<int> fPlastic_TL;
+    std::vector<int> fPlastic_TR;
+    std::vector<int> fPlastic_QL;
+    std::vector<int> fPlastic_QR;
+
+    std::vector<int> fPlastic_TL_ID;
+    std::vector<int> fPlastic_TR_ID;
+    std::vector<int> fPlastic_QL_ID;
+    std::vector<int> fPlastic_QR_ID;
+
+  public:
+    void Clear();
+    void Print();
+    void Clear(const Option_t*) {};
+    void Dump() const{};
+  
+  public:
+    void SetTL(const int& T, const int& ID){fPlastic_TL.push_back(T);fPlastic_TL_ID.push_back(ID);}
+    void SetTR(const int& T, const int& ID){fPlastic_TR.push_back(T);fPlastic_TR_ID.push_back(ID);}
+
+    void SetQL(const int& Q, const int& ID){fPlastic_QL.push_back(Q);fPlastic_QL_ID.push_back(ID);}
+    void SetQR(const int& Q, const int& ID){fPlastic_QR.push_back(Q);fPlastic_QR_ID.push_back(ID);}
+
+    int GetTLMult() const {return fPlastic_TL_ID.size();}
+    int const GetTL(const unsigned int& i){return fPlastic_TL[i];};
+    int const GetTLID(const unsigned int& i){return fPlastic_TL_ID[i];};
+
+    int GetTRMult() const {return fPlastic_TR_ID.size();}
+    int const GetTR(const unsigned int& i){return fPlastic_TR[i];};
+    int const GetTRID(const unsigned int& i){return fPlastic_TR_ID[i];};
+
+    int GetQLMult() const {return fPlastic_QL_ID.size();}
+    int const GetQL(const unsigned int& i){return fPlastic_QL[i];};
+    int const GetQLID(const unsigned int& i){return fPlastic_QL_ID[i];};
+
+    int GetQRMult() const {return fPlastic_QR_ID.size();}
+    int const GetQR(const unsigned int& i){return fPlastic_QR[i];};
+    int const GetQRID(const unsigned int& i){return fPlastic_QR_ID[i];};
+
+    ClassDef(TBigRIPSPlasticData,1); 
+};
+
+#endif

NPLib/Detectors/BigRIPS/TBigRIPSPlasticPhysics.cxx

+/*****************************************************************************
+ * Copyright (C) 2009-2016   this file is part of the NPTool Project         *
+ *                                                                           *
+ * For the licensing terms see $NPTOOL/Licence/NPTool_Licence                *
+ * For the list of contributors see $NPTOOL/Licence/Contributors             *
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Original Author: F, Flavigny   contact address: flavigny@lpccaen.in2p3.fr *
+ *                                                                           *
+ * Creation Date  : April 2021                                               *
+ * Last update    :                                                          *
+ *---------------------------------------------------------------------------*
+ * Decription:                                                               *
+ *  This class hold RIBF Plastic treated data                                *
+ *                                                                           *
+ *---------------------------------------------------------------------------*
+ * Comment:                                                                  *
+ *                                                                           *
+ *****************************************************************************/
+#include "TBigRIPSPlasticPhysics.h"
+
+//   STL
+#include <sstream>
+#include <iostream>
+#include <cmath>
+#include <stdlib.h>
+#include <limits>
+
+//   NPL
+#include "RootInput.h"
+#include "RootOutput.h"
+#include "TAsciiFile.h"
+#include "NPOptionManager.h"
+#include "NPDetectorFactory.h"
+#include "NPSystemOfUnits.h"
+//   ROOT
+using namespace NPUNITS;
+///////////////////////////////////////////////////////////////////////////
+
+ClassImp(TBigRIPSPlasticPhysics)
+  ///////////////////////////////////////////////////////////////////////////
+  TBigRIPSPlasticPhysics::TBigRIPSPlasticPhysics(){
+    m_EventData         = new TBigRIPSPlasticData ;
+    m_PreTreatedData    = new TBigRIPSPlasticData ;
+    m_EventPhysics      = this ;
+    //m_Spectra           = NULL;
+  }
+
+///////////////////////////////////////////////////////////////////////////
+void TBigRIPSPlasticPhysics::BuildSimplePhysicalEvent(){
+  BuildPhysicalEvent();
+}
+
+///////////////////////////////////////////////////////////////////////////
+void TBigRIPSPlasticPhysics::BuildPhysicalEvent(){
+  PreTreat();
+  return;
+}
+///////////////////////////////////////////////////////////////////////////
+void TBigRIPSPlasticPhysics::PreTreat(){
+
+  ClearPreTreatedData();
+
+  //Intermediate map associating a Plastic ID with its variables stored in an object
+  // Condition for filling: Raw TDC value within [LowerLimit,UpperLimit]
+  // Only first TDC hit for each variable is stored
+  static map<int, BigRIPSPlasticVariables > Fdata ; 
+  static map<int, BigRIPSPlasticVariables >::iterator found;
+  Fdata.clear() ; 
+
+  //pair of detector ID and variable type (TL,TR,QR,QL)=(0,1,2,3)
+  std::pair<unsigned int, double> pair_id_type; 
+  int id, TimeRaw, QRaw;
+
+
+  //TL
+  unsigned int sizeTL = m_EventData->GetTLMult();
+  for(unsigned int i = 0 ; i < sizeTL ; i++){
+        id = m_EventData->GetTLID(i);
+        TimeRaw = m_EventData->GetTL(i);
+        if(TimeRaw>RawLowerLimit[id] && TimeRaw<RawUpperLimit[id]){
+            if(Fdata[id].FTL.size()==0){
+                Fdata[id].FTL.push_back(TimeRaw); 
+
+            }else {
+                Fdata[id].FmultiHit[0]=1; //multiple value for same TDC ch.
+            }
+        }
+  }
+
+  //TR
+  unsigned int sizeTR = m_EventData->GetTRMult();
+  for(unsigned int i = 0 ; i < sizeTR ; i++){
+        id = m_EventData->GetTRID(i);
+        TimeRaw = m_EventData->GetTR(i);
+        if(TimeRaw>RawLowerLimit[id] && TimeRaw<RawUpperLimit[id]){
+            if(Fdata[id].FTR.size()==0){
+                Fdata[id].FTR.push_back(TimeRaw); 
+            }else {
+                Fdata[id].FmultiHit[1]=1; //multiple value for same TDC ch.
+            }
+        }
+  }
+
+  //QL
+  unsigned int sizeQL = m_EventData->GetQLMult();
+  for(unsigned int i = 0 ; i < sizeQL ; i++){
+        id = m_EventData->GetQLID(i);
+        QRaw = m_EventData->GetQL(i);
+            if(Fdata[id].FQL.size()==0){
+                Fdata[id].FQL.push_back(QRaw); 
+            }else {
+                Fdata[id].FmultiHit[2]=1; //multiple value for same Q ch.
+            }
+  }
+
+  //QR
+  unsigned int sizeQR = m_EventData->GetQRMult();
+  for(unsigned int i = 0 ; i < sizeQR ; i++){
+        id = m_EventData->GetQRID(i);
+        QRaw = m_EventData->GetQR(i);
+            if(Fdata[id].FQR.size()==0){
+                Fdata[id].FQR.push_back(QRaw); 
+            }else {
+                Fdata[id].FmultiHit[3]=1; //multiple value for same Q ch.
+            }
+  }
+
+  int Nmulti;
+  BigRIPSPlasticVariables tmp;
+
+  for(auto it = Fdata.begin();it!=Fdata.end();++it){
+    id = it->first;
+    ID.push_back(id);
+    FP.push_back(IDtoFP[id]);
+    tmp.Clear();
+    tmp = it->second;
+    //tmp.Print(); 
+    //TL=tmp.FTL * tcal_left[id];
+    //TR=tmp.FTR * tcal_right[id];
+    //QL=tmp.FQL;
+    //QR=tmp.FQR;
+    
+    //Calculate how many TDC variables got a multi hit
+    Nmulti=0;
+    for (int i=0; i<4; i++) if(tmp.FmultiHit[i]==1) Nmulti++;
+    multiHit.push_back(Nmulti);
+
+    //Calculate TL, TLSlew
+    double TL_cal, TLSlew_cal;
+    if(tmp.FTL.size()==1){
+        TL_cal = tmp.FTL[0] * tcal_left[id];
+        TL.push_back(TL_cal);
+        if(tmp.HasTLandQL()){            
+            TLSlew_cal = tcal_left[id]*
+                       (tmp.FTL[0] 
+                       + tslew_left_a[id]/sqrt(tmp.FQL[0]) 
+                       + tslew_left_b[id]);
+            TLSlew.push_back(TLSlew_cal);
+       }else{
+            TLSlew.push_back(TL_cal);
+       }
+    }else{ 
+       TL.push_back(-99999);
+       TLSlew.push_back(-99999);
+    }
+
+    //Calculate TR, TRSlew
+    double TR_cal, TRSlew_cal;
+    if(tmp.FTR.size()==1){
+        TR_cal = tmp.FTR[0] * tcal_right[id];
+        TR.push_back(TR_cal);
+        if(tmp.HasTRandQR()){            
+            TRSlew_cal = tcal_right[id]*
+                       (tmp.FTR[0] 
+                       + tslew_right_a[id]/sqrt(tmp.FQR[0]) 
+                       + tslew_right_b[id]);
+            TRSlew.push_back(TRSlew_cal);
+       }else{
+            TRSlew.push_back(TR_cal);
+       }
+    }else{ 
+       TR.push_back(-99999);
+       TRSlew.push_back(-99999);
+    }
+
+    //Calculate T, TSlew
+    if(tmp.FTL.size()==1 && tmp.FTR.size()==1){
+       T.push_back((TR_cal+TL_cal)/2.);
+       if(tmp.FQL.size()==1 && tmp.FQR.size()==1){
+          TSlew.push_back((TRSlew_cal+TLSlew_cal)/2.);
+       }            
+    }            
+
+    //Simply fill QL and QR
+    if(tmp.FQL.size()==1){
+       QL.push_back(tmp.FQL[0]);
+    }else{
+       QL.push_back(-99999);
+    } 
+    if(tmp.FQR.size()==1){
+       QR.push_back(tmp.FQR[0]);            
+    }else{
+       QR.push_back(-99999);
+    } 
+
+    if(tmp.HasEverything()==1){
+       fired.push_back(true);            
+    }else{
+       fired.push_back(false);
+    } 
+
+  }//end of loop on FData (loop on all plastics)
+
+  //Print(); 
+  Fdata.clear();
+
+  return;
+}
+///////////////////////////////////////////////////////////////////////////
+void TBigRIPSPlasticPhysics::Clear(){
+    ID.clear();
+    FP.clear();
+    T.clear();
+    TL.clear();
+    TR.clear();
+    TSlew.clear();
+    TLSlew.clear();
+    TRSlew.clear();
+    QL.clear();
+    QR.clear();
+    multiHit.clear();
+    fired.clear();
+}
+///////////////////////////////////////////////////////////////////////////
+void TBigRIPSPlasticPhysics::Print(){
+    cout << "XXXXXXXXXXXXXXXXXXXXXXXX Plastic Physics Event XXXXXXXXXXXXXXXXX" << endl;
+    cout << "TL_Mult = " << TL.size();
+    for (UShort_t i = 0; i < TL.size(); i++){cout << "\tTL: " << TL[i] << endl;}
+    cout << "TR_Mult = " << TR.size();
+    for (UShort_t i = 0; i < TR.size(); i++){cout << "\tTR: " << TR[i] << endl;}
+    cout << "QL_Mult = " << QL.size();
+    for (UShort_t i = 0; i < QL.size(); i++){cout << "\tQL: " << QL[i] << endl;}
+    cout << "QR_Mult = " << QR.size();
+    for (UShort_t i = 0; i < QR.size(); i++){cout << "\tQR: " << QR[i] << endl;}
+}
+///////////////////////////////////////////////////////////////////////////
+
+////   Innherited from VDetector Class   ////
+
+///////////////////////////////////////////////////////////////////////////
+void TBigRIPSPlasticPhysics::ReadConfiguration(NPL::InputParser parser){
+  vector<NPL::InputBlock*> blocks = parser.GetAllBlocksWithToken("BigRIPSPlastic");
+  if(NPOptionManager::getInstance()->GetVerboseLevel())
+    cout << "//// " << blocks.size() << " Plastic detector file found " << endl; 
+
+  vector<string> token= {"XML"};
+
+  for(unsigned int i = 0 ; i < blocks.size() ; i++){
+    cout << endl << "////  BigRIPSPlastic file (" << i+1 << ")" << endl;
+    string xmlpath = blocks[i]->GetString("XML");
+    NPL::XmlParser xml;
+    xml.LoadFile(xmlpath);
+    AddPlastics("BigRIPSPlastic",xml);
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////
+void TBigRIPSPlasticPhysics::AddPlastics(string name, NPL::XmlParser& xml){
+  std::vector<NPL::XML::block*> b = xml.GetAllBlocksWithName(name);  
+
+  if(name=="BigRIPSPlastic"){
+    unsigned int size = b.size();
+    for(unsigned int i = 0 ; i < size ; i++){
+      unsigned int ID = b[i]->AsInt("ID"); 
+      //string sDir = b[i]->AsString("anodedir");
+      RawLowerLimit[ID] = b[i]->AsInt("tdc_underflow"); 
+      RawUpperLimit[ID] = b[i]->AsInt("tdc_overflow"); 
+      IDtoFP[ID] = b[i]->AsInt("FPL"); 
+      tcal_left[ID] = b[i]->AsDouble("tcal_left"); 
+      tcal_right[ID] = b[i]->AsDouble("tcal_right"); 
+      tslew_left_a[ID] = b[i]->AsDouble("tslew_left_a"); 
+      tslew_left_b[ID] = b[i]->AsDouble("tslew_left_b"); 
+      tslew_right_a[ID] = b[i]->AsDouble("tslew_right_a"); 
+      tslew_right_b[ID] = b[i]->AsDouble("tslew_right_b"); 
+    }
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////
+void TBigRIPSPlasticPhysics::InitSpectra(){  
+  //m_Spectra = new TBigRIPSPlasticSpectra(m_NumberOfDetector);
+}
+
+///////////////////////////////////////////////////////////////////////////
+void TBigRIPSPlasticPhysics::FillSpectra(){  
+  //  m_Spectra -> FillRawSpectra(m_EventData);
+  //  m_Spectra -> FillPreTreatedSpectra(m_PreTreatedData);
+  //  m_Spectra -> FillPhysicsSpectra(m_EventPhysics);
+}
+///////////////////////////////////////////////////////////////////////////
+void TBigRIPSPlasticPhysics::CheckSpectra(){  
+  //  m_Spectra->CheckSpectra();  
+}
+///////////////////////////////////////////////////////////////////////////
+void TBigRIPSPlasticPhysics::ClearSpectra(){  
+  // To be done
+}
+///////////////////////////////////////////////////////////////////////////
+map< string , TH1*> TBigRIPSPlasticPhysics::GetSpectra() {
+  /*  if(m_Spectra)
+      return m_Spectra->GetMapHisto();
+      else{
+      map< string , TH1*> empty;
+      return empty;
+      }*/
+  map< string , TH1*> empty;
+  return empty;
+
+} 
+
+///////////////////////////////////////////////////////////////////////////
+void TBigRIPSPlasticPhysics::WriteSpectra(){
+  // m_Spectra->WriteSpectra();
+}
+///////////////////////////////////////////////////////////////////////////
+void TBigRIPSPlasticPhysics::AddParameterToCalibrationManager(){
+  //CalibrationManager* Cal = CalibrationManager::getInstance();
+
+  // each layer
+  //for( int l = 0 ; l < 14 ; ++l){
+  //  Cal->AddParameter("SamuraiFDC2", "L"+ NPL::itoa(l),"FDC2_L"+ NPL::itoa(l));
+  //}
+
+}
+
+///////////////////////////////////////////////////////////////////////////
+void TBigRIPSPlasticPhysics::InitializeRootInputRaw(){
+  TChain* inputChain = RootInput::getInstance()->GetChain()   ;
+  inputChain->SetBranchStatus( "BigRIPSPlastic" , true );
+  // The following line is necessary only for system were the tree is splitted
+  // (older root version). The found argument silenced the Branches not found
+  // warning for non splitted tree.
+  if(inputChain->FindBranch("fPlastic_*"))
+    inputChain->SetBranchStatus( "fPlastic_*",true);
+  inputChain->SetBranchAddress( "BigRIPSPlastic" , &m_EventData );
+
+}
+
+///////////////////////////////////////////////////////////////////////////
+void TBigRIPSPlasticPhysics::InitializeRootInputPhysics(){
+}
+
+///////////////////////////////////////////////////////////////////////////
+void TBigRIPSPlasticPhysics::InitializeRootOutput(){
+  TTree* outputTree = RootOutput::getInstance()->GetTree();
+  outputTree->Branch( "Plastic" , "TBigRIPSPlasticPhysics" , &m_EventPhysics );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//            Construct Method to be pass to the DetectorFactory              //
+////////////////////////////////////////////////////////////////////////////////
+NPL::VDetector* TBigRIPSPlasticPhysics::Construct(){
+  return (NPL::VDetector*) new TBigRIPSPlasticPhysics();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//            Registering the construct method to the factory                 //
+////////////////////////////////////////////////////////////////////////////////
+extern "C"{
+  class proxy_bigripsPlastic{
+    public:
+      proxy_bigripsPlastic(){
+        NPL::DetectorFactory::getInstance()->AddToken("BigRIPSPlastic","BigRIPS");
+        NPL::DetectorFactory::getInstance()->AddDetector("BigRIPSPlastic",TBigRIPSPlasticPhysics::Construct);
+      }
+  };
+
+  proxy_bigripsPlastic p_bigripsPlastic;
+}
+

NPLib/Detectors/BigRIPS/TBigRIPSPlasticPhysics.h

+#ifndef TBIGRIPSPLASTICPHYSICS_H
+#define TBIGRIPSPLASTICPHYSICS_H
+/*****************************************************************************
+ * Copyright (C) 2009-2016    this file is part of the NPTool Project        *
+ *                                                                           *
+ * For the licensing terms see $NPTOOL/Licence/NPTool_Licence                *
+ * For the list of contributors see $NPTOOL/Licence/Contributors             *
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Original Author: F. Flavigny contact address: flavigny@lpccaen.in2p3.fr   *
+ *                                                                           *
+ * Creation Date  : April 2020                                               *
+ * Last update    :                                                          *
+ *---------------------------------------------------------------------------*
+ * Decription:                                                               *
+ *  This class hold RIBF Plastic treated data                                *
+ *                                                                           *
+ *---------------------------------------------------------------------------*
+ * Comment:                                                                  *
+ *                                                                           *  
+ *                                                                           *
+ *                                                                           *
+ *****************************************************************************/
+// STL
+#include <vector>
+#include <map>
+
+// NPL
+#include "TBigRIPSPlasticData.h"
+#include "BigRIPSPlasticVariables.h"
+//#include "TBigRIPSPlasticSpectra.h"
+#include "NPCalibrationManager.h"
+#include "NPVDetector.h"
+#include "NPInputParser.h"
+#include "NPXmlParser.h"
+#include "NPDCReconstruction.h"
+// ROOT 
+#include "TVector3.h" 
+// Forward declaration
+//class TBigRIPSPlasticSpectra;
+
+
+using namespace std ;
+
+class TBigRIPSPlasticPhysics : public TObject, public NPL::VDetector{
+  public:
+    TBigRIPSPlasticPhysics();
+    ~TBigRIPSPlasticPhysics() {};
+
+  public: 
+    void Clear();   
+    void Clear(const Option_t*) {};
+    void Print();   
+
+  public:
+    std::vector<int> ID;
+    std::vector<int> FP;
+    std::vector<double> T;
+    std::vector<double> TL;
+    std::vector<double> TR;
+    std::vector<double> TSlew;
+    std::vector<double> TLSlew;
+    std::vector<double> TRSlew;
+    std::vector<double> QL;
+    std::vector<double> QR;
+    std::vector<int> multiHit;
+    std::vector<bool> fired;
+
+  public:
+
+    // Projected position at given Z plan
+    TVector3 ProjectedPosition(double Z);
+
+  private: // Xml file read to add Plastics and their parameters 
+    void AddPlastics(string name, NPL::XmlParser&);//! take the XML file and fill in parameters of each Plastic
+    map<int,double> RawUpperLimit;//! Upper Value of TDC range considered for a Plastic
+    map<int,double> RawLowerLimit;//! Lower Value of TDC range considered for a Plastic 
+    map<int,int>  IDtoFP;//! Focal plane where the Plastic is located
+    map<int,double> tcal_left; 
+    map<int,double> tcal_right; 
+    map<int,double> tslew_left_a; 
+    map<int,double> tslew_left_b; 
+    map<int,double> tslew_right_a; 
+    map<int,double> tslew_right_b; 
+  
+  public: //   Innherited from VDetector Class
+
+    // Read stream at ConfigFile to pick-up parameters of detector (Position,...) using Token
+    void ReadConfiguration(NPL::InputParser) ;
+
+    // Add Parameter to the CalibrationManger
+    void AddParameterToCalibrationManager() ;      
+
+    // Activated associated Branches and link it to the private member DetectorData address
+    // In this method mother Branches (Detector) AND daughter leaf (fDetector_parameter) have to be activated
+    void InitializeRootInputRaw() ;
+
+    // Activated associated Branches and link it to the private member DetectorPhysics address
+    // In this method mother Branches (Detector) AND daughter leaf (parameter) have to be activated
+    void InitializeRootInputPhysics() ;
+
+    // Create associated branches and associated private member DetectorPhysics address
+    void InitializeRootOutput() ;
+
+    // This method is called at each event read from the Input Tree. Aime is to build treat Raw dat in order to extract physical parameter. 
+    void BuildPhysicalEvent() ;
+
+    // Same as above, but only the simplest event and/or simple method are used (low multiplicity, faster algorythm but less efficient ...).
+    // This method aimed to be used for analysis performed during experiment, when speed is requiered.
+    // NB: This method can eventually be the same as BuildPhysicalEvent.
+    void BuildSimplePhysicalEvent() ;
+
+    // Same as above but for online analysis
+    void BuildOnlinePhysicalEvent()  {BuildPhysicalEvent();};
+
+    // Those two method all to clear the Event Physics or Data
+    void ClearEventPhysics() {Clear();}      
+    void ClearEventData()    {m_EventData->Clear();}   
+
+    // Method related to the TSpectra classes, aimed at providing a framework for online applications
+    // Instantiate the Spectra class and the histogramm throught it
+    void InitSpectra();
+    // Fill the spectra hold by the spectra class
+    void FillSpectra();
+    // Used for Online mainly, perform check on the histo and for example change their color if issues are found
+    void CheckSpectra();
+    // Used for Online only, clear all the spectra hold by the Spectra class
+    void ClearSpectra();
+    // Write Spectra to file
+    void WriteSpectra();
+
+  public:     
+
+    //   Clear The PreTeated object
+    void ClearPreTreatedData()   {m_PreTreatedData->Clear();}
+
+    //   Remove bad channel, calibrate the data and apply threshold
+    void PreTreat();
+
+    // Retrieve raw and pre-treated data
+    TBigRIPSPlasticData* GetRawData()        const {return m_EventData;}
+    TBigRIPSPlasticData* GetPreTreatedData() const {return m_PreTreatedData;}
+
+  private:   //   Root Input and Output tree classes
+    TBigRIPSPlasticData*         m_EventData;//!
+    TBigRIPSPlasticData*         m_PreTreatedData;//!
+    TBigRIPSPlasticPhysics*      m_EventPhysics;//!
+
+
+  private: // Spectra Class
+   // TBigRIPSPlasticSpectra* m_Spectra; // !
+
+  public: // Spectra Getter
+    map< string , TH1*> GetSpectra(); 
+
+  public: // Static constructor to be passed to the Detector Factory
+    static NPL::VDetector* Construct();
+    ClassDef(TBigRIPSPlasticPhysics,1)  // BigRIPSPlasticPhysics structure
+};
+
+#endif