asddasdasd

diff --git a/src/dssptools.cpp b/src/dssptools.cpp
index 04e60aba538ef0448d666971d1677963f27ca01b..bd622e955226474173eb97b88e9aee347309fe1d 100644 (file)
--- a/src/dssptools.cpp
+++ b/src/dssptools.cpp
@@ -68,14 +68,18 @@ namespace gmx
 namespace analysismodules
 {
 
-void ResInfo::setIndex(backboneAtomTypes atomTypeName, std::size_t atomIndex)
-{
-   _ResInfo.at(static_cast<std::size_t>(atomTypeName)) = atomIndex;
-}
+//void ResInfo::setIndex(backboneAtomTypes atomTypeName, std::size_t atomIndex)
+//{
+//   _ResInfo.at(static_cast<std::size_t>(atomTypeName)) = atomIndex;
+//}
 
-std::size_t ResInfo::getIndex(backboneAtomTypes atomTypeName) const
-{
-   return _ResInfo[static_cast<std::size_t>(atomTypeName)];
+//std::size_t ResInfo::getIndex(backboneAtomTypes atomTypeName) const
+//{
+//   return _ResInfo[static_cast<std::size_t>(atomTypeName)];
+//}
+
+std::size_t ResInfo::getIndex(backboneAtomTypes atomTypeName) const{
+    return _backboneIndices[static_cast<std::size_t>(atomTypeName)];
 }
 
 secondaryStructures::secondaryStructures(){
@@ -114,8 +118,8 @@ secondaryStructureTypes secondaryStructures::secondaryStructuresData::getStatus(
 }
 
 bool secondaryStructures::hasHBondBetween(std::size_t DonorID, std::size_t AcceptorID) const{
-    return ( (*ResInfoMap)[DonorID].acceptor[0] == &(*ResInfoMap)[AcceptorID] && (*ResInfoMap)[DonorID].acceptorEnergy[0] < HBondEnergyCutOff ||
-             (*ResInfoMap)[DonorID].acceptor[1] == &(*ResInfoMap)[AcceptorID] && (*ResInfoMap)[DonorID].acceptorEnergy[1] < HBondEnergyCutOff );
+    return ( (*ResInfoMap)[DonorID].acceptor[0] == (*ResInfoMap)[AcceptorID].info && (*ResInfoMap)[DonorID].acceptorEnergy[0] < HBondEnergyCutOff ||
+             (*ResInfoMap)[DonorID].acceptor[1] == (*ResInfoMap)[AcceptorID].info && (*ResInfoMap)[DonorID].acceptorEnergy[1] < HBondEnergyCutOff );
 }
 
 bool secondaryStructures::NoChainBreaksBetween(std::size_t Resi1, std::size_t Resi2) const{
@@ -551,7 +555,7 @@ void DsspTool::calculateHBondEnergy(ResInfo& Donor,
     float HbondEnergy{ 0 };
     float distanceON{ 0 }, distanceCH{ 0 }, distanceOH{ 0 }, distanceCN{ 0 };
 
-   std::string proLINE {Donor.resiName};
+   std::string proLINE {*(Donor.info->name)};
 
    if( !proLINE.compare("PRO")){ // TODO test this shit
 
@@ -601,26 +605,26 @@ void DsspTool::calculateHBondEnergy(ResInfo& Donor,
        }
    }
    else {
-       std::cerr << "PRO DETECTED! THIS IS RESI # " <<  << std::endl;
+       std::cerr << "PRO DETECTED! THIS IS RESI № " << Donor.info->nr << std::endl;
    }
 
    if (HbondEnergy < Donor.acceptorEnergy[0]){
        Donor.acceptor[1] = Donor.acceptor[0];
-       Donor.acceptor[0] = &Acceptor;
+       Donor.acceptor[0] = Acceptor.info;
        Donor.acceptorEnergy[0] = HbondEnergy;
    }
    else if (HbondEnergy < Donor.acceptorEnergy[1]){
-       Donor.acceptor[1] = &Acceptor;
+       Donor.acceptor[1] = Acceptor.info;
        Donor.acceptorEnergy[1] = HbondEnergy;
    }
 
    if (HbondEnergy < Acceptor.donorEnergy[0]){
        Acceptor.donor[1] = Acceptor.donor[0];
-       Acceptor.donor[0] = &Donor;
+       Acceptor.donor[0] = Donor.info;
        Acceptor.donorEnergy[0] = HbondEnergy;
    }
    else if (HbondEnergy < Acceptor.donorEnergy[1]){
-       Acceptor.donor[1] = &Donor;
+       Acceptor.donor[1] = Donor.info;
        Acceptor.donorEnergy[1] = HbondEnergy;
    }
 }
@@ -645,7 +649,7 @@ void DsspTool::initAnalysis(/*const TrajectoryAnalysisSettings &settings,*/const
    IndexMap.resize(0);
    IndexMap.push_back(_backboneAtoms);
    std::cout << "Trouble :(" << std::endl;
-   IndexMap[i].resiName = *(top.atoms()->resinfo[i].name) ;
+   *(IndexMap[i].info) = top.atoms()->resinfo[resicompare];
 
    for (gmx::ArrayRef<const int>::iterator ai{ initParams.sel_.atomIndices().begin() }; (ai != initParams.sel_.atomIndices().end()); ++ai){
        if (resicompare != top.atoms()->atom[static_cast<std::size_t>(*ai)].resind)
@@ -653,7 +657,7 @@ void DsspTool::initAnalysis(/*const TrajectoryAnalysisSettings &settings,*/const
            ++i;
            resicompare = top.atoms()->atom[static_cast<std::size_t>(*ai)].resind;
            IndexMap.push_back(_backboneAtoms);
-           IndexMap[i].resiName = *(top.atoms()->resinfo[i].name);
+           *(IndexMap[i].info) = top.atoms()->resinfo[resicompare];
 //           std::cout << "First resi is " << IndexMap[i].resinfo->name << std::endl;
 
 //           if( verbose_ && i != 1 && (!IndexMap[i-1].getIndex(backboneAtomTypes::AtomCA) ||
@@ -689,23 +693,23 @@ void DsspTool::initAnalysis(/*const TrajectoryAnalysisSettings &settings,*/const
        std::string atomname(*(top.atoms()->atomname[static_cast<std::size_t>(*ai)]));
        if (atomname == backboneAtomTypeNames[backboneAtomTypes::AtomCA])
        {
-           IndexMap[i].setIndex(backboneAtomTypes::AtomCA, static_cast<std::size_t>(*ai));
+           IndexMap[i]._backboneIndices[static_cast<std::size_t>(backboneAtomTypes::AtomCA)] = *ai;
        }
        else if (atomname == backboneAtomTypeNames[backboneAtomTypes::AtomC])
        {
-           IndexMap[i].setIndex(backboneAtomTypes::AtomC, static_cast<std::size_t>(*ai));
+           IndexMap[i]._backboneIndices[static_cast<std::size_t>(backboneAtomTypes::AtomC)] = *ai;
        }
        else if (atomname == backboneAtomTypeNames[backboneAtomTypes::AtomO])
        {
-           IndexMap[i].setIndex(backboneAtomTypes::AtomO, static_cast<std::size_t>(*ai));
+           IndexMap[i]._backboneIndices[static_cast<std::size_t>(backboneAtomTypes::AtomO)] = *ai;
        }
        else if (atomname == backboneAtomTypeNames[backboneAtomTypes::AtomN])
        {
-           IndexMap[i].setIndex(backboneAtomTypes::AtomN, static_cast<std::size_t>(*ai));
+           IndexMap[i]._backboneIndices[static_cast<std::size_t>(backboneAtomTypes::AtomN)] = *ai;
        }
        else if (atomname == backboneAtomTypeNames[backboneAtomTypes::AtomH])
        {
-           IndexMap[i].setIndex(backboneAtomTypes::AtomH, static_cast<std::size_t>(*ai));
+           IndexMap[i]._backboneIndices[static_cast<std::size_t>(backboneAtomTypes::AtomH)] = *ai;
        }
 
 //       if( atomname == backboneAtomTypeNames[backboneAtomTypes::AtomCA] || atomname == backboneAtomTypeNames[backboneAtomTypes::AtomC] || atomname == backboneAtomTypeNames[backboneAtomTypes::AtomO]
@@ -714,10 +718,6 @@ void DsspTool::initAnalysis(/*const TrajectoryAnalysisSettings &settings,*/const
 //       }
    }
 
-   for(std::vector<ResInfo>::iterator infi {IndexMap.begin()}; infi != IndexMap.end() ; ++infi ){
-       std::cout << infi->resiName << std::endl;
-   }
-
    std::cout << "initAnalyzyz ended" << std::endl;
 }
 

diff --git a/src/dssptools.h b/src/dssptools.h
index 471de95cf13c41249ed031638c6fd2e60fd5fcf6..57da4af8ea77302aade1fb1e683bbb8e93c04de2 100644 (file)
--- a/src/dssptools.h
+++ b/src/dssptools.h
@@ -106,20 +106,27 @@ const gmx::EnumerationArray<backboneAtomTypes, const char*> backboneAtomTypeName
    { "CA", "C", "O", "N", "H" }
 };
 
+struct ResInfo {
+    std::array<std::size_t, static_cast<std::size_t>(backboneAtomTypes::Count)>     _backboneIndices{ 0, 0, 0, 0, 0 }; // todo something with zeroes
+    std::size_t                                                                     getIndex(backboneAtomTypes atomTypeName) const;
+    t_resinfo                                                                       *info{nullptr}, *donor[2]{nullptr, nullptr}, *acceptor[2]{nullptr, nullptr};
+    float                                                                           donorEnergy[2]{}, acceptorEnergy[2]{};
+};
 
-class ResInfo
-{
-public:
-   void   setIndex(backboneAtomTypes atomTypeName, std::size_t atomIndex);
-   std::size_t getIndex(backboneAtomTypes atomTypeName) const;
 
-   ResInfo                                                                    *donor[2]{nullptr, nullptr}, *acceptor[2]{nullptr, nullptr};
-   float                                                                        donorEnergy[2]{}, acceptorEnergy[2]{};
-   std::string                                                                  resiName;
+//class ResInfo
+//{
+//public:
+//   void   setIndex(backboneAtomTypes atomTypeName, std::size_t atomIndex);
+//   std::size_t getIndex(backboneAtomTypes atomTypeName) const;
 
-private:
-   std::array<std::size_t, static_cast<std::size_t>(backboneAtomTypes::Count)>  _ResInfo{ 0, 0, 0, 0, 0 };
-};
+//   ResInfo                                                                    *donor[2]{nullptr, nullptr}, *acceptor[2]{nullptr, nullptr};
+//   float                                                                        donorEnergy[2]{}, acceptorEnergy[2]{};
+//   std::string                                                                  resiName;
+
+//private:
+//   std::array<std::size_t, static_cast<std::size_t>(backboneAtomTypes::Count)>  _ResInfo{ 0, 0, 0, 0, 0 };
+//};
 
 enum class secondaryStructureTypes : std::size_t {
     Loop = 0,
@@ -203,7 +210,6 @@ private:
 class alternateNeighborhoodSearch{
 public:
     alternateNeighborhoodSearch(){}
-    ~alternateNeighborhoodSearch(){} // TO DO
     void setCutoff(const real &cutoff_init);
     void AltPairSearch(const t_trxframe &fr, const std::vector<ResInfo>      &IndexMap);
     bool findNextPair();