- swithced to prefix "++"

- some stylistic changes
- changed quotes

diff --git a/src/domains.cpp b/src/domains.cpp
index a03015f7ec5edf9b01714caf881de3122fbf7491..235b30a3d377a83c488966406e5d57736f8a99e4 100644 (file)
--- a/src/domains.cpp
+++ b/src/domains.cpp
@@ -173,7 +173,7 @@ Domains::initAnalysis(const TrajectoryAnalysisSettings &settings,
 {
     // считывание индекса
     index.resize(0);
 {
     // считывание индекса
     index.resize(0);

-    for (ArrayRef< const int >::iterator ai {selec.atomIndices().begin()}; (ai < selec.atomIndices().end()); ai++) {
+    for (ArrayRef< const int >::iterator ai {selec.atomIndices().begin()}; (ai < selec.atomIndices().end()); ++ai) {

         index.push_back(static_cast< size_t >(*ai));
     }
 
         index.push_back(static_cast< size_t >(*ai));
     }
 


@@ -193,9 +193,9 @@ Domains::initAnalysis(const TrajectoryAnalysisSettings &settings,
     // создание пар для фитирования структур
     fitPairs.resize(0);
     fitPairs.resize(bone);
     // создание пар для фитирования структур
     fitPairs.resize(0);
     fitPairs.resize(bone);

-    for (size_t i {0}; i < bone; i++) {
+    for (size_t i {0}; i < bone; ++i) {

         fitPairs[i].resize(0);
         fitPairs[i].resize(0);

-        for (size_t j {0}; j < domain_min_size; j++) {
+        for (size_t j {0}; j < domain_min_size; ++j) {

             fitPairs[i].push_back(std::make_pair(j + i, j + i));
         }
     }
             fitPairs[i].push_back(std::make_pair(j + i, j + i));
         }
     }


@@ -211,7 +211,7 @@ void
 Domains::analyzeFrame(int frnr, const t_trxframe &fr, t_pbc *pbc, TrajectoryAnalysisModuleData *pdata)
 {
     // считывания текущего фрейма траектории
 Domains::analyzeFrame(int frnr, const t_trxframe &fr, t_pbc *pbc, TrajectoryAnalysisModuleData *pdata)
 {
     // считывания текущего фрейма траектории

-    for (size_t i {0}; i < index.size(); i++) {
+    for (size_t i {0}; i < index.size(); ++i) {

         trajectory[i] = fr.x[index[i]];
     }
 
         trajectory[i] = fr.x[index[i]];
     }
 


@@ -222,7 +222,7 @@ Domains::analyzeFrame(int frnr, const t_trxframe &fr, t_pbc *pbc, TrajectoryAnal
 
     // фитирование каждой копии
     #pragma omp parallel for ordered schedule(dynamic) firstprivate(reference)
 
     // фитирование каждой копии
     #pragma omp parallel for ordered schedule(dynamic) firstprivate(reference)

-    for (size_t i = 0; i < bone; i++) {
+    for (size_t i = 0; i < bone; ++i) {

         MyFitNew(reference, tsTemp[i], fitPairs[i], 0.000'001);
     }
     #pragma omp barrier
         MyFitNew(reference, tsTemp[i], fitPairs[i], 0.000'001);
     }
     #pragma omp barrier

diff --git a/src/domaintests.cpp b/src/domaintests.cpp
index d5295f0bf71ca55158ef98a68a2b0ea5829b9ec0..ce634c28133b3adf47fa45dbb11a49c4cce17dfb 100644 (file)
--- a/src/domaintests.cpp
+++ b/src/domaintests.cpp
@@ -63,7 +63,7 @@ TEST( fitTests, fitTest_ApplyFit)
     std::vector< std::pair< size_t, size_t > > testPairs;
     testPairs.resize(0);
 
     std::vector< std::pair< size_t, size_t > > testPairs;
     testPairs.resize(0);
 

-    for (size_t i {0}; i < 27; i++) {
+    for (size_t i {0}; i < 27; ++i) {

         testFrame1.push_back(x1 * static_cast< float >(i % 3) + y1 * static_cast< float >((i % 9) / 3) + z1 * static_cast< float >(i / 9));
         testFrame2.push_back(x2 * static_cast< float >(i % 3) + y2 * static_cast< float >((i % 9) / 3) + z2 * static_cast< float >(i / 9));
         testPairs.push_back(std::make_pair(i, i));
         testFrame1.push_back(x1 * static_cast< float >(i % 3) + y1 * static_cast< float >((i % 9) / 3) + z1 * static_cast< float >(i / 9));
         testFrame2.push_back(x2 * static_cast< float >(i % 3) + y2 * static_cast< float >((i % 9) / 3) + z2 * static_cast< float >(i / 9));
         testPairs.push_back(std::make_pair(i, i));


@@ -94,7 +94,7 @@ TEST( fitTests, fitTest_ApplyFit)
     CalcMid(testFrame1, testFrame3, mid1, mid2, testPairs);
     ASSERT_NEAR((mid1 - mid2).norm(), 0., 0.000001);
     double testF {0};
     CalcMid(testFrame1, testFrame3, mid1, mid2, testPairs);
     ASSERT_NEAR((mid1 - mid2).norm(), 0., 0.000001);
     double testF {0};

-    for (size_t i {0}; i < testFrame1.size(); i++) {
+    for (size_t i {0}; i < testFrame1.size(); ++i) {

         testF += F(testFrame1[i].toDVec(), testFrame3[i].toDVec(), angl);
     }
     ASSERT_NEAR(testF, 0., 0.000001);
         testF += F(testFrame1[i].toDVec(), testFrame3[i].toDVec(), angl);
     }
     ASSERT_NEAR(testF, 0., 0.000001);


@@ -111,7 +111,7 @@ TEST( fitTests, fitTest_CalcMid)
     std::vector< std::pair< size_t, size_t > > testPairs;
     testPairs.resize(0);
 
     std::vector< std::pair< size_t, size_t > > testPairs;
     testPairs.resize(0);
 

-    for (size_t i {0}; i < 27; i++) {
+    for (size_t i {0}; i < 27; ++i) {

         testFrame1.push_back(x1 * static_cast< float >(i % 3) + y1 * static_cast< float >((i % 9) / 3) + z1 * static_cast< float >(i / 9));
         testFrame2.push_back(x2 * static_cast< float >(i % 3) + y2 * static_cast< float >((i % 9) / 3) + z2 * static_cast< float >(i / 9));
         testPairs.push_back(std::make_pair(i, i));
         testFrame1.push_back(x1 * static_cast< float >(i % 3) + y1 * static_cast< float >((i % 9) / 3) + z1 * static_cast< float >(i / 9));
         testFrame2.push_back(x2 * static_cast< float >(i % 3) + y2 * static_cast< float >((i % 9) / 3) + z2 * static_cast< float >(i / 9));
         testPairs.push_back(std::make_pair(i, i));


@@ -131,7 +131,7 @@ void myFitNewRoutine(const std::vector< RVec > &fr1, std::vector< RVec > fr2, co
     MyFitNew(fr1, fr2, testPairs, prc);
     tF = 0;
     DVec angl(0., 0., 0.);
     MyFitNew(fr1, fr2, testPairs, prc);
     tF = 0;
     DVec angl(0., 0., 0.);

-    for (size_t i {0}; i < fr1.size(); i++) {
+    for (size_t i {0}; i < fr1.size(); ++i) {

         tF += F(fr1[i].toDVec(), fr2[i].toDVec(), angl);
     }
 }
         tF += F(fr1[i].toDVec(), fr2[i].toDVec(), angl);
     }
 }


@@ -153,7 +153,7 @@ TEST( fitTests, fitTest_MyFitNew)
      * optimal 3x3x3 cubes fitting
     */
 
      * optimal 3x3x3 cubes fitting
     */
 

-    for (size_t i {0}; i < 27; i++) {
+    for (size_t i {0}; i < 27; ++i) {

         testFrame1.push_back(x1 * static_cast< float >(i % 3) + y1 * static_cast< float >((i % 9) / 3) + z1 * static_cast< float >(i / 9));
         testFrame2.push_back(testFrame1.back() + a);
         testPairs.push_back(std::make_pair(i, i));
         testFrame1.push_back(x1 * static_cast< float >(i % 3) + y1 * static_cast< float >((i % 9) / 3) + z1 * static_cast< float >(i / 9));
         testFrame2.push_back(testFrame1.back() + a);
         testPairs.push_back(std::make_pair(i, i));


@@ -208,7 +208,7 @@ TEST( fitTests, fitTest_MyFitNew)
 
     testFrame1.resize(0);
     testFrame2.resize(0);
 
     testFrame1.resize(0);
     testFrame2.resize(0);

-    for (size_t i {0}; i < 27; i++) {
+    for (size_t i {0}; i < 27; ++i) {

         testFrame1.push_back(x2 * static_cast< float >(i % 3) + y2 * static_cast< float >((i % 9) / 3) + z2 * static_cast< float >(i / 9));
         testFrame2.push_back(x3 * static_cast< float >(i % 3) + y3 * static_cast< float >((i % 9) / 3) + z3 * static_cast< float >(i / 9));
     }
         testFrame1.push_back(x2 * static_cast< float >(i % 3) + y2 * static_cast< float >((i % 9) / 3) + z2 * static_cast< float >(i / 9));
         testFrame2.push_back(x3 * static_cast< float >(i % 3) + y3 * static_cast< float >((i % 9) / 3) + z3 * static_cast< float >(i / 9));
     }


@@ -273,7 +273,7 @@ TEST( domainTests, domainTest_setDefaults)
     testRef.resize(0);
 
     RVec testA(0., 0., 0.), testB(1., 1., 1.);
     testRef.resize(0);
 
     RVec testA(0., 0., 0.), testB(1., 1., 1.);

-    for (size_t i {0}; i < 100; i++) {
+    for (size_t i {0}; i < 100; ++i) {

         testIndex.push_back(i);
         testRef.push_back(testA + testB * static_cast< float >(i));
     }
         testIndex.push_back(i);
         testRef.push_back(testA + testB * static_cast< float >(i));
     }


@@ -293,8 +293,8 @@ TEST( domainTests, domainTest_setDefaults)
     ASSERT_EQ(testDomain.structIndex, testIndex);
 
     ASSERT_EQ(testDomain.refTable.size(), testRef.size());
     ASSERT_EQ(testDomain.structIndex, testIndex);
 
     ASSERT_EQ(testDomain.refTable.size(), testRef.size());

-    for (size_t j {0}; j < testRef.size(); j++) {
-        for (size_t i {0}; i < testRef.size(); i++) {
+    for (size_t j {0}; j < testRef.size(); ++j) {
+        for (size_t i {0}; i < testRef.size(); ++i) {

             ASSERT_NEAR(testDomain.refTable[j][i].norm(), (testRef[i] - testRef[j]).norm(), 0.000'01);
         }
     }
             ASSERT_NEAR(testDomain.refTable[j][i].norm(), (testRef[i] - testRef[j]).norm(), 0.000'01);
         }
     }


@@ -317,16 +317,16 @@ TEST( domainTests, domainTest_update)
     testTraj2.resize(0);
     testTraj3.resize(0);
     RVec testA(1, 2, 3), testB(1, 0, 0), testC(0, 1, 0);
     testTraj2.resize(0);
     testTraj3.resize(0);
     RVec testA(1, 2, 3), testB(1, 0, 0), testC(0, 1, 0);

-    for (size_t i0 {0}; i0 < 1000; i0++) {
+    for (size_t i0 {0}; i0 < 1000; ++i0) {

         testTraj1.resize(testTraj1.size() + 1);
         testTraj2.resize(testTraj2.size() + 1);
         testTraj3.resize(testTraj3.size() + 1);
         testTraj1.resize(testTraj1.size() + 1);
         testTraj2.resize(testTraj2.size() + 1);
         testTraj3.resize(testTraj3.size() + 1);

-        for (size_t i1 {0}; i1 < 10; i1++) {
+        for (size_t i1 {0}; i1 < 10; ++i1) {

             testTraj1.back().push_back(static_cast< float >(i1) * testA + static_cast< float >(i0) * testB);
             testTraj2.back().push_back(static_cast< float >(i1) * testA + static_cast< float >(i0) * testB);
             testTraj3.back().push_back(static_cast< float >(i1) * testA + static_cast< float >(i0) * testB + static_cast< float >(i0) * testC);
         }
             testTraj1.back().push_back(static_cast< float >(i1) * testA + static_cast< float >(i0) * testB);
             testTraj2.back().push_back(static_cast< float >(i1) * testA + static_cast< float >(i0) * testB);
             testTraj3.back().push_back(static_cast< float >(i1) * testA + static_cast< float >(i0) * testB + static_cast< float >(i0) * testC);
         }

-        for (size_t i1 {0}; i1 < 10; i1++) {
+        for (size_t i1 {0}; i1 < 10; ++i1) {

             testTraj1.back().push_back(static_cast< float >(i1) * testA - static_cast< float >(i0) * testB);
             testTraj2.back().push_back(static_cast< float >(i1) * testA + static_cast< float >(i0) * testC);
             testTraj3.back().push_back(static_cast< float >(i1) * testA + static_cast< float >(i0) * testB - static_cast< float >(i0) * testC);
             testTraj1.back().push_back(static_cast< float >(i1) * testA - static_cast< float >(i0) * testB);
             testTraj2.back().push_back(static_cast< float >(i1) * testA + static_cast< float >(i0) * testC);
             testTraj3.back().push_back(static_cast< float >(i1) * testA + static_cast< float >(i0) * testB - static_cast< float >(i0) * testC);


@@ -336,7 +336,7 @@ TEST( domainTests, domainTest_update)
     testIndex.resize(0);
     std::vector< RVec > testRef;
     testRef.resize(0);
     testIndex.resize(0);
     std::vector< RVec > testRef;
     testRef.resize(0);

-    for (size_t i {0}; i < 20; i++) {
+    for (size_t i {0}; i < 20; ++i) {

         testIndex.push_back(i);
         testRef.push_back(static_cast< float >(i % 10) * testA);
     }
         testIndex.push_back(i);
         testRef.push_back(static_cast< float >(i % 10) * testA);
     }


@@ -355,7 +355,7 @@ TEST( domainTests, domainTest_update)
     testDomain3.setDefaults(testIndex, testRef, testWindowSize, testDomainMinimumSize, testDomainSearchAlgorythm, testTimeStepBetweenWindows, testSliceNum, testEpsilon, testDelta, testOutPutFileName3);
 
     std::vector< std::vector< RVec > > testTemp1, testTemp2, testTemp3;
     testDomain3.setDefaults(testIndex, testRef, testWindowSize, testDomainMinimumSize, testDomainSearchAlgorythm, testTimeStepBetweenWindows, testSliceNum, testEpsilon, testDelta, testOutPutFileName3);
 
     std::vector< std::vector< RVec > > testTemp1, testTemp2, testTemp3;

-    for (size_t i {0}; i < 1000; i++) {
+    for (size_t i {0}; i < 1000; ++i) {

         testTemp1.resize(0);
         testTemp2.resize(0);
         testTemp3.resize(0);
         testTemp1.resize(0);
         testTemp2.resize(0);
         testTemp3.resize(0);


@@ -396,7 +396,7 @@ TEST( domainTests, domainTest_getDomains)
     testRef.resize(0);
 
     RVec testA(0, 0, 0), testB(1, 1, 1);
     testRef.resize(0);
 
     RVec testA(0, 0, 0), testB(1, 1, 1);

-    for (size_t i {0}; i < 100; i++) {
+    for (size_t i {0}; i < 100; ++i) {

         testIndex.push_back(i);
         testRef.push_back(testA + testB * static_cast< float >(i));
     }
         testIndex.push_back(i);
         testRef.push_back(testA + testB * static_cast< float >(i));
     }


@@ -414,10 +414,10 @@ TEST( domainTests, domainTest_getDomains)
 
     testDomain.graph.resize(1);
     testDomain.graph.front().resize(testSliceNum);
 
     testDomain.graph.resize(1);
     testDomain.graph.front().resize(testSliceNum);

-    for (size_t i1 {0}; i1 < testSliceNum; i1++) {
+    for (size_t i1 {0}; i1 < testSliceNum; ++i1) {

         testDomain.setGraph(testDomain.graph.front()[i1]);
         testDomain.setGraph(testDomain.graph.front()[i1]);

-        for (size_t i2 {0}; i2 < testIndex.size(); i2++) {
-            for (size_t i3 {0}; i3 < testIndex.size(); i3++) {
+        for (size_t i2 {0}; i2 < testIndex.size(); ++i2) {
+            for (size_t i3 {0}; i3 < testIndex.size(); ++i3) {

                 testDomain.graph.front()[i1][i2][i3].num = 4;
             }
         }
                 testDomain.graph.front()[i1][i2][i3].num = 4;
             }
         }


@@ -425,13 +425,13 @@ TEST( domainTests, domainTest_getDomains)
     testDomain.getDomains();
     ASSERT_EQ(testDomain.domains.size(), 0);
 
     testDomain.getDomains();
     ASSERT_EQ(testDomain.domains.size(), 0);
 

-    for (int i0 {0}; i0 < 3; i0++) {
+    for (int i0 {0}; i0 < 3; ++i0) {

         testDomain.graph.resize(1);
         testDomain.graph.front().resize(testSliceNum);
         testDomain.graph.resize(1);
         testDomain.graph.front().resize(testSliceNum);

-        for (size_t i1 {0}; i1 < testSliceNum; i1++) {
+        for (size_t i1 {0}; i1 < testSliceNum; ++i1) {

             testDomain.setGraph(testDomain.graph.front()[i1]);
             testDomain.setGraph(testDomain.graph.front()[i1]);

-            for (size_t i2 {0}; i2 < testIndex.size(); i2++) {
-                for (size_t i3 {0}; i3 < testIndex.size(); i3++) {
+            for (size_t i2 {0}; i2 < testIndex.size(); ++i2) {
+                for (size_t i3 {0}; i3 < testIndex.size(); ++i3) {

                     testDomain.graph.front()[i1][i2][i3].num = 100;
                 }
             }
                     testDomain.graph.front()[i1][i2][i3].num = 100;
                 }
             }

diff --git a/src/domaintype.cpp b/src/domaintype.cpp
index 1841698c5ece6a8d218bf985ef2063476aa6004a..c929d59d520c292785c8b69bd8c5f492fbfd2169 100644 (file)
--- a/src/domaintype.cpp
+++ b/src/domaintype.cpp
@@ -3,42 +3,37 @@
 // деструктор класса
 domainType::~domainType() {}
 
 // деструктор класса
 domainType::~domainType() {}
 

-// конструктор класса для инициализации
-domainType::domainType() {}
-

 // конструктор класса для полноценной инициализации данных
 domainType::domainType(const std::vector< size_t > &index, const std::vector< RVec > &reference,
                     const int windowSize, const int domainMinimumSize,
                     const int domainSearchAlgorythm, const int timeStepBetweenWindowStarts,
                     const unsigned int sliceNum, const double epsilon, const double delta,
 // конструктор класса для полноценной инициализации данных
 domainType::domainType(const std::vector< size_t > &index, const std::vector< RVec > &reference,
                     const int windowSize, const int domainMinimumSize,
                     const int domainSearchAlgorythm, const int timeStepBetweenWindowStarts,
                     const unsigned int sliceNum, const double epsilon, const double delta,

-                    const std::string outPutFileName) {
+                    const std::string &outPutFileName) {

     setDefaults(index, reference, windowSize, domainMinimumSize, domainSearchAlgorythm, timeStepBetweenWindowStarts, sliceNum, epsilon, delta, outPutFileName);
 }
 
     setDefaults(index, reference, windowSize, domainMinimumSize, domainSearchAlgorythm, timeStepBetweenWindowStarts, sliceNum, epsilon, delta, outPutFileName);
 }
 

-// set numeric values to "-1" / string value to "" - if you want default settings
-// функция заполнения необходимыми данными для вычисления структурных доменов
+// функция заполнения необходимых данных для вычисления структурных доменов

 void domainType::setDefaults(const std::vector< size_t > &index, const std::vector< RVec > &reference,
                         const int windowSize, const int domainMinimumSize,
                         const int domainSearchAlgorythm, const int timeStepBetweenWindows,
                         const unsigned int sliceNum, const double epsilon, const double delta,
 void domainType::setDefaults(const std::vector< size_t > &index, const std::vector< RVec > &reference,
                         const int windowSize, const int domainMinimumSize,
                         const int domainSearchAlgorythm, const int timeStepBetweenWindows,
                         const unsigned int sliceNum, const double epsilon, const double delta,

-                        const std::string outPutFileName) {
+                        const std::string &outPutFileName) {

     graph.resize(0);
     structIndex = index;
     refTable.resize(reference.size());
     graph.resize(0);
     structIndex = index;
     refTable.resize(reference.size());

-    for (size_t i {0}; i < reference.size(); i++) {
+    for (size_t i {0}; i < reference.size(); ++i) {

         refTable[i].resize(0);
         refTable[i].resize(0);

-        for (size_t j {0}; j < reference.size(); j++) {
+        for (size_t j {0}; j < reference.size(); ++j) {

             refTable[i].push_back(reference[i] - reference[j]);
         }
     }
             refTable[i].push_back(reference[i] - reference[j]);
         }
     }

-    // слава шиве, слава индусам... зачем столько ифов?
-    if (epsilon != -1) { eps = epsilon; }
-    if (delta != -1) { dlt = delta; }
-    if (windowSize != -1) { window = windowSize; }
-    if (domainMinimumSize != -1) { dms = domainMinimumSize; }
-    if (domainSearchAlgorythm != -1) { dsa = domainSearchAlgorythm; }
-    if (timeStepBetweenWindows != -1) { ts = timeStepBetweenWindows; }
-    if (outPutFileName != "") { outPut = outPutFileName; }
+    epsilon > 0 ? eps = epsilon : eps = 0.2;
+    delta > 0 && delta <= 1 ? dlt = delta : dlt = 0.95;
+    windowSize > 0 ? window = windowSize : window = 1000;
+    domainMinimumSize > 3 ? dms = domainMinimumSize : dms = 4;
+    domainSearchAlgorythm > -1 && domainSearchAlgorythm < 3 ? dsa = domainSearchAlgorythm : dsa = 0;
+    timeStepBetweenWindows > 0 ? ts = timeStepBetweenWindows : ts = window / 10;
+    outPutFileName.size() > 0 ? outPut = outPutFileName : outPut = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());

     domsizes.resize(0);
     domsizes.resize(sliceNum);
     updateCount = 0;
     domsizes.resize(0);
     domsizes.resize(sliceNum);
     updateCount = 0;


@@ -46,7 +41,7 @@ void domainType::setDefaults(const std::vector< size_t > &index, const std::vect
 
 // фукнция обновления данных для выделения структурных доменов
 void domainType::update(const std::vector< std::vector< RVec > > &frame, const int frameNumber) {
 
 // фукнция обновления данных для выделения структурных доменов
 void domainType::update(const std::vector< std::vector< RVec > > &frame, const int frameNumber) {

-    // ��ромакс считает с нуля, проверял; инициализируем новое "окно"
+    // ��нициализируем новое "окно", громакс считает кадры с нуля

     if (frameNumber % ts == 0) {
         graph.resize(graph.size() + 1);
         graph.back().resize(structIndex.size() - static_cast< size_t >(dms) + 1);
     if (frameNumber % ts == 0) {
         graph.resize(graph.size() + 1);
         graph.back().resize(structIndex.size() - static_cast< size_t >(dms) + 1);


@@ -54,18 +49,18 @@ void domainType::update(const std::vector< std::vector< RVec > > &frame, const i
             setGraph(i);
         }
     }
             setGraph(i);
         }
     }

-    // заполняем структуру данных для структурных доменов
+    // заполняем матрицы данных для структурных доменов для всех текущих "окон"

     for (auto &i : graph) {
         #pragma omp parallel for
     for (auto &i : graph) {
         #pragma omp parallel for

-        for (size_t j = 0; j < i.size(); j++) {
-            for (size_t k1 {0}; k1 < i[j].size(); k1++) {
-                for (size_t k2 {k1}; k2 < i[j].size(); k2++) {
+        for (size_t j = 0; j < i.size(); ++j) {
+            for (size_t k1 {0}; k1 < i[j].size(); ++k1) {
+                for (size_t k2 {k1}; k2 < i[j].size(); ++k2) {

                     if ((frame[j][k1] - frame[j][k2] - refTable[k1][k2]).norm() <= static_cast< float >(eps)) {
                         if (k1 != k2) {
                     if ((frame[j][k1] - frame[j][k2] - refTable[k1][k2]).norm() <= static_cast< float >(eps)) {
                         if (k1 != k2) {

-                            i[j][k1][k2].num++;
-                            i[j][k2][k1].num++;
+                            ++i[j][k1][k2].num;
+                            ++i[j][k2][k1].num;

                         } else {
                         } else {

-                            i[j][k1][k2].num++;
+                            ++i[j][k1][k2].num;

                         }
                     }
                 }
                         }
                     }
                 }


@@ -73,9 +68,9 @@ void domainType::update(const std::vector< std::vector< RVec > > &frame, const i
         }
         #pragma omp barrier
     }
         }
         #pragma omp barrier
     }

-    // считаем число эффективных обновлений
+    // обновляем число эффективных обновлений

     if (graph.size() > 0) {
     if (graph.size() > 0) {

-        updateCount++;
+        ++updateCount;

     }
     // в случае, если число обновлений равно размеру окна, выделяем на нём домены
     if (updateCount == window) {
     }
     // в случае, если число обновлений равно размеру окна, выделяем на нём домены
     if (updateCount == window) {


@@ -88,10 +83,10 @@ void domainType::update(const std::vector< std::vector< RVec > > &frame, const i
 void domainType::setGraph(std::vector< std::vector< node > > &smallGraph) {
     smallGraph.resize(0);
     smallGraph.resize(refTable.size());
 void domainType::setGraph(std::vector< std::vector< node > > &smallGraph) {
     smallGraph.resize(0);
     smallGraph.resize(refTable.size());

-    for (size_t i {0}; i < refTable.size(); i++) {
+    for (size_t i {0}; i < refTable.size(); ++i) {

         smallGraph[i].resize(0);
         smallGraph[i].resize(refTable.size());
         smallGraph[i].resize(0);
         smallGraph[i].resize(refTable.size());

-        for (size_t j {0}; j < refTable.size(); j++) {
+        for (size_t j {0}; j < refTable.size(); ++j) {

             smallGraph[i][j].num = 0;
             smallGraph[i][j].check = false;
         }
             smallGraph[i][j].num = 0;
             smallGraph[i][j].check = false;
         }


@@ -102,7 +97,7 @@ void domainType::setGraph(std::vector< std::vector< node > > &smallGraph) {
 void domainType::deleteDomainFromGraph(const std::vector< size_t > &domain) {
     for (auto &i : graph.front()) {
         for (const auto &j : domain) {
 void domainType::deleteDomainFromGraph(const std::vector< size_t > &domain) {
     for (auto &i : graph.front()) {
         for (const auto &j : domain) {

-            for (size_t k {0}; k < i.size(); k++) {
+            for (size_t k {0}; k < i.size(); ++k) {

                 i[j][k].check = false;
                 i[k][j].check = false;
             }
                 i[j][k].check = false;
                 i[k][j].check = false;
             }


@@ -113,13 +108,13 @@ void domainType::deleteDomainFromGraph(const std::vector< size_t > &domain) {
 // подсчёт размеров всех потенциально возможных доменов и проверка на наличие домена для выделения
  bool domainType::searchDomainSizes() {
     bool flag {false};
 // подсчёт размеров всех потенциально возможных доменов и проверка на наличие домена для выделения
  bool domainType::searchDomainSizes() {
     bool flag {false};

-    for (size_t i {0}; i < graph.front().size(); i++) {
+    for (size_t i {0}; i < graph.front().size(); ++i) {

         domsizes[i].resize(0); // необходимо переопределять память
         domsizes[i].resize(graph.front()[i].size(), 0);
         domsizes[i].resize(0); // необходимо переопределять память
         domsizes[i].resize(graph.front()[i].size(), 0);

-        for (size_t j {0}; j < graph.front()[i].size(); j++) {
+        for (size_t j {0}; j < graph.front()[i].size(); ++j) {

             for (const auto &k : graph.front()[i][j]) {
                 if (k.check) {
             for (const auto &k : graph.front()[i][j]) {
                 if (k.check) {

-                    domsizes[i][j]++;
+                    ++domsizes[i][j];

                 }   
             }
             if ((!flag) && (domsizes[i][j] >= dms)) {
                 }   
             }
             if ((!flag) && (domsizes[i][j] >= dms)) {


@@ -143,20 +138,17 @@ void domainType::getDomains() {
         }
     }
     domains.resize(0);
         }
     }
     domains.resize(0);

-    // итеративное выделение доменов одним из двух(пока что) способов
-    // в случае если цикл запустился, то гарантированно имеется домен для выделения
+    // итеративное выделение доменов одним из трёх способов

     while (searchDomainSizes()) {
         size_t t1 {0}, t2 {0};
     while (searchDomainSizes()) {
         size_t t1 {0}, t2 {0};

-        for (size_t i {0}; i < domsizes.size(); i++) {
-            for (size_t j {0}; j < domsizes[i].size(); j++) {
+        for (size_t i {0}; i < domsizes.size(); ++i) {
+            for (size_t j {0}; j < domsizes[i].size(); ++j) {
+                // вынуждены выделять первый домен из равных по кол-ву элементов

                 if ((dsa == 0) && (domsizes[i][j] > domsizes[t1][t2])) {
                 if ((dsa == 0) && (domsizes[i][j] > domsizes[t1][t2])) {

-                    // из-за физических ограничений по памяти в общем случае нельзя хранить всю подноготную данных на
-                    // основе которых было полученно "вхождение" атомов в домен, потому мы только знаем, что размер
-                    // совпадает, а сказать который из двух стабильнее нельзя, либо нужно придумать что-то новое

                     t1 = i;
                     t2 = j;
                 }
                     t1 = i;
                     t2 = j;
                 }

-                if ((dsa == 2) && ((domsizes[i][j] < domsizes[t1][t2]) || ((domsizes[i][j] >= dms) && (domsizes[t1][t2] < dms)))) {
+                if ((dsa == 2) && (domsizes[i][j] >= dms) && ((domsizes[i][j] < domsizes[t1][t2]) || (domsizes[t1][t2] < dms))) {

                     t1 = i;
                     t2 = j;
                 }
                     t1 = i;
                     t2 = j;
                 }


@@ -164,7 +156,7 @@ void domainType::getDomains() {
         }
         // выделяем найдённый домен
         domains.resize(domains.size() + 1);
         }
         // выделяем найдённый домен
         domains.resize(domains.size() + 1);

-        for (size_t i {0}; i < graph.front()[t1][t2].size(); i++) {
+        for (size_t i {0}; i < graph.front()[t1][t2].size(); ++i) {

             if (graph.front()[t1][t2][i].check) {
                 domains.back().push_back(i);
             }
             if (graph.front()[t1][t2][i].check) {
                 domains.back().push_back(i);
             }


@@ -173,12 +165,12 @@ void domainType::getDomains() {
         if (dsa == 1) {
             break;
         }
         if (dsa == 1) {
             break;
         }

-        // удаляем ��го из матриц
+        // удаляем ��ыделенный домен из матриц

         deleteDomainFromGraph(domains.back());
     }
         deleteDomainFromGraph(domains.back());
     }

-    // удаляем рассматриваемое окно из вектора
+    // удаляем рассматриваемое окно

     graph.erase(graph.begin());
     graph.erase(graph.begin());

-    // смещаем счётчик обновлений для следующего окна, std::max для случая если окна не пересекаются
+    // смещаем счётчик обновлений для следующего окна

     updateCount = std::max(0, window - ts);
 }
 
     updateCount = std::max(0, window - ts);
 }
 


@@ -189,15 +181,15 @@ void domainType::print(int currentFrame) {
     }
     FILE *ndxFile {std::fopen(outPut.c_str(), "a+")}, *slFile {std::fopen(("selectionList-" + outPut.substr(0, outPut.size() - 4)).c_str(), "a+")};
     short int writeCount {0};
     }
     FILE *ndxFile {std::fopen(outPut.c_str(), "a+")}, *slFile {std::fopen(("selectionList-" + outPut.substr(0, outPut.size() - 4)).c_str(), "a+")};
     short int writeCount {0};

-    for (size_t i {0}; i < domains.size(); i++) {
+    for (size_t i {0}; i < domains.size(); ++i) {

         // domain - стартовая позиция в фреймах - номер домена - минимальный размер домена -
         // константа тепловых колебаний (отклонения) - константа входимости (отклонения)
         std::fprintf(ndxFile, "[domain-stPos-%06d-num-%03lu-dms-%03d-epsi-%04.3f-delta-%04.3f]\n", currentFrame - window + 1, i + 1, dms, eps, dlt);
         std::fprintf(slFile, "group %cdomain-stPos-%06d-num-%03lu-dms-%03d-epsi-%04.3f-delta-%04.3f%c;\n", '"', currentFrame - window + 1, i + 1, dms, eps, dlt, '"');
         writeCount = 0;
         std::printf("\n");
         // domain - стартовая позиция в фреймах - номер домена - минимальный размер домена -
         // константа тепловых колебаний (отклонения) - константа входимости (отклонения)
         std::fprintf(ndxFile, "[domain-stPos-%06d-num-%03lu-dms-%03d-epsi-%04.3f-delta-%04.3f]\n", currentFrame - window + 1, i + 1, dms, eps, dlt);
         std::fprintf(slFile, "group %cdomain-stPos-%06d-num-%03lu-dms-%03d-epsi-%04.3f-delta-%04.3f%c;\n", '"', currentFrame - window + 1, i + 1, dms, eps, dlt, '"');
         writeCount = 0;
         std::printf("\n");

-        for (size_t j {0}; j < domains[i].size(); j++) {
-            writeCount++;
+        for (size_t j {0}; j < domains[i].size(); ++j) {
+            ++writeCount;

             if (writeCount > 20) {
                 writeCount -= 20;
                 std::fprintf(ndxFile, "\n");
             if (writeCount > 20) {
                 writeCount -= 20;
                 std::fprintf(ndxFile, "\n");

diff --git a/src/domaintype.h b/src/domaintype.h
index 7eaab0ea0ae802579cee99ebda03f98126052868..4309dbabd5d8b6e45f7b55f83e93a70dc0a1fc12 100644 (file)
--- a/src/domaintype.h
+++ b/src/domaintype.h
@@ -12,6 +12,7 @@
 #include <omp.h>
 #include <vector>
 #include <cstdio>
 #include <omp.h>
 #include <vector>
 #include <cstdio>

+#include <chrono>

 
 using namespace gmx;
 
 
 using namespace gmx;
 


@@ -22,14 +23,14 @@ class domainType {
         ~domainType();
 
         // конструктор класса для инициализации
         ~domainType();
 
         // конструктор класса для инициализации

-        domainType();
+        domainType() = default;

 
         // конструктор класса для полноценной инициализации данных
         domainType(const std::vector< size_t > &index, const std::vector< RVec > &reference,
                     const int windowSize, const int domainMinimumSize,
                     const int domainSearchAlgorythm, const int timeStepBetweenWindowStarts,
                     const unsigned int sliceNum, const double epsilon, const double delta,
 
         // конструктор класса для полноценной инициализации данных
         domainType(const std::vector< size_t > &index, const std::vector< RVec > &reference,
                     const int windowSize, const int domainMinimumSize,
                     const int domainSearchAlgorythm, const int timeStepBetweenWindowStarts,
                     const unsigned int sliceNum, const double epsilon, const double delta,

-                    const std::string outPutFileName);
+                    const std::string &outPutFileName);

 
         // set numeric values to "-1" / string value to "" - if you want default settings
         // функция заполнения необходимыми данными для вычисления структурных доменов
 
         // set numeric values to "-1" / string value to "" - if you want default settings
         // функция заполнения необходимыми данными для вычисления структурных доменов


@@ -37,7 +38,7 @@ class domainType {
                         const int windowSize, const int domainMinimumSize,
                         const int domainSearchAlgorythm, const int timeStepBetweenWindows,
                         const unsigned int sliceNum, const double epsilon, const double delta,
                         const int windowSize, const int domainMinimumSize,
                         const int domainSearchAlgorythm, const int timeStepBetweenWindows,
                         const unsigned int sliceNum, const double epsilon, const double delta,

-                        const std::string outPutFileName);
+                        const std::string &outPutFileName);

 
         // фукнция обновления данных для выделения структурных доменов
         void update(const std::vector< std::vector< RVec > > &frame, const int frameNumber);
 
         // фукнция обновления данных для выделения структурных доменов
         void update(const std::vector< std::vector< RVec > > &frame, const int frameNumber);