diff --git a/src/libs/antares/study/area/list.cpp b/src/libs/antares/study/area/list.cpp
index de3c2e9b1f..46a2e98c6f 100644
--- a/src/libs/antares/study/area/list.cpp
+++ b/src/libs/antares/study/area/list.cpp
@@ -449,43 +449,31 @@ const AreaLink* AreaList::findLink(const AreaName& area, const AreaName& with) c
 
 void AreaList::clear()
 {
-    delete[] byIndex;
-    byIndex = nullptr;
+    byIndex.clear();
 
-    if (!areas.empty())
-    {
-        Area::Map copy;
-        copy.swap(areas);
+    Area::Map copy;
+    copy.swap(areas);
 
-        auto end = copy.end();
-        for (auto i = copy.begin(); i != end; ++i)
-        {
-            delete i->second;
-        }
+    auto end = copy.end();
+    for (auto i = copy.begin(); i != end; ++i)
+    {
+        delete i->second;
     }
 }
 
 void AreaList::rebuildIndexes()
 {
-    delete[] byIndex;
+    byIndex.clear();
 
-    if (areas.empty())
-    {
-        byIndex = nullptr;
-    }
-    else
-    {
-        using AreaWeakPtr = Area*;
-        byIndex = new AreaWeakPtr[areas.size()];
+    byIndex.resize(areas.size());
 
-        uint indx = 0;
-        auto end = areas.end();
-        for (auto i = areas.begin(); i != end; ++i, ++indx)
-        {
-            Area* area = i->second;
-            byIndex[indx] = area;
-            area->index = indx;
-        }
+    uint indx = 0;
+    auto end = areas.end();
+    for (auto i = areas.begin(); i != end; ++i, ++indx)
+    {
+        Area* area = i->second;
+        byIndex[indx] = area;
+        area->index = indx;
     }
 }
 
diff --git a/src/libs/antares/study/include/antares/study/area/area.h b/src/libs/antares/study/include/antares/study/area/area.h
index 6661ab8556..7550d9840f 100644
--- a/src/libs/antares/study/include/antares/study/area/area.h
+++ b/src/libs/antares/study/include/antares/study/area/area.h
@@ -689,7 +689,7 @@ class AreaList final: public Yuni::NonCopyable<AreaList>
 
 public:
     //! All areas by their index
-    Area** byIndex = nullptr;
+    std::vector<Area*> byIndex;
     //! All areas in the list
     Area::Map areas;
 
diff --git a/src/solver/misc/include/antares/solver/misc/cholesky.hxx b/src/solver/misc/include/antares/solver/misc/cholesky.hxx
index 26c333d785..90418c17b2 100644
--- a/src/solver/misc/include/antares/solver/misc/cholesky.hxx
+++ b/src/solver/misc/include/antares/solver/misc/cholesky.hxx
@@ -42,7 +42,7 @@ bool Cholesky(U1& L, U2& A, uint size, T* temp)
 
     for (uint i = 0; i < size; ++i)
     {
-        typename MatrixSubColumn<U1>::Type Li = L[i];
+        auto& Li = L[i];
 
         // on calcule d'abord L[i][i]
         som = A[i][i];
@@ -58,8 +58,8 @@ bool Cholesky(U1& L, U2& A, uint size, T* temp)
             // maintenant on cherche L[k][i], k > i.
             for (uint k = i + 1; k < size; ++k)
             {
-                typename MatrixSubColumn<U1>::Type Lk = L[k];
-                typename MatrixSubColumn<U2>::Type Ak = A[k];
+                auto& Lk = L[k];
+                auto& Ak = A[k];
 
                 if (temp[k] == Ak[k])
                 {
diff --git a/src/solver/ts-generator/include/antares/solver/ts-generator/xcast/xcast.h b/src/solver/ts-generator/include/antares/solver/ts-generator/xcast/xcast.h
index 55bb128e85..34b588b972 100644
--- a/src/solver/ts-generator/include/antares/solver/ts-generator/xcast/xcast.h
+++ b/src/solver/ts-generator/include/antares/solver/ts-generator/xcast/xcast.h
@@ -74,7 +74,7 @@ class XCast final: private Yuni::NonCopyable<XCast>
     /*!
     ** \brief Destructor
     */
-    ~XCast();
+    ~XCast() = default;
     //@}
 
     //! \name Loading
@@ -105,7 +105,6 @@ class XCast final: private Yuni::NonCopyable<XCast>
 
 private:
     void allocateTemporaryData();
-    void destroyTemporaryData();
 
     template<class PredicateT>
     void updateMissingCoefficients(PredicateT& predicate);
@@ -180,7 +179,7 @@ class XCast final: private Yuni::NonCopyable<XCast>
     //! The correlation matrix for the current month
     const Matrix<float>* pCorrMonth;
 
-    bool pNeverInitialized;
+    bool pNeverInitialized = true;
     uint Nombre_points_intermediaire;
 
     //! True when starting a new month (some data may have to be reinitialized)
@@ -192,57 +191,58 @@ class XCast final: private Yuni::NonCopyable<XCast>
     uint pNDPMatrixCount;
     uint pLevellingCount;
 
-    bool pAccuracyOnCorrelation;
+    bool pAccuracyOnCorrelation = false;
     bool All_normal; // all processes are Normal
 
-    float* A; // les variables de A à CO sont des vues de ALPH à CORR pour un mois particulier
-    float* B;
-    float* G;
-    float* D;
-    int* M;
-    float* T;
-    Data::XCast::Distribution* L;
-    bool* BO;
-    float* MA;
-    float* MI;
-    float** FO; // contrainte : FO >=0
+    // les variables de A à CO sont des vues de ALPH à CORR pour un mois particulier
+    std::vector<float> A;
+    std::vector<float> B;
+    std::vector<float> G;
+    std::vector<float> D;
+    std::vector<int> M;
+    std::vector<float> T;
+    std::vector<Data::XCast::Distribution> L;
+    std::vector<bool> BO;
+    std::vector<float> MA;
+    std::vector<float> MI;
+    std::vector<std::vector<float>> FO; // contrainte : FO >=0
 
     float STEP;
     float SQST;
-    float* POSI;
-    float** CORR;
-    float* MAXI;
-    float* MINI;
-    float* Presque_maxi;
-    float* Presque_mini;
-    float* ESPE;
-    float* STDE;
-    float** LISS;
-    float** DATL;
-
-    float* DIFF;
-    float* TREN;
-    float* WIEN;
-    float* BROW;
-
-    float* BASI; // used only if all processes are Normal
-    float* ALPH; // used only if all processes are Normal
-    float* BETA; // used only if all processes are Normal
-
-    float** Triangle_reference;
-    float** Triangle_courant;
-    float** Carre_reference;
-    float** Carre_courant;
-
-    float* D_COPIE;
-
-    float** DATA;
+    std::vector<float> POSI;
+    std::vector<std::vector<float>> CORR;
+    std::vector<float> MAXI;
+    std::vector<float> MINI;
+    std::vector<float> Presque_maxi;
+    std::vector<float> Presque_mini;
+    std::vector<float> ESPE;
+    std::vector<float> STDE;
+    std::vector<std::vector<float>> LISS;
+    std::vector<std::vector<float>> DATL;
+
+    std::vector<float> DIFF;
+    std::vector<float> TREN;
+    std::vector<float> WIEN;
+    std::vector<float> BROW;
+
+    std::vector<float> BASI; // used only if all processes are Normal
+    std::vector<float> ALPH; // used only if all processes are Normal
+    std::vector<float> BETA; // used only if all processes are Normal
+
+    std::vector<std::vector<float>> Triangle_reference;
+    std::vector<std::vector<float>> Triangle_courant;
+    std::vector<std::vector<float>> Carre_reference;
+    std::vector<std::vector<float>> Carre_courant;
+
+    std::vector<float> D_COPIE;
+
+    std::vector<std::vector<float>> DATA;
 
     // cholesky temporary data
-    float* pQCHOLTotal;
+    std::vector<float> pQCHOLTotal;
 
     //!
-    bool* pUseConversion;
+    std::vector<bool> pUseConversion;
 
     //! Name of the current timeseries
     Yuni::CString<32, false> pTSName;
diff --git a/src/solver/ts-generator/xcast/core.cpp b/src/solver/ts-generator/xcast/core.cpp
index a3d373e2c1..1eab73d534 100644
--- a/src/solver/ts-generator/xcast/core.cpp
+++ b/src/solver/ts-generator/xcast/core.cpp
@@ -93,7 +93,7 @@ bool XCast::generateValuesForTheCurrentDay()
     // si les parametres ont change on reinitialise certaines variables intermediaires
     if (pNewMonth)
     {
-        if (Cholesky<float>(Triangle_courant, pCorrMonth->entry, processCount, pQCHOLTotal))
+        if (Cholesky<float>(Triangle_courant, pCorrMonth->entry, processCount, pQCHOLTotal.data()))
         {
             // C n'est pas sdp, mais peut-etre proche de sdp
             // on tente un abattement de 0.999
@@ -107,7 +107,10 @@ bool XCast::generateValuesForTheCurrentDay()
                 }
             }
 
-            if (Cholesky<float>(Triangle_courant, pCorrMonth->entry, processCount, pQCHOLTotal))
+            if (Cholesky<float>(Triangle_courant,
+                                pCorrMonth->entry,
+                                processCount,
+                                pQCHOLTotal.data()))
             {
                 // la matrice C n'est pas admissible, on abandonne
                 logs.error() << "TS " << pTSName << " generator: invalid correlation matrix";
@@ -227,7 +230,7 @@ bool XCast::generateValuesForTheCurrentDay()
                                      Carre_reference,
                                      pCorrMonth->entry,
                                      processCount,
-                                     pQCHOLTotal);
+                                     pQCHOLTotal.data());
         if (shrink == -1.f)
         {
             // sortie impossible  car on a v�rifi� que C est d.p
@@ -414,7 +417,7 @@ bool XCast::generateValuesForTheCurrentDay()
 
                     for (uint s = 0; s != processCount; ++s)
                     {
-                        float* corr_s = CORR[s];
+                        auto& corr_s = CORR[s];
                         auto& userMonthlyCorr = pCorrMonth->column(s);
                         for (uint t = 0; t < s; ++t)
                         {
@@ -453,7 +456,7 @@ bool XCast::generateValuesForTheCurrentDay()
                                                  Carre_courant,
                                                  Carre_reference,
                                                  processCount,
-                                                 pQCHOLTotal);
+                                                 pQCHOLTotal.data());
                     if (shrink <= 1.f)
                     {
                         if (shrink == -1.f)
diff --git a/src/solver/ts-generator/xcast/xcast.cpp b/src/solver/ts-generator/xcast/xcast.cpp
index 56f7234119..b431e8d8ff 100644
--- a/src/solver/ts-generator/xcast/xcast.cpp
+++ b/src/solver/ts-generator/xcast/xcast.cpp
@@ -52,17 +52,10 @@ enum
 XCast::XCast(Data::Study& study, Data::TimeSeriesType ts, IResultWriter& writer):
     study(study),
     timeSeriesType(ts),
-    pNeverInitialized(true),
-    pAccuracyOnCorrelation(false),
     pWriter(writer)
 {
 }
 
-XCast::~XCast()
-{
-    destroyTemporaryData();
-}
-
 template<class PredicateT>
 void XCast::exportTimeSeriesToTheOutput(Progression::Task& progression, PredicateT& predicate)
 {
@@ -114,8 +107,6 @@ void XCast::applyTransferFunction(PredicateT& predicate)
     float a[maxPoints];
     float b[maxPoints];
 
-    float* dailyResults;
-
     const uint processCount = (uint)pData.localareas.size();
 
     for (uint s = 0; s != processCount; ++s)
@@ -145,7 +136,7 @@ void XCast::applyTransferFunction(PredicateT& predicate)
                 b[i] = (p0[y] * p1[x] - p1[y] * p0[x]) / (p1[x] - p0[x]);
             }
 
-            dailyResults = DATA[s];
+            auto& dailyResults = DATA[s];
             for (h = 0; h != HOURS_PER_DAY; ++h)
             {
                 for (i = 0; i != tf.width; ++i)
@@ -200,162 +191,64 @@ void XCast::updateMissingCoefficients(PredicateT& predicate)
     }
 }
 
-namespace
-{
-template<int DebugT>
-class Allocator
-{
-public:
-    Allocator():
-        allocated(0)
-    {
-    }
-
-    ~Allocator()
-    {
-        logs.debug() << "  allocated " << (allocated / 1024) << "Ko";
-    }
-
-    template<class T>
-    inline T* allocate(const size_t s)
-    {
-        allocated += sizeof(T) * s;
-        return new T[s];
-    }
-
-public:
-    size_t allocated;
-};
-
-template<>
-class Allocator<0>
-{
-public:
-    template<class T>
-    inline T* allocate(const size_t s) const
-    {
-        return new T[s];
-    }
-};
-
-} // namespace
-
 void XCast::allocateTemporaryData()
 {
     uint p = (uint)pData.localareas.size();
 
-    Allocator<Yuni::Logs::Verbosity::Debug::enabled> m;
-
-    A = m.allocate<float>(p);
-    B = m.allocate<float>(p);
-    G = m.allocate<float>(p);
-    D = m.allocate<float>(p);
-    M = m.allocate<int>(p);
-    T = m.allocate<float>(p);
-    BO = m.allocate<bool>(p);
-    MA = m.allocate<float>(p);
-    MI = m.allocate<float>(p);
-    L = m.allocate<Data::XCast::Distribution>(p);
-    POSI = m.allocate<float>(p);
-    MAXI = m.allocate<float>(p);
-    MINI = m.allocate<float>(p);
-    ESPE = m.allocate<float>(p);
-    STDE = m.allocate<float>(p);
-    DIFF = m.allocate<float>(p);
-    TREN = m.allocate<float>(p);
-    WIEN = m.allocate<float>(p + 1);
-    BROW = m.allocate<float>(p);
-
-    BASI = m.allocate<float>(p);
-    ALPH = m.allocate<float>(p);
-    BETA = m.allocate<float>(p);
-
-    D_COPIE = m.allocate<float>(p);
-
-    pUseConversion = m.allocate<bool>(p);
-
-    Presque_maxi = m.allocate<float>(p);
-    Presque_mini = m.allocate<float>(p);
-    pQCHOLTotal = m.allocate<float>(p);
-
-    CORR = m.allocate<float*>(p);
-    Triangle_reference = m.allocate<float*>(p);
-    Triangle_courant = m.allocate<float*>(p);
-    FO = m.allocate<float*>(p);
-    LISS = m.allocate<float*>(p);
-    DATL = m.allocate<float*>(p);
-    DATA = m.allocate<float*>(p);
-    Carre_courant = m.allocate<float*>(p);
-    Carre_reference = m.allocate<float*>(p);
+    A.resize(p);
+    B.resize(p);
+    G.resize(p);
+    D.resize(p);
+    M.resize(p);
+    T.resize(p);
+    BO.resize(p);
+    MA.resize(p);
+    MI.resize(p);
+    L.resize(p);
+    POSI.resize(p);
+    MAXI.resize(p);
+    MINI.resize(p);
+    ESPE.resize(p);
+    STDE.resize(p);
+    DIFF.resize(p);
+    TREN.resize(p);
+    WIEN.resize(p + 1);
+    BROW.resize(p);
+
+    BASI.resize(p);
+    ALPH.resize(p);
+    BETA.resize(p);
+
+    D_COPIE.resize(p);
+
+    pUseConversion.resize(p);
+
+    Presque_maxi.resize(p);
+    Presque_mini.resize(p);
+    pQCHOLTotal.resize(p);
+
+    CORR.resize(p);
+    Triangle_reference.resize(p);
+    Triangle_courant.resize(p);
+    FO.resize(p);
+    LISS.resize(p);
+    DATL.resize(p);
+    DATA.resize(p);
+    Carre_courant.resize(p);
+    Carre_reference.resize(p);
 
     for (uint i = 0; i != p; ++i)
     {
-        Triangle_reference[i] = m.allocate<float>(p);
-        Triangle_courant[i] = m.allocate<float>(p);
-        Carre_courant[i] = m.allocate<float>(p);
-        Carre_reference[i] = m.allocate<float>(p);
-
-        CORR[i] = m.allocate<float>(p);
-        FO[i] = m.allocate<float>(24);
-        LISS[i] = m.allocate<float>(24);
-        DATL[i] = m.allocate<float>(24);
-        DATA[i] = m.allocate<float>(24);
-    }
-}
-
-void XCast::destroyTemporaryData()
-{
-    if (!pNeverInitialized)
-    {
-        uint p = (uint)pData.localareas.size();
-        for (uint i = 0; i != p; ++i)
-        {
-            delete[] CORR[i];
-            delete[] FO[i];
-            delete[] LISS[i];
-            delete[] DATL[i];
-            delete[] Triangle_reference[i];
-            delete[] Triangle_courant[i];
-            delete[] DATA[i];
-            delete[] Carre_courant[i];
-            delete[] Carre_reference[i];
-        }
-        delete[] Carre_courant;
-        delete[] Carre_reference;
-        delete[] D_COPIE;
-        delete[] DATA;
-        delete[] Triangle_reference;
-        delete[] Triangle_courant;
-        delete[] LISS;
-        delete[] DATL;
-        delete[] CORR;
-        delete[] FO;
-        delete[] A;
-        delete[] B;
-        delete[] G;
-        delete[] D;
-        delete[] M;
-        delete[] T;
-        delete[] L;
-        delete[] BO;
-        delete[] MA;
-        delete[] MI;
-        delete[] POSI;
-        delete[] MAXI;
-        delete[] MINI;
-        delete[] Presque_maxi;
-        delete[] Presque_mini;
-        delete[] ESPE;
-        delete[] STDE;
-        delete[] DIFF;
-        delete[] TREN;
-        delete[] WIEN;
-        delete[] BROW;
-        delete[] BASI;
-        delete[] ALPH;
-        delete[] BETA;
-        delete[] pQCHOLTotal;
-        delete[] pUseConversion;
+        Triangle_reference[i].resize(p);
+        Triangle_courant[i].resize(p);
+        Carre_courant[i].resize(p);
+        Carre_reference[i].resize(p);
+
+        CORR[i].resize(p);
+        FO[i].resize(24);
+        LISS[i].resize(24);
+        DATL[i].resize(24);
+        DATA[i].resize(24);
     }
 }
 
@@ -476,7 +369,7 @@ bool XCast::runWithPredicate(PredicateT& predicate, Progression::Task& progressi
                     MA[s] = +std::numeric_limits<float>::max();
                 }
                 }
-                memcpy(FO[s], xcastdata.K[realmonth], sizeof(float) * HOURS_PER_DAY);
+                memcpy(FO[s].data(), xcastdata.K[realmonth], sizeof(float) * HOURS_PER_DAY);
             }
 
             uint nbDaysPerMonth = study.calendar.months[month].days;
@@ -491,7 +384,7 @@ bool XCast::runWithPredicate(PredicateT& predicate, Progression::Task& progressi
 
                 for (uint s = 0; s != processCount; ++s)
                 {
-                    float* dailyResults = DATA[s];
+                    auto& dailyResults = DATA[s];
 
                     for (uint h = 0; h != HOURS_PER_DAY; ++h)
                     {
@@ -512,7 +405,7 @@ bool XCast::runWithPredicate(PredicateT& predicate, Progression::Task& progressi
                     }
 
                     auto& column = srcData.translation[0];
-                    float* dailyResults = DATA[s];
+                    auto& dailyResults = DATA[s];
                     assert(hourInTheYear + HOURS_PER_DAY <= srcData.translation.height
                            && "Bound checking");
 
@@ -529,7 +422,7 @@ bool XCast::runWithPredicate(PredicateT& predicate, Progression::Task& progressi
 
                 for (uint s = 0; s != processCount; ++s)
                 {
-                    float* dailyResults = DATA[s];
+                    auto& dailyResults = DATA[s];
 
                     for (uint h = 0; h != HOURS_PER_DAY; ++h)
                     {
@@ -548,7 +441,7 @@ bool XCast::runWithPredicate(PredicateT& predicate, Progression::Task& progressi
                     auto& series = predicate.matrix(currentArea);
                     assert(tsIndex < series.width);
                     auto& column = series.column(tsIndex);
-                    float* dailyResults = DATA[s];
+                    auto& dailyResults = DATA[s];
 
                     for (uint h = 0; h != HOURS_PER_DAY; ++h)
                     {