Updating Vendeta project

NPLib/Detectors/FissionChamber/TFissionChamberData.cxx

@@ -45,7 +45,8 @@ TFissionChamberData::~TFissionChamberData() {
 //////////////////////////////////////////////////////////////////////
 void TFissionChamberData::Clear() {
   fFC_AnodeNbr.clear();
-  fFC_Energy.clear();
+  fFC_Q1.clear();
+  fFC_Q2.clear();
   fFC_Time.clear();
   fFC_Time_HF.clear();
   fFC_isFakeFission.clear();
@@ -58,12 +59,13 @@ void TFissionChamberData::Dump() const {
   // This method is very useful for debuging and worth the dev.
   cout << "XXXXXXXXXXXXXXXXXXXXXXXX New Event [TFissionChamberData::Dump()] XXXXXXXXXXXXXXXXX" << endl;
 
-  size_t mysize = fFC_Energy.size();
+  size_t mysize = fFC_Q1.size();
   cout << "FissionChamber_E_Mult: " << mysize << endl;
  
   for (size_t i = 0 ; i < mysize ; i++){
     cout << "AnodeNbr: " << fFC_AnodeNbr[i]
-         << " Energy: " << fFC_Energy[i]
+         << " Q1: " << fFC_Q1[i]
+         << " Q2: " << fFC_Q2[i]
          << " Time: " << fFC_Time[i];
   }
 }

NPLib/Detectors/FissionChamber/TFissionChamberData.h

@@ -35,7 +35,8 @@ class TFissionChamberData : public TObject {
   // to allow multiplicity treatment
   private: 
     vector<UShort_t>   fFC_AnodeNbr;
-    vector<Double_t>   fFC_Energy;
+    vector<Double_t>   fFC_Q1;
+    vector<Double_t>   fFC_Q2;
     vector<Double_t>   fFC_Time;
     vector<Bool_t>     fFC_isFakeFission;
     vector<Double_t>   fFC_Time_HF;
@@ -63,19 +64,22 @@ class TFissionChamberData : public TObject {
   public:
     //////////////////////    SETTERS    ////////////////////////
     inline void SetAnodeNbr(const UShort_t& AnodeNbr){fFC_AnodeNbr.push_back(AnodeNbr);}//!
-    inline void SetEnergy(const Double_t& Energy){fFC_Energy.push_back(Energy);}//!
+    inline void SetQ1(const Double_t& Q1){fFC_Q1.push_back(Q1);}//!
+    inline void SetQ2(const Double_t& Q2){fFC_Q2.push_back(Q2);}//!
     inline void SetTime(const Double_t& Time){fFC_Time.push_back(Time);}//!
     inline void SetTimeHF(const Double_t& Time){fFC_Time_HF.push_back(Time);}//!
     inline void SetFakeFissionStatus(const Bool_t& isFF){fFC_isFakeFission.push_back(isFF);}//!
 
     //////////////////////    GETTERS    ////////////////////////
     // Energy
-    inline UShort_t GetMultEnergy() const
-      {return fFC_Energy.size();}
+    inline UShort_t GetMultiplicity() const
+      {return fFC_AnodeNbr.size();}
     inline UShort_t GetAnodeNbr(const unsigned int &i) const 
       {return fFC_AnodeNbr[i];}//!
-    inline Double_t GetEnergy(const unsigned int &i) const 
-      {return fFC_Energy[i];}//!
+    inline Double_t GetQ1(const unsigned int &i) const 
+      {return fFC_Q1[i];}//!
+    inline Double_t GetQ2(const unsigned int &i) const 
+      {return fFC_Q2[i];}//!
     inline Double_t GetTime(const unsigned int &i) const 
       {return fFC_Time[i];}//!
     inline Double_t GetTimeHF(const unsigned int &i) const 

NPLib/Detectors/FissionChamber/TFissionChamberPhysics.cxx

@@ -83,11 +83,14 @@ void TFissionChamberPhysics::BuildPhysicalEvent() {
   PreTreat();
 
   // match energy and time together
-  unsigned int mysizeE = m_PreTreatedData->GetMultEnergy();
+  unsigned int mysizeE = m_PreTreatedData->GetMultiplicity();
   for (UShort_t e = 0; e < mysizeE ; e++) {
     AnodeNumber.push_back(m_PreTreatedData->GetAnodeNbr(e));
-    Energy.push_back(m_PreTreatedData->GetEnergy(e));
+    Q1.push_back(m_PreTreatedData->GetQ1(e));
+    Q2.push_back(m_PreTreatedData->GetQ2(e));
     Time.push_back(m_PreTreatedData->GetTime(e));
+    Time_HF.push_back(m_PreTreatedData->GetTimeHF(e));
+    isFakeFission.push_back(m_PreTreatedData->GetFakeFissionStatus(e));
   }
 }
 
@@ -102,19 +105,21 @@ void TFissionChamberPhysics::PreTreat() {
   // instantiate CalibrationManager
   static CalibrationManager* Cal = CalibrationManager::getInstance();
 
-  unsigned int mysize = m_EventData->GetMultEnergy();
+  unsigned int mysize = m_EventData->GetMultiplicity();
   for (UShort_t i = 0; i < mysize ; ++i) {
-    if (m_EventData->GetEnergy(i) > m_E_RAW_Threshold) {
-      Double_t Energy = Cal->ApplyCalibration("FissionChamber/ANODE"+NPL::itoa(m_EventData->GetAnodeNbr(i))+"_ENERGY",m_EventData->GetEnergy(i));
-      if (Energy > m_E_Threshold) {
-        int AnodeNumber = m_EventData->GetAnodeNbr(i);
-        double TimeOffset = Cal->GetValue("FissionChamber/ANODE"+NPL::itoa(AnodeNumber)+"_TIMEOFFSET",0);
-        double Time = m_EventData->GetTime(i) + TimeOffset;
-
-        m_PreTreatedData->SetAnodeNbr(AnodeNumber);
-        m_PreTreatedData->SetEnergy(Energy);
-        m_PreTreatedData->SetTime(Time);
-      }
+    Double_t Q1 = m_EventData->GetQ1(i);
+    Double_t Q2 = m_EventData->GetQ2(i);
+    if (Q2 > m_E_Threshold) {
+      int AnodeNumber = m_EventData->GetAnodeNbr(i);
+      double TimeOffset = Cal->GetValue("FissionChamber/ANODE"+NPL::itoa(AnodeNumber)+"_TIMEOFFSET",0);
+      double Time = m_EventData->GetTime(i) + TimeOffset;
+
+      m_PreTreatedData->SetAnodeNbr(AnodeNumber);
+      m_PreTreatedData->SetQ1(Q1);
+      m_PreTreatedData->SetQ2(Q2);
+      m_PreTreatedData->SetTime(Time);
+      m_PreTreatedData->SetFakeFissionStatus(m_EventData->GetFakeFissionStatus(i));
+      m_PreTreatedData->SetTimeHF(m_EventData->GetTimeHF(i));
     }
   }
 }
@@ -188,8 +193,11 @@ void TFissionChamberPhysics::ReadAnalysisConfig() {
 ///////////////////////////////////////////////////////////////////////////
 void TFissionChamberPhysics::Clear() {
   AnodeNumber.clear();
-  Energy.clear();
+  Q1.clear();
+  Q2.clear();
   Time.clear();
+  Time_HF.clear();
+  isFakeFission.clear();
 }
 
 

NPLib/Detectors/FissionChamber/TFissionChamberPhysics.h

@@ -63,8 +63,11 @@ class TFissionChamberPhysics : public TObject, public NPL::VDetector {
   // output ROOT file
   public:
     vector<int>      AnodeNumber;
-    vector<double>   Energy;
+    vector<double>   Q1;
+    vector<double>   Q2;
     vector<double>   Time;
+    vector<bool>     isFakeFission;
+    vector<double>   Time_HF;
 
   /// A usefull method to bundle all operation to add a detector
   void AddDetector(TVector3 POS); 

NPLib/Detectors/FissionChamber/TFissionChamberSpectra.cxx

@@ -69,7 +69,7 @@ void TFissionChamberSpectra::InitRawSpectra() {
   static string name;
   for (unsigned int i = 0; i < fNumberOfDetectors; i++) { // loop on number of detectors
     // Energy 
-    name = "FissionChamber"+NPL::itoa(i+1)+"_ENERGY_RAW";
+    name = "FissionChamber"+NPL::itoa(i+1)+"_Q1_RAW";
     AddHisto1D(name, name, 4096, 0, 16384, "FissionChamber/RAW");
     // Time 
     name = "FissionChamber"+NPL::itoa(i+1)+"_TIME_RAW";
@@ -84,7 +84,7 @@ void TFissionChamberSpectra::InitPreTreatedSpectra() {
   static string name;
   for (unsigned int i = 0; i < fNumberOfDetectors; i++) { // loop on number of detectors
     // Energy 
-    name = "FissionChamber"+NPL::itoa(i+1)+"_ENERGY_CAL";
+    name = "FissionChamber"+NPL::itoa(i+1)+"_Q1_CAL";
     AddHisto1D(name, name, 500, 0, 25, "FissionChamber/CAL");
     // Time
     name = "FissionChamber"+NPL::itoa(i+1)+"_TIME_CAL";
@@ -112,11 +112,11 @@ void TFissionChamberSpectra::FillRawSpectra(TFissionChamberData* RawData) {
   static string family;
 
   // Energy 
-  unsigned int sizeE = RawData->GetMultEnergy();
+  unsigned int sizeE = RawData->GetMultiplicity();
   for (unsigned int i = 0; i < sizeE; i++) {
-    name = "FissionChamber"+NPL::itoa(RawData->GetAnodeNbr(i))+"_ENERGY_RAW";
+    name = "FissionChamber"+NPL::itoa(RawData->GetAnodeNbr(i))+"_Q1_RAW";
     family = "FissionChamber/RAW";
-    FillSpectra(family,name,RawData->GetEnergy(i));
+    FillSpectra(family,name,RawData->GetQ1(i));
 
     name = "FissionChamber"+NPL::itoa(RawData->GetAnodeNbr(i))+"_TIME_RAW";
     family = "FissionChamber/RAW";
@@ -133,11 +133,11 @@ void TFissionChamberSpectra::FillPreTreatedSpectra(TFissionChamberData* PreTreat
   static string family;
   
   // Energy 
-  unsigned int sizeE = PreTreatedData->GetMultEnergy();
+  unsigned int sizeE = PreTreatedData->GetMultiplicity();
   for (unsigned int i = 0; i < sizeE; i++) {
-    name = "FissionChamber"+NPL::itoa(PreTreatedData->GetAnodeNbr(i))+"_ENERGY_CAL";
+    name = "FissionChamber"+NPL::itoa(PreTreatedData->GetAnodeNbr(i))+"_Q1_CAL";
     family = "FissionChamber/CAL";
-    FillSpectra(family,name,PreTreatedData->GetEnergy(i));
+    FillSpectra(family,name,PreTreatedData->GetQ1(i));
   
     name = "FissionChamber"+NPL::itoa(PreTreatedData->GetAnodeNbr(i))+"_TIME_CAL";
     family = "FissionChamber/CAL";
@@ -154,10 +154,10 @@ void TFissionChamberSpectra::FillPhysicsSpectra(TFissionChamberPhysics* Physics)
   family= "FissionChamber/PHY";
 
   // Energy vs time
-  unsigned int sizeE = Physics->Energy.size();
+  unsigned int sizeE = Physics->Q1.size();
   for(unsigned int i = 0 ; i < sizeE ; i++){
-    name = "FissionChamber_ENERGY_TIME";
-    FillSpectra(family,name,Physics->Energy[i],Physics->Time[i]);
+    name = "FissionChamber_Q1_TIME";
+    FillSpectra(family,name,Physics->Q1[i],Physics->Time[i]);
   }
 }
 

NPLib/Detectors/Vendeta/TVendetaPhysics.cxx

@@ -87,7 +87,7 @@ void TVendetaPhysics::BuildPhysicalEvent() {
 
   // apply thresholds and calibration
   PreTreat();
-
+  
   // match energy and time together
   unsigned int mysizeE = m_PreTreatedData->GetMultEnergy();
   for (UShort_t e = 0; e < mysizeE ; e++) {
@@ -95,6 +95,7 @@ void TVendetaPhysics::BuildPhysicalEvent() {
     Q1.push_back(m_PreTreatedData->GetQ1(e));
     Q2.push_back(m_PreTreatedData->GetQ2(e));
     Time.push_back(m_PreTreatedData->GetTime(e));
+    isHG.push_back(m_PreTreatedData->GetHighGainStatus(e));
   }
 
   m_AnodeNumber=-1;
@@ -111,27 +112,24 @@ void TVendetaPhysics::PreTreat() {
   // instantiate CalibrationManager
   static CalibrationManager* Cal = CalibrationManager::getInstance();
 
-  // Energy
   unsigned int mysize = m_EventData->GetMultEnergy();
-  for (UShort_t i = 0; i < mysize ; ++i) {
-    if (m_EventData->GetQ1(i) > m_E_RAW_Threshold && m_EventData->GetQ2(i) > m_E_RAW_Threshold) {
-      int det = m_EventData->GetDetectorNbr(i);
-      bool isHG = m_PreTreatedData->GetHighGainStatus(i);
-      double TimeOffset=0;
-      if(isHG==0){
-        TimeOffset = Cal->GetValue("Vendeta/DET"+NPL::itoa(det)+"_LG_ANODE"+NPL::itoa(m_AnodeNumber)+"_TIMEOFFSET",0);
+  for (UShort_t i = 0; i < mysize ; ++i){
+    int det = m_EventData->GetDetectorNbr(i);
+    bool isHG = m_EventData->GetHighGainStatus(i);
+    double TimeOffset=0;
+    if(isHG==0){
+      TimeOffset = Cal->GetValue("Vendeta/DET"+NPL::itoa(det)+"_LG_ANODE"+NPL::itoa(m_AnodeNumber)+"_TIMEOFFSET",0);
       }
-      else if(isHG==1){ 
-        TimeOffset = Cal->GetValue("Vendeta/DET"+NPL::itoa(det)+"_HG_ANODE"+NPL::itoa(m_AnodeNumber)+"_TIMEOFFSET",0);
+    else if(isHG==1){ 
+      TimeOffset = Cal->GetValue("Vendeta/DET"+NPL::itoa(det)+"_HG_ANODE"+NPL::itoa(m_AnodeNumber)+"_TIMEOFFSET",0);
       }
 
-      double Time = m_EventData->GetTime(i) + TimeOffset;
-      m_PreTreatedData->SetDetectorNbr(det);
-      m_PreTreatedData->SetQ1(m_EventData->GetQ1(i));
-      m_PreTreatedData->SetQ2(m_EventData->GetQ2(i));
-      m_PreTreatedData->SetTime(Time);
-      m_PreTreatedData->SetHighGainStatus(isHG);
-    }
+    double Time = m_EventData->GetTime(i) + TimeOffset;
+    m_PreTreatedData->SetDetectorNbr(det);
+    m_PreTreatedData->SetQ1(m_EventData->GetQ1(i));
+    m_PreTreatedData->SetQ2(m_EventData->GetQ2(i));
+    m_PreTreatedData->SetTime(Time);
+    m_PreTreatedData->SetHighGainStatus(isHG);
   }
 }
 
@@ -218,8 +216,8 @@ void TVendetaPhysics::ReadConfiguration(NPL::InputParser parser) {
   if(NPOptionManager::getInstance()->GetVerboseLevel())
     cout << "//// " << blocks.size() << " detectors found " << endl; 
 
-  vector<string> cart = {"POS","Shape"};
-  vector<string> sphe = {"R","Theta","Phi","Shape"};
+  vector<string> cart = {"POS"};
+  vector<string> sphe = {"R","Theta","Phi"};
 
   for(unsigned int i = 0 ; i < blocks.size() ; i++){
     if(blocks[i]->HasTokenList(cart)){
@@ -227,7 +225,6 @@ void TVendetaPhysics::ReadConfiguration(NPL::InputParser parser) {
         cout << endl << "////  Vendeta " << i+1 <<  endl;
     
       TVector3 Pos = blocks[i]->GetTVector3("POS","mm");
-      string Shape = blocks[i]->GetString("Shape");
       AddDetector(Pos);
     }
     else if(blocks[i]->HasTokenList(sphe)){
@@ -236,7 +233,6 @@ void TVendetaPhysics::ReadConfiguration(NPL::InputParser parser) {
       double R = blocks[i]->GetDouble("R","mm");
       double Theta = blocks[i]->GetDouble("Theta","deg");
       double Phi = blocks[i]->GetDouble("Phi","deg");
-      string Shape = blocks[i]->GetString("Shape");
       AddDetector(R,Theta,Phi);
     }
     else{

NPSimulation/Detectors/FissionChamber/FissionChamber.cc

@@ -405,7 +405,8 @@ void FissionChamber::ReadSensitive(const G4Event* ){
       double Time = RandGauss::shoot(Scorer->GetTime(i),FissionChamber_NS::ResoTime);
       int DetectorNbr = level[0];
       m_Event->SetAnodeNbr(DetectorNbr);
-      m_Event->SetEnergy(Energy);
+      m_Event->SetQ1(Energy);
+      m_Event->SetQ2(Energy);
       m_Event->SetTime(Time); 
       m_Event->SetTimeHF(0); 
       m_Event->SetFakeFissionStatus(0); 

Projects/Vendeta/Analysis.cxx

@@ -47,7 +47,7 @@ void Analysis::Init(){
 void Analysis::TreatEvent(){
   ReInitValue();
 
-  unsigned int FC_mult = FC->Energy.size();
+  unsigned int FC_mult = FC->AnodeNumber.size();
   if(FC_mult==1){
     int anode = FC->AnodeNumber[0];
     double Time_FC = FC->Time[0];
@@ -58,7 +58,6 @@ void Analysis::TreatEvent(){
     for(unsigned int i=0; i<Vendeta_mult; i++){
       int DetNbr          = Vendeta->DetectorNumber[i];
       double Time_Vendeta = Vendeta->Time[i];
-      bool HG_status      = Vendeta->isHG[i];
       double Rdet         = Vendeta->GetDistanceFromTarget(DetNbr);
       TVector3 DetPos     = Vendeta->GetVectorDetectorPosition(DetNbr);
 
@@ -75,7 +74,9 @@ void Analysis::TreatEvent(){
       Tof.push_back(DT);
       ELab.push_back(En);
       ThetaLab.push_back(Theta_random);
-      isHG.push_back(HG_status);
+      Q1.push_back(Vendeta->Q1[i]);
+      Q2.push_back(Vendeta->Q2[i]);
+      HG_status.push_back(Vendeta->isHG[i]);
     }
   }
 
@@ -86,8 +87,9 @@ void Analysis::InitOutputBranch(){
   RootOutput::getInstance()->GetTree()->Branch("ThetaLab",&ThetaLab);
   RootOutput::getInstance()->GetTree()->Branch("ELab",&ELab);
   RootOutput::getInstance()->GetTree()->Branch("Tof",&Tof);
-  RootOutput::getInstance()->GetTree()->Branch("Charge",&Charge);
-  RootOutput::getInstance()->GetTree()->Branch("isHG",&isHG);
+  RootOutput::getInstance()->GetTree()->Branch("Q1",&Q1);
+  RootOutput::getInstance()->GetTree()->Branch("Q2",&Q2);
+  RootOutput::getInstance()->GetTree()->Branch("HG_status",&HG_status);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -95,8 +97,9 @@ void Analysis::ReInitValue(){
   ThetaLab.clear();
   ELab.clear();
   Tof.clear();
-  Charge.clear();
-  isHG.clear();
+  Q1.clear();
+  Q2.clear();
+  HG_status.clear();
 }
 
 ////////////////////////////////////////////////////////////////////////////////

Projects/Vendeta/Analysis.h

@@ -45,8 +45,9 @@ class Analysis: public NPL::VAnalysis{
     vector<double> ThetaLab;
     vector<double> ELab;
     vector<double> Tof;
-    vector<double> Charge;
-    vector<bool> isHG;
+    vector<double> Q1;
+    vector<double> Q2;
+    vector<bool>   HG_status;
 
   private:
     TVendetaPhysics* Vendeta;