Sparta class:
 
[FIX: needs much work]
 
  enum ShiftTerms { TERM_RING  =1,
                    TERM_EFIELD=2,
                    TERM_ORDER =4,
                    TERM_HBOND =8,
                    TERM_PHIM  =16,
                    TERM_PHI   =32,
                    TERM_PHIP  =64,
                    TERM_PSIM  =128,
                    TERM_PSI   =256,
                    TERM_PSIP  =512,
                    TERM_CHI1M =1024,
                    TERM_CHI1  =2048,
                    TERM_CHI1P =4096,
                    TERM_CHI2M =8192,
                    TERM_CHI2  =16384,
                    TERM_CHI2P =32768 };
 
  int indexBlosumM  ; //indices into ANN input vector
  int indexPhiM     ;
  int indexPsiM     ;
  int indexChi1M    ;
  int indexChi2M    ;
  int indexBlosum   ;
  int indexPhi      ;
  int indexPsi      ;
  int indexChi1     ;
  int indexChi2     ;
  int indexBlosumP  ;
  int indexPhiP     ;
  int indexPsiP     ;
  int indexChi1P    ;
  int indexChi2P    ;
  int indexHbondOM  ;
  int indexHbondHN  ;
  int indexHbondHA  ;
  int indexHbondO   ;
  int indexHbondHNP ;
  int indexOrder    ;
  
  enum ANNSet { ANNSET_20110211, ANNSET_20110225, ANNSET_20110324 };
 
  MODACCESSOR(termsUsed,TermsUsed,int);
  ANNSet annSet;
  void setAnnSet( ANNSet );
 
  GDB RC_Tab; // random coil chemical shift table
 
  // for each OMP thread
  // for each atom index
  // a list of DerivData contributions
  CDSList<DerivData> derivAccumList;
 
  SPARTA(const AtomSel& sel);
 
  bool addAtomType(const Atom&); // returns false if atomtype isn't supported
 
  void printSyntax();
 
  void init();
 
  SPARTA_PDB inPDB;
  const AtomSel& selection() const { return sel; }
 
  AtomSel chemShiftAtomSel;
 
  ACCESSOR(annInputDim,AnnInputDim,int); // dimension of ANN input vector
  ACCESSOR(annHiddenDim,AnnHiddenDim,int); // dimension of ANN hidden layer
  
  ACCESSOR(matchCount,MatchCount,int); //Max Match Count per query triplet
  ACCESSOR(excluded,Excluded,String); //Max Match Count per query triplet
  //  ACCESSOR(inName,InName,String); // input PDB coordinates file name
  ACCESSOR(tripFileName,TripFileName,String); // triplet filename
  ACCESSOR(weightFileName,WeightFileName,String); //weight table of score funct
  ACCESSOR(homoFileName,HomoFileName,String); // sequence homology table
  ACCESSOR(fitFileName,FitFileName,String); // table of "fitting parameters"
  ACCESSOR(refCSFileName,RefCSFileName,String);
  ACCESSOR(rcFileName,RCFileName,String); // random coil chemical shift table
  ACCESSOR(adjFileName,AdjFileName,String); // adjustment of RC CS table
  ACCESSOR(prevFileName,PrevFileName,String); // RC Adj for Prev Residue Type
  ACCESSOR(nextFileName,NextFileName,String); // RC Adj for Next Residue Type
  ACCESSOR(B62FileName,B62FileName,String);       // BLOSUM62 table 
  ACCESSOR(annLevel1Pattern,ANNLevel1Pattern,String); //pattern for ANN db files
  ACCESSOR(surfPattern,SurfPattern,String); 
 
  ACCESSOR(dynamicSSBonds,DynamicSSBonds,bool);
  ACCESSOR(verbose,Verbose,bool);
 
  //Get the list of useful shifts from a given residue. 
  //   get 2nd chemical shift and apply correction
  void getResInfo(CDSList<DerivData>*); 
        
  // Initiate an ANN prediction for a single protein
  void runANN_Prediction(); 
  // 
  run_A_ANN_Prediction(calcDerivs=False) - Run ANN prediction, and optionally
                                           compute gradient with respect to
                                           atomic coordinates.
        
  // get the prediction error from error surface
  float_type getANN_PredError(const float_type& phi, 
                              const float_type& psi, 
                              const char        aa,
                              const String&     aName);
        void init_PredErrorSurface();
        
        void Compile();
        void Compile(const String &name);
 
        // get random coil chemical shift for atom 'aName' of residue 'resName'
  float_type getRC(const char resName, const String& aName);
  float_type getRCadj(const char resName, const String& aName);
  float_type getPrevRCadj(const String& prev_rName, const String& aName);
  float_type getNextRCadj(const String& next_rName, const String& aName);
 
  float_type getPred2ndShift(const Atom&               atom,
                             const int                 resIndex,
                                   CDSList<DerivData>* derivData=0);            
 
  String summarizeInput();
  String summary();
  String comparisonOutput();
  String refCSOutput();
 
        
        char * ftoa( float_type n, char *buff, char f='g', int prec=6 );
        char * itoa( int n, char *buff, int base=10 );
 
  CDSVector<float_type> predictedShifts;
  CDSVector<float_type> randomCoilShifts;
  CDSVector<float_type> predictedSigma;
 
  float_type getShift(const Atom&);
 
  getDerivs(atom) - return the gradient information for the chemical shift
                    of the specified atom. The returned object is a list of
                    DerivDataElement, which has members
                       index - index into simulation, specifying an atom
                       val   - a vec3.Vec3 specifying gradient value.
 
 
  float_type getRCShift(const Atom&);
  float_type getSigma(const Atom&);
 
  void calcDerivsOn();
  // update all values in an instance. This is only required if
  // coordinates or some other parameter has changed.
  virtual void updateValues();  
};
 
namespace EnumNamespace {
  extern EnumNameMap ANNSet[];
};
 
 
 
GDB class:
 
  Read/Write access to text database files used by Talos+ and Sparta+.
 
  These files consist of XPLOR-like REMARK comments, a DATA section which
  contains key-value string pairs, and more general entries with field names 
  and type specified.
 
methods:
 
   data() - return the DATA entries as a map
 
   getVars() - return field names
 
   getEntry(name,
            value,
            index=1) - return the entry in the database for which the field 
                       specified by name matches value. There may be multiple 
                       such matches. The index argument specified which is
                       returned, by one-offset order in the database file.
 
   getValues(name) - given a field name, return all possible values for the
                     field. The order of the returned keys may differ from
                     that in the database.
 
   getEntries(name) - return all entries which match the specified field name.
 
   entry(index)     - return entry by offset 1 index
 
   numEntries()     - return the number of entries.
 
//FIX: complete this: CDS 2013/09/09
 
public:
 
        String GDBfileName;
 
        String FORMAT_str, VARS_str;
 
        GDB_Entry EMPTY;
 
 
        GDB();
        GDB(const String& fileName);
 
  
 
  StringList remarks() const { return REMARKS; }
 
        void loadGDB(const String &fileName);
        void saveGDB(const String &fileName);
        void saveGDB(ostream&);
 
        //add one VAR with given FORMAT
        void addVAR(const String &VAR_Name, const String &FORMAT_Name);
        //re-set one VAR with given FORMAT
        void setVAR(int index, const String &VAR_Name, const String &FORMAT_Name);
 
  //return field names
  CDSList<String> getVars() const { return VARS; }
 
        //set the DATA with 'DataVal'
        void setData(const String &DataName, const String &DataVal);
        //get the DATA value with 'DataName'
        String getData(const String &DataName);
 
  //return DATA field as a map
  CDSMap<String,String> data() const;
 
 
        const GDB_Entry& getEntry(int number);
        const GDB_Entry& getEntry(const String &VName, 
                                  const String &VVal, 
                                        int index=1);
  const GDB_Entry& getEntry(const String &VName1, 
                            const String &VVal1, 
                            const String &VName2, 
                            const String &VVal2, 
                                  int index);
 
  //given a field name, return a unique list of all possible values of that
  // field. The order of the keys in this list is random, and will not 
  // correspond to that in the database table.
  CDSList<String> getValues(const String &VName) const;
  
  // return all entries for which field VName is VVal
  CDSList<GDB_Entry> getEntries(const String &VName, 
                                const String &VVal);
  
        //re-set the 'index'-th data entry with new 'VarVal' for given 
        // 'VarName'
        void setEntry(int index, const String &VarName, const String &VarVal);
        //add one data entry to the end of current Entries
        void addEntry(const String &VarName, const String &VarVal);
 
 
        void addRemark(const String &str); // add one REMARK
 
        void presetClass(const String &ClassName); // pre-set the VARS and FORMAT
 
        bool checkFormat(const String& f); // check if f is a valid FORMAT
 
        bool isVarFloat(int index);
        bool isVarInt(int index);
        bool isVarString(int index);
 
        bool isVarFloat(const String &VarName);
        bool isVarInt(const String &VarName);
        bool isVarString(const String &VarName);
 
        void VARS_str_parser(const String &str);
        void FORMAT_str_parser(const String &str);
 
        void set_plaintext();
 
 
//      //Strings functions
//      static int contains( const String &str, const String &c );
//      static int contains( const String &str, const char &c );
        //
        
        static bool isDigit( const char &c );
        static bool isSpace( const char &c );
        
//      static StringList split( const char &sep, const String &str );
//      static StringList split( const String &sep, const String &str );
//      //splits the String str into Strings wherever a separator 'sep' occurs, and returns the list of those Strings.
//      static StringList split_WhiteSpace(const String &str);
        
        //returns a section of the String, each section is defined by char 'sep', numbers of start and end are the index number (begin with 0)
        static char* section( const String &str, const char &seq, char *buff, int start, int end= 0xffffffff );
 
        //Returns a String that has whitespace removed from the start and the end, 
        //and which has each sequence of internal whitespace replaced with a single space.
        static String simplifyWhiteSpace( const String &str );
};
 
 
 
 
 
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.