fix(califa):Fixed problem with the geo parameters

jose-luis-rs · jose-luis-rs · commit 171f0e1c7543 · 2026-01-20T12:53:33.000+01:00
Minor change
diff --git a/califa/calibration/R3BCalifaCrystalCal2Cluster.cxx b/califa/calibration/R3BCalifaCrystalCal2Cluster.cxx
@@ -1,6 +1,6 @@
 /******************************************************************************
  *   Copyright (C) 2019 GSI Helmholtzzentrum für Schwerionenforschung GmbH    *
- *   Copyright (C) 2019-2025 Members of R3B Collaboration                     *
+ *   Copyright (C) 2019-2026 Members of R3B Collaboration                     *
  *                                                                            *
  *             This software is distributed under the terms of the            *
  *                 GNU General Public Licence (GPL) version 3,                *
@@ -85,33 +85,33 @@ void RemoveUsedCrystals(vector<uint16_t>& used,
                         vector<R3BCalifaCrystalCalData*>& saturated)
 {
 
-    for (int p = 0; p < used.size(); p++)
+    for (auto p = 0; p < used.size(); p++)
     {
-        for (int s = 0; s < all.size(); s++)
+        for (auto s = 0; s < all.size(); s++)
 
             if (all.at(s)->GetCrystalId() == used.at(p))
                 all.erase(all.begin() + s);
     }
 
-    for (int p = 0; p < used.size(); p++)
+    for (auto p = 0; p < used.size(); p++)
     {
-        for (int s = 0; s < gamma.size(); s++)
+        for (auto s = 0; s < gamma.size(); s++)
 
             if (gamma.at(s)->GetCrystalId() == used.at(p))
                 gamma.erase(gamma.begin() + s);
     }
 
-    for (int p = 0; p < used.size(); p++)
+    for (auto p = 0; p < used.size(); p++)
     {
-        for (int s = 0; s < proton.size(); s++)
+        for (auto s = 0; s < proton.size(); s++)
 
             if (proton.at(s)->GetCrystalId() == used.at(p))
                 proton.erase(proton.begin() + s);
     }
 
-    for (int p = 0; p < used.size(); p++)
+    for (auto p = 0; p < used.size(); p++)
     {
-        for (int s = 0; s < saturated.size(); s++)
+        for (auto s = 0; s < saturated.size(); s++)
 
             if (saturated.at(s)->GetCrystalId() == used.at(p))
                 saturated.erase(saturated.begin() + s);
@@ -152,7 +152,7 @@ R3BCalifaCrystalCal2Cluster::~R3BCalifaCrystalCal2Cluster()
 
 void R3BCalifaCrystalCal2Cluster::SetParContainers()
 {
-    FairRuntimeDb* rtdb = FairRuntimeDb::instance();
+    auto* rtdb = FairRuntimeDb::instance();
     R3BLOG_IF(fatal, !rtdb, "FairRuntimeDb not found");
 
     fCalifaGeoPar = dynamic_cast<R3BTGeoPar*>(rtdb->getContainer("CalifaGeoPar"));
@@ -166,24 +166,35 @@ void R3BCalifaCrystalCal2Cluster::SetParContainers()
     else
     {
         R3BLOG(info, "Container CalifaGeoPar found.");
-        fCalifaPos.SetXYZ(fCalifaGeoPar->GetPosX(), fCalifaGeoPar->GetPosY(), fCalifaGeoPar->GetPosZ());
     }
 
-    if (!fCalifaGeoPar || !fTargetGeoPar)
+    if (!fTargetGeoPar)
     {
-        R3BLOG_IF(warn, !fTargetGeoPar, "Could not get access to TargetGeoPar container. Setting nominal position. ");
+        R3BLOG_IF(warn, !fTargetGeoPar, "Could not get access to TargetGeoPar container. Setting nominal position.");
         fTargetPos.SetXYZ(0.0, 0.0, 0.0);
     }
     else
     {
         R3BLOG(info, "Container TargetGeoPar found.");
+    }
+
+    return;
+}
+
+void R3BCalifaCrystalCal2Cluster::SetParameter()
+{
+    if (fCalifaGeoPar)
+    {
+        fCalifaPos.SetXYZ(fCalifaGeoPar->GetPosX(), fCalifaGeoPar->GetPosY(), fCalifaGeoPar->GetPosZ());
+    }
+
+    if (fTargetGeoPar)
+    {
         fTargetPos.SetXYZ(fTargetGeoPar->GetPosX(), fTargetGeoPar->GetPosY(), fTargetGeoPar->GetPosZ());
     }
 
     LOG(info) << "Califa position : X = " << fCalifaPos.X() << " Y = " << fCalifaPos.Y() << " Z = " << fCalifaPos.Z();
     LOG(info) << "Target position : X = " << fTargetPos.X() << " Y = " << fTargetPos.Y() << " Z = " << fTargetPos.Z();
-
-    return;
 }
 
 InitStatus R3BCalifaCrystalCal2Cluster::Init()
@@ -199,6 +210,9 @@ InitStatus R3BCalifaCrystalCal2Cluster::Init()
     fCalifaClusterData = new TClonesArray("R3BCalifaClusterData");
     rootman->Register("CalifaClusterData", "CALIFA Cluster", fCalifaClusterData, !fOnline);
 
+    // Load parameters
+    SetParameter();
+
     if (R3BCalifaGeometry::Instance()->IsSimulation() == true)
     {
         fTotalCrystals = R3BCalifaGeometry::Instance()->GetNbCrystals() / 2;
@@ -223,7 +237,7 @@ InitStatus R3BCalifaCrystalCal2Cluster::Init()
         R3BLOG_IF(fatal, !fHistoFile, "Randomization file not found");
 
         fAngularDistributions = new TH2F*[fTotalCrystals];
-        for (Int_t i = 0; i < fTotalCrystals; i++)
+        for (auto i = 0; i < fTotalCrystals; i++)
         {
             std::string name = "distributionCrystalID_" + std::to_string(i + 1);
             fHistoFile->GetObject(name.c_str(), fAngularDistributions[i]);
@@ -235,14 +249,15 @@ InitStatus R3BCalifaCrystalCal2Cluster::Init()
 InitStatus R3BCalifaCrystalCal2Cluster::ReInit()
 {
     SetParContainers();
+    SetParameter();
     return kSUCCESS;
 }
 
 void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /*opt*/)
 {
     Reset();
 
-    const int numCrystalHits = fCrystalCalData->GetEntriesFast();
+    auto numCrystalHits = fCrystalCalData->GetEntriesFast();
 
     if (numCrystalHits == 0)
         return;
@@ -256,10 +271,10 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /*opt*/)
 
     vector<uint16_t> usedCrystals;
 
-    Double_t cryEnergy = 0.;
-    Int_t cryId = 0;
+    double cryEnergy = 0.;
+    int cryId = 0;
 
-    for (Int_t i = 0; i < numCrystalHits; i++)
+    for (auto i = 0; i < numCrystalHits; i++)
     {
         cryId = dynamic_cast<R3BCalifaCrystalCalData*>(fCrystalCalData->At(i))->GetCrystalId();
         cryEnergy = dynamic_cast<R3BCalifaCrystalCalData*>(fCrystalCalData->At(i))->GetEnergy();
@@ -294,9 +309,9 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /*opt*/)
     }
 
     /* ----- Remove duplicate entries in gamma clusters ----- */
-    for (int k = 0; k < gammaCandidatesVec.size(); k++)
+    for (auto k = 0; k < gammaCandidatesVec.size(); k++)
     {
-        for (int s = 0; s < gammaCandidatesVec.size(); s++)
+        for (auto s = 0; s < gammaCandidatesVec.size(); s++)
         {
             if (gammaCandidatesVec.at(k)->GetCrystalId() == (gammaCandidatesVec.at(s)->GetCrystalId() - fTotalCrystals))
                 gammaCandidatesVec.erase(gammaCandidatesVec.begin() + s);
@@ -313,7 +328,7 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /*opt*/)
 
     while (protonCandidatesVec.size())
     {
-        Int_t motherId = protonCandidatesVec.at(0)->GetCrystalId();
+        auto motherId = protonCandidatesVec.at(0)->GetCrystalId();
 
         califa_candidate cluster = { motherId, vector<uint16_t>(), 0.0, 0.0, 0.0, 0.0, 0.0 };
 
@@ -328,7 +343,6 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /*opt*/)
 
         if (fRand)
         {
-
             if (motherId > fTotalCrystals)
                 fAngularDistributions[protonCandidatesVec.at(0)->GetCrystalId() - 1 - fTotalCrystals]->GetRandom2(
                     fRandPhi, fRandTheta);
@@ -350,10 +364,10 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /*opt*/)
 
         addCrystal2Cluster(&cluster, protonCandidatesVec.at(0), "proton", &usedCrystals, fTotalCrystals);
 
-        for (Int_t j = 0; j < allCrystalVec.size(); j++)
+        for (auto j = 0; j < allCrystalVec.size(); j++)
         {
-            Int_t thisCryId = allCrystalVec.at(j)->GetCrystalId();
-            Float_t thisEnergy = allCrystalVec.at(j)->GetEnergy();
+            auto thisCryId = allCrystalVec.at(j)->GetCrystalId();
+            auto thisEnergy = allCrystalVec.at(j)->GetEnergy();
 
             if (thisCryId > fTotalCrystals && !isInside(usedCrystals, thisCryId) && !fSimulation)
             {
@@ -367,7 +381,6 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /*opt*/)
             if (thisCryId <= fTotalCrystals && !isInside(usedCrystals, thisCryId) && !std::isnan(thisEnergy) &&
                 !fSimulation)
             {
-
                 angles = R3BCalifaGeometry::Instance()->GetAngles(thisCryId);
 
                 if (InsideClusterWindow(mother_angles, angles))
@@ -377,7 +390,6 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /*opt*/)
             /* ------- Simulation ------- */
             if (!isInside(usedCrystals, thisCryId) && fSimulation)
             {
-
                 angles = R3BCalifaGeometry::Instance()->GetAngles(thisCryId);
 
                 // add to gamma or proton cluster depending on crystal id
@@ -400,7 +412,7 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /*opt*/)
     /*------ Gamma Clusters ------- */
     while (gammaCandidatesVec.size())
     {
-        Int_t motherId = gammaCandidatesVec.at(0)->GetCrystalId();
+        auto motherId = gammaCandidatesVec.at(0)->GetCrystalId();
 
         califa_candidate cluster = { motherId, vector<uint16_t>(), 0.0, 0.0, 0.0, 0.0, 0.0 };
 
@@ -436,9 +448,9 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /*opt*/)
 
         addCrystal2Cluster(&cluster, gammaCandidatesVec.at(0), "gamma", &usedCrystals, fTotalCrystals);
 
-        for (Int_t j = 0; j < allCrystalVec.size(); j++)
+        for (auto j = 0; j < allCrystalVec.size(); j++)
         {
-            Int_t thisCryId = allCrystalVec.at(j)->GetCrystalId();
+            auto thisCryId = allCrystalVec.at(j)->GetCrystalId();
 
             if (thisCryId <= fTotalCrystals && !isInside(usedCrystals, thisCryId) && !fSimulation)
             {
@@ -449,9 +461,9 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /*opt*/)
             }
         }
 
-        for (Int_t j = 0; j < allCrystalVec.size(); j++)
+        for (auto j = 0; j < allCrystalVec.size(); j++)
         {
-            Int_t thisCryId = allCrystalVec.at(j)->GetCrystalId();
+            auto thisCryId = allCrystalVec.at(j)->GetCrystalId();
 
             if (thisCryId > fTotalCrystals && !isInside(usedCrystals, thisCryId) && !fSimulation)
             {
@@ -462,9 +474,9 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /*opt*/)
             }
         }
 
-        for (Int_t j = 0; j < allCrystalVec.size(); j++)
+        for (auto j = 0; j < allCrystalVec.size(); j++)
         {
-            Int_t thisCryId = allCrystalVec.at(j)->GetCrystalId();
+            auto thisCryId = allCrystalVec.at(j)->GetCrystalId();
 
             if (!isInside(usedCrystals, thisCryId) && fSimulation)
             {
@@ -486,7 +498,7 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /*opt*/)
     /* ----------- Saturation Clusters ----------- */
     while (saturatedCandidatesVec.size())
     {
-        Int_t motherId = saturatedCandidatesVec.at(0)->GetCrystalId();
+        auto motherId = saturatedCandidatesVec.at(0)->GetCrystalId();
 
         califa_candidate cluster = { motherId, vector<uint16_t>(), 0.0, 0.0, 0.0, 0.0, 0.0 };
 
@@ -507,9 +519,9 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /*opt*/)
 
         addCrystal2Cluster(&cluster, saturatedCandidatesVec.at(0), "gamma", &usedCrystals, fTotalCrystals);
 
-        for (Int_t j = 0; j < allCrystalVec.size(); j++)
+        for (auto j = 0; j < allCrystalVec.size(); j++)
         {
-            Int_t thisCryId = allCrystalVec.at(j)->GetCrystalId();
+            auto thisCryId = allCrystalVec.at(j)->GetCrystalId();
 
             if (thisCryId > fTotalCrystals && !isInside(usedCrystals, thisCryId))
             {
@@ -562,7 +574,7 @@ R3BCalifaClusterData* R3BCalifaCrystalCal2Cluster::AddCluster(vector<uint16_t> c
                                                               uint8_t clusterType)
 {
     TClonesArray& clref = *fCalifaClusterData;
-    Int_t size = clref.GetEntriesFast();
+    auto size = clref.GetEntriesFast();
     return new (clref[size]) R3BCalifaClusterData(crystalList, ene, Nf, Ns, pAngle, aAngle, time, clusterType);
 }
 
diff --git a/califa/calibration/R3BCalifaCrystalCal2Cluster.h b/califa/calibration/R3BCalifaCrystalCal2Cluster.h
@@ -1,6 +1,6 @@
 /******************************************************************************
  *   Copyright (C) 2019 GSI Helmholtzzentrum für Schwerionenforschung GmbH    *
- *   Copyright (C) 2019-2025 Members of R3B Collaboration                     *
+ *   Copyright (C) 2019-2026 Members of R3B Collaboration                     *
  *                                                                            *
  *             This software is distributed under the terms of the            *
  *                 GNU General Public Licence (GPL) version 3,                *
@@ -80,6 +80,8 @@ class R3BCalifaCrystalCal2Cluster : public FairTask
     void SetRoundWindow(Double_t window);
 
   private:
+    void SetParameter();
+
     TClonesArray* fCrystalCalData = nullptr;
     TClonesArray* fCalifaClusterData = nullptr;
 
@@ -103,8 +105,8 @@ class R3BCalifaCrystalCal2Cluster : public FairTask
     Double_t fRoundWindow = 0.25; // Cluster window [rad]
     bool fSimulation = false;     // Simulation flag
 
-    Bool_t fRand = 0.; // Flag to set randomization procedure
-    TString fRandFile; // File with angular coverages for each crystal
+    bool fRand = false; // Flag to set randomization procedure
+    TString fRandFile;  // File with angular coverages for each crystal
     TFile* fHistoFile = NULL;
     TH2F** fAngularDistributions;
     TString fWindowAlg = "Round";

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`/******************************************************************************`
`2`	`2`	`* Copyright (C) 2019 GSI Helmholtzzentrum für Schwerionenforschung GmbH *`
`3`		`- * Copyright (C) 2019-2025 Members of R3B Collaboration *`
	`3`	`+ * Copyright (C) 2019-2026 Members of R3B Collaboration *`
`4`	`4`	`* *`
`5`	`5`	`* This software is distributed under the terms of the *`
`6`	`6`	`* GNU General Public Licence (GPL) version 3, *`
`@@ -85,33 +85,33 @@ void RemoveUsedCrystals(vector<uint16_t>& used,`
`85`	`85`	`vector<R3BCalifaCrystalCalData*>& saturated)`
`86`	`86`	`{`
`87`	`87`
`88`		`- for (int p = 0; p < used.size(); p++)`
	`88`	`+ for (auto p = 0; p < used.size(); p++)`
`89`	`89`	`{`
`90`		`- for (int s = 0; s < all.size(); s++)`
	`90`	`+ for (auto s = 0; s < all.size(); s++)`
`91`	`91`
`92`	`92`	`if (all.at(s)->GetCrystalId() == used.at(p))`
`93`	`93`	`all.erase(all.begin() + s);`
`94`	`94`	`}`
`95`	`95`
`96`		`- for (int p = 0; p < used.size(); p++)`
	`96`	`+ for (auto p = 0; p < used.size(); p++)`
`97`	`97`	`{`
`98`		`- for (int s = 0; s < gamma.size(); s++)`
	`98`	`+ for (auto s = 0; s < gamma.size(); s++)`
`99`	`99`
`100`	`100`	`if (gamma.at(s)->GetCrystalId() == used.at(p))`
`101`	`101`	`gamma.erase(gamma.begin() + s);`
`102`	`102`	`}`
`103`	`103`
`104`		`- for (int p = 0; p < used.size(); p++)`
	`104`	`+ for (auto p = 0; p < used.size(); p++)`
`105`	`105`	`{`
`106`		`- for (int s = 0; s < proton.size(); s++)`
	`106`	`+ for (auto s = 0; s < proton.size(); s++)`
`107`	`107`
`108`	`108`	`if (proton.at(s)->GetCrystalId() == used.at(p))`
`109`	`109`	`proton.erase(proton.begin() + s);`
`110`	`110`	`}`
`111`	`111`
`112`		`- for (int p = 0; p < used.size(); p++)`
	`112`	`+ for (auto p = 0; p < used.size(); p++)`
`113`	`113`	`{`
`114`		`- for (int s = 0; s < saturated.size(); s++)`
	`114`	`+ for (auto s = 0; s < saturated.size(); s++)`
`115`	`115`
`116`	`116`	`if (saturated.at(s)->GetCrystalId() == used.at(p))`
`117`	`117`	`saturated.erase(saturated.begin() + s);`
`@@ -152,7 +152,7 @@ R3BCalifaCrystalCal2Cluster::~R3BCalifaCrystalCal2Cluster()`
`152`	`152`
`153`	`153`	`void R3BCalifaCrystalCal2Cluster::SetParContainers()`
`154`	`154`	`{`
`155`		`- FairRuntimeDb* rtdb = FairRuntimeDb::instance();`
	`155`	`+ auto* rtdb = FairRuntimeDb::instance();`
`156`	`156`	`R3BLOG_IF(fatal, !rtdb, "FairRuntimeDb not found");`
`157`	`157`
`158`	`158`	`fCalifaGeoPar = dynamic_cast<R3BTGeoPar*>(rtdb->getContainer("CalifaGeoPar"));`
`@@ -166,24 +166,35 @@ void R3BCalifaCrystalCal2Cluster::SetParContainers()`
`166`	`166`	`else`
`167`	`167`	`{`
`168`	`168`	`R3BLOG(info, "Container CalifaGeoPar found.");`
`169`		`- fCalifaPos.SetXYZ(fCalifaGeoPar->GetPosX(), fCalifaGeoPar->GetPosY(), fCalifaGeoPar->GetPosZ());`
`170`	`169`	`}`
`171`	`170`
`172`		`- if (!fCalifaGeoPar \|\| !fTargetGeoPar)`
	`171`	`+ if (!fTargetGeoPar)`
`173`	`172`	`{`
`174`		`- R3BLOG_IF(warn, !fTargetGeoPar, "Could not get access to TargetGeoPar container. Setting nominal position. ");`
	`173`	`+ R3BLOG_IF(warn, !fTargetGeoPar, "Could not get access to TargetGeoPar container. Setting nominal position.");`
`175`	`174`	`fTargetPos.SetXYZ(0.0, 0.0, 0.0);`
`176`	`175`	`}`
`177`	`176`	`else`
`178`	`177`	`{`
`179`	`178`	`R3BLOG(info, "Container TargetGeoPar found.");`
	`179`	`+ }`
	`180`	`+`
	`181`	`+ return;`
	`182`	`+}`
	`183`	`+`
	`184`	`+void R3BCalifaCrystalCal2Cluster::SetParameter()`
	`185`	`+{`
	`186`	`+ if (fCalifaGeoPar)`
	`187`	`+ {`
	`188`	`+ fCalifaPos.SetXYZ(fCalifaGeoPar->GetPosX(), fCalifaGeoPar->GetPosY(), fCalifaGeoPar->GetPosZ());`
	`189`	`+ }`
	`190`	`+`
	`191`	`+ if (fTargetGeoPar)`
	`192`	`+ {`
`180`	`193`	`fTargetPos.SetXYZ(fTargetGeoPar->GetPosX(), fTargetGeoPar->GetPosY(), fTargetGeoPar->GetPosZ());`
`181`	`194`	`}`
`182`	`195`
`183`	`196`	`LOG(info) << "Califa position : X = " << fCalifaPos.X() << " Y = " << fCalifaPos.Y() << " Z = " << fCalifaPos.Z();`
`184`	`197`	`LOG(info) << "Target position : X = " << fTargetPos.X() << " Y = " << fTargetPos.Y() << " Z = " << fTargetPos.Z();`
`185`		`-`
`186`		`- return;`
`187`	`198`	`}`
`188`	`199`
`189`	`200`	`InitStatus R3BCalifaCrystalCal2Cluster::Init()`
`@@ -199,6 +210,9 @@ InitStatus R3BCalifaCrystalCal2Cluster::Init()`
`199`	`210`	`fCalifaClusterData = new TClonesArray("R3BCalifaClusterData");`
`200`	`211`	`rootman->Register("CalifaClusterData", "CALIFA Cluster", fCalifaClusterData, !fOnline);`
`201`	`212`
	`213`	`+ // Load parameters`
	`214`	`+ SetParameter();`
	`215`	`+`
`202`	`216`	`if (R3BCalifaGeometry::Instance()->IsSimulation() == true)`
`203`	`217`	`{`
`204`	`218`	`fTotalCrystals = R3BCalifaGeometry::Instance()->GetNbCrystals() / 2;`
`@@ -223,7 +237,7 @@ InitStatus R3BCalifaCrystalCal2Cluster::Init()`
`223`	`237`	`R3BLOG_IF(fatal, !fHistoFile, "Randomization file not found");`
`224`	`238`
`225`	`239`	`fAngularDistributions = new TH2F*[fTotalCrystals];`
`226`		`- for (Int_t i = 0; i < fTotalCrystals; i++)`
	`240`	`+ for (auto i = 0; i < fTotalCrystals; i++)`
`227`	`241`	`{`
`228`	`242`	`std::string name = "distributionCrystalID_" + std::to_string(i + 1);`
`229`	`243`	`fHistoFile->GetObject(name.c_str(), fAngularDistributions[i]);`
`@@ -235,14 +249,15 @@ InitStatus R3BCalifaCrystalCal2Cluster::Init()`
`235`	`249`	`InitStatus R3BCalifaCrystalCal2Cluster::ReInit()`
`236`	`250`	`{`
`237`	`251`	`SetParContainers();`
	`252`	`+ SetParameter();`
`238`	`253`	`return kSUCCESS;`
`239`	`254`	`}`
`240`	`255`
`241`	`256`	`void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /opt/)`
`242`	`257`	`{`
`243`	`258`	`Reset();`
`244`	`259`
`245`		`- const int numCrystalHits = fCrystalCalData->GetEntriesFast();`
	`260`	`+ auto numCrystalHits = fCrystalCalData->GetEntriesFast();`
`246`	`261`
`247`	`262`	`if (numCrystalHits == 0)`
`248`	`263`	`return;`
`@@ -256,10 +271,10 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /opt/)`
`256`	`271`
`257`	`272`	`vector<uint16_t> usedCrystals;`
`258`	`273`
`259`		`- Double_t cryEnergy = 0.;`
`260`		`- Int_t cryId = 0;`
	`274`	`+ double cryEnergy = 0.;`
	`275`	`+ int cryId = 0;`
`261`	`276`
`262`		`- for (Int_t i = 0; i < numCrystalHits; i++)`
	`277`	`+ for (auto i = 0; i < numCrystalHits; i++)`
`263`	`278`	`{`
`264`	`279`	`cryId = dynamic_cast<R3BCalifaCrystalCalData*>(fCrystalCalData->At(i))->GetCrystalId();`
`265`	`280`	`cryEnergy = dynamic_cast<R3BCalifaCrystalCalData*>(fCrystalCalData->At(i))->GetEnergy();`
`@@ -294,9 +309,9 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /opt/)`
`294`	`309`	`}`
`295`	`310`
`296`	`311`	`/* ----- Remove duplicate entries in gamma clusters ----- */`
`297`		`- for (int k = 0; k < gammaCandidatesVec.size(); k++)`
	`312`	`+ for (auto k = 0; k < gammaCandidatesVec.size(); k++)`
`298`	`313`	`{`
`299`		`- for (int s = 0; s < gammaCandidatesVec.size(); s++)`
	`314`	`+ for (auto s = 0; s < gammaCandidatesVec.size(); s++)`
`300`	`315`	`{`
`301`	`316`	`if (gammaCandidatesVec.at(k)->GetCrystalId() == (gammaCandidatesVec.at(s)->GetCrystalId() - fTotalCrystals))`
`302`	`317`	`gammaCandidatesVec.erase(gammaCandidatesVec.begin() + s);`
`@@ -313,7 +328,7 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /opt/)`
`313`	`328`
`314`	`329`	`while (protonCandidatesVec.size())`
`315`	`330`	`{`
`316`		`- Int_t motherId = protonCandidatesVec.at(0)->GetCrystalId();`
	`331`	`+ auto motherId = protonCandidatesVec.at(0)->GetCrystalId();`
`317`	`332`
`318`	`333`	`califa_candidate cluster = { motherId, vector<uint16_t>(), 0.0, 0.0, 0.0, 0.0, 0.0 };`
`319`	`334`
`@@ -328,7 +343,6 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /opt/)`
`328`	`343`
`329`	`344`	`if (fRand)`
`330`	`345`	`{`
`331`		`-`
`332`	`346`	`if (motherId > fTotalCrystals)`
`333`	`347`	`fAngularDistributions[protonCandidatesVec.at(0)->GetCrystalId() - 1 - fTotalCrystals]->GetRandom2(`
`334`	`348`	`fRandPhi, fRandTheta);`
`@@ -350,10 +364,10 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /opt/)`
`350`	`364`
`351`	`365`	`addCrystal2Cluster(&cluster, protonCandidatesVec.at(0), "proton", &usedCrystals, fTotalCrystals);`
`352`	`366`
`353`		`- for (Int_t j = 0; j < allCrystalVec.size(); j++)`
	`367`	`+ for (auto j = 0; j < allCrystalVec.size(); j++)`
`354`	`368`	`{`
`355`		`- Int_t thisCryId = allCrystalVec.at(j)->GetCrystalId();`
`356`		`- Float_t thisEnergy = allCrystalVec.at(j)->GetEnergy();`
	`369`	`+ auto thisCryId = allCrystalVec.at(j)->GetCrystalId();`
	`370`	`+ auto thisEnergy = allCrystalVec.at(j)->GetEnergy();`
`357`	`371`
`358`	`372`	`if (thisCryId > fTotalCrystals && !isInside(usedCrystals, thisCryId) && !fSimulation)`
`359`	`373`	`{`
`@@ -367,7 +381,6 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /opt/)`
`367`	`381`	`if (thisCryId <= fTotalCrystals && !isInside(usedCrystals, thisCryId) && !std::isnan(thisEnergy) &&`
`368`	`382`	`!fSimulation)`
`369`	`383`	`{`
`370`		`-`
`371`	`384`	`angles = R3BCalifaGeometry::Instance()->GetAngles(thisCryId);`
`372`	`385`
`373`	`386`	`if (InsideClusterWindow(mother_angles, angles))`
`@@ -377,7 +390,6 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /opt/)`
`377`	`390`	`/* ------- Simulation ------- */`
`378`	`391`	`if (!isInside(usedCrystals, thisCryId) && fSimulation)`
`379`	`392`	`{`
`380`		`-`
`381`	`393`	`angles = R3BCalifaGeometry::Instance()->GetAngles(thisCryId);`
`382`	`394`
`383`	`395`	`// add to gamma or proton cluster depending on crystal id`
`@@ -400,7 +412,7 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /opt/)`
`400`	`412`	`/------ Gamma Clusters ------- /`
`401`	`413`	`while (gammaCandidatesVec.size())`
`402`	`414`	`{`
`403`		`- Int_t motherId = gammaCandidatesVec.at(0)->GetCrystalId();`
	`415`	`+ auto motherId = gammaCandidatesVec.at(0)->GetCrystalId();`
`404`	`416`
`405`	`417`	`califa_candidate cluster = { motherId, vector<uint16_t>(), 0.0, 0.0, 0.0, 0.0, 0.0 };`
`406`	`418`
`@@ -436,9 +448,9 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /opt/)`
`436`	`448`
`437`	`449`	`addCrystal2Cluster(&cluster, gammaCandidatesVec.at(0), "gamma", &usedCrystals, fTotalCrystals);`
`438`	`450`
`439`		`- for (Int_t j = 0; j < allCrystalVec.size(); j++)`
	`451`	`+ for (auto j = 0; j < allCrystalVec.size(); j++)`
`440`	`452`	`{`
`441`		`- Int_t thisCryId = allCrystalVec.at(j)->GetCrystalId();`
	`453`	`+ auto thisCryId = allCrystalVec.at(j)->GetCrystalId();`
`442`	`454`
`443`	`455`	`if (thisCryId <= fTotalCrystals && !isInside(usedCrystals, thisCryId) && !fSimulation)`
`444`	`456`	`{`
`@@ -449,9 +461,9 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /opt/)`
`449`	`461`	`}`
`450`	`462`	`}`
`451`	`463`
`452`		`- for (Int_t j = 0; j < allCrystalVec.size(); j++)`
	`464`	`+ for (auto j = 0; j < allCrystalVec.size(); j++)`
`453`	`465`	`{`
`454`		`- Int_t thisCryId = allCrystalVec.at(j)->GetCrystalId();`
	`466`	`+ auto thisCryId = allCrystalVec.at(j)->GetCrystalId();`
`455`	`467`
`456`	`468`	`if (thisCryId > fTotalCrystals && !isInside(usedCrystals, thisCryId) && !fSimulation)`
`457`	`469`	`{`
`@@ -462,9 +474,9 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /opt/)`
`462`	`474`	`}`
`463`	`475`	`}`
`464`	`476`
`465`		`- for (Int_t j = 0; j < allCrystalVec.size(); j++)`
	`477`	`+ for (auto j = 0; j < allCrystalVec.size(); j++)`
`466`	`478`	`{`
`467`		`- Int_t thisCryId = allCrystalVec.at(j)->GetCrystalId();`
	`479`	`+ auto thisCryId = allCrystalVec.at(j)->GetCrystalId();`
`468`	`480`
`469`	`481`	`if (!isInside(usedCrystals, thisCryId) && fSimulation)`
`470`	`482`	`{`
`@@ -486,7 +498,7 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /opt/)`
`486`	`498`	`/* ----------- Saturation Clusters ----------- */`
`487`	`499`	`while (saturatedCandidatesVec.size())`
`488`	`500`	`{`
`489`		`- Int_t motherId = saturatedCandidatesVec.at(0)->GetCrystalId();`
	`501`	`+ auto motherId = saturatedCandidatesVec.at(0)->GetCrystalId();`
`490`	`502`
`491`	`503`	`califa_candidate cluster = { motherId, vector<uint16_t>(), 0.0, 0.0, 0.0, 0.0, 0.0 };`
`492`	`504`
`@@ -507,9 +519,9 @@ void R3BCalifaCrystalCal2Cluster::Exec(Option_t* /opt/)`
`507`	`519`
`508`	`520`	`addCrystal2Cluster(&cluster, saturatedCandidatesVec.at(0), "gamma", &usedCrystals, fTotalCrystals);`
`509`	`521`
`510`		`- for (Int_t j = 0; j < allCrystalVec.size(); j++)`
	`522`	`+ for (auto j = 0; j < allCrystalVec.size(); j++)`
`511`	`523`	`{`
`512`		`- Int_t thisCryId = allCrystalVec.at(j)->GetCrystalId();`
	`524`	`+ auto thisCryId = allCrystalVec.at(j)->GetCrystalId();`
`513`	`525`
`514`	`526`	`if (thisCryId > fTotalCrystals && !isInside(usedCrystals, thisCryId))`
`515`	`527`	`{`
`@@ -562,7 +574,7 @@ R3BCalifaClusterData* R3BCalifaCrystalCal2Cluster::AddCluster(vector<uint16_t> c`
`562`	`574`	`uint8_t clusterType)`
`563`	`575`	`{`
`564`	`576`	`TClonesArray& clref = *fCalifaClusterData;`
`565`		`- Int_t size = clref.GetEntriesFast();`
	`577`	`+ auto size = clref.GetEntriesFast();`
`566`	`578`	`return new (clref[size]) R3BCalifaClusterData(crystalList, ene, Nf, Ns, pAngle, aAngle, time, clusterType);`
`567`	`579`	`}`
`568`	`580`