fragmentDataBase.cpp

Go to the documentation of this file.
00001 //
00002 // Utilitaires  pour manipuler les fichiers pdb
00003 //
00004 #include "fragmentDataBase.h"
00005 //
00006 //
00007 #include <iostream>
00008 #include <stdlib.h>
00009 //
00010 //
00011 FragmentDataBaseElement::FragmentDataBaseElement()  : _numberOfAtoms(0),_fragmentName(""),_nameOfAtoms(NULL)
00012 {}
00013 FragmentDataBaseElement::FragmentDataBaseElement(const int size)  : _numberOfAtoms(size),_fragmentName(""),
00014                                                                       _nameOfAtoms(new std::string[size])
00015 {}
00016 FragmentDataBaseElement::~FragmentDataBaseElement() 
00017 {
00018   _numberOfAtoms = 0 ;
00019   if(_nameOfAtoms != NULL)
00020     { delete [] _nameOfAtoms ;_nameOfAtoms = NULL ;}
00021 }
00022 void FragmentDataBaseElement::setNumberOfAtoms(const int size){
00023   _numberOfAtoms = size ;
00024   if(_nameOfAtoms != NULL)
00025     { delete [] _nameOfAtoms ;}
00026   _nameOfAtoms   = new std::string[size] ;
00027 }
00028 
00029 void FragmentDataBaseElement::read(std::ifstream & data){
00030   //
00031   data >> _fragmentName >> _numberOfAtoms ;
00032   //
00033   this->setNumberOfAtoms( _numberOfAtoms);
00034   //
00035   for ( int j = 0 ; j < _numberOfAtoms  ; ++j){
00036     data >> _nameOfAtoms[j] ;
00037   }
00038 }
00039 
00040 void FragmentDataBaseElement::write(){
00041   //
00042    std::cout << " " << _fragmentName << "  "<<  _numberOfAtoms << std::endl
00043         << "        " ;
00044   //
00045   for ( int j = 0 ; j < _numberOfAtoms  ; ++j){
00046     std::cout <<  _nameOfAtoms[j] << " ";
00047   }
00048   std::cout<< std::endl;
00049 }
00050 
00051 bool FragmentDataBaseElement::findAtomName(const std::string &atomName )
00052 {
00053   for(int i = 0 ; i < _numberOfAtoms; ++i ){
00054     if( _nameOfAtoms[i] == atomName){
00055       return true ;
00056     }
00057   }
00058   return false;
00059 }
00060 
00061 //
00062 // ====================== END of  FragmentDataBaseElement
00063 //
00064 
00065 ResiduDataBaseElement::ResiduDataBaseElement()  : _numberOfFragments(0),_residuName(""),_nameOfFragments(NULL)
00066 {}
00067 ResiduDataBaseElement::ResiduDataBaseElement(const int size)  : _numberOfFragments(size),_residuName(""),
00068                                                                 _nameOfFragments(new FragmentDataBaseElement[size])
00069 {}
00070 ResiduDataBaseElement::~ResiduDataBaseElement() 
00071 {
00072   _numberOfFragments = 0 ;
00073   if(_nameOfFragments != NULL)
00074     { delete [] _nameOfFragments ;_nameOfFragments = NULL ;}
00075 }
00076 void ResiduDataBaseElement::setNumberOfFragments(const int size){
00077   _numberOfFragments = size ;
00078   if(_nameOfFragments != NULL)
00079     { delete [] _nameOfFragments ;}
00080   _nameOfFragments = new FragmentDataBaseElement[size] ;
00081 }
00082 
00083 void ResiduDataBaseElement::read(std::ifstream & data){
00084   //
00085   std::string comment ;
00086   //
00087   data >> _residuName >> _numberOfFragments ;
00088   //
00089   this->setNumberOfFragments( _numberOfFragments);
00090   //
00091   for ( int j = 0 ; j < _numberOfFragments  ; ++j){
00092     _nameOfFragments[j].read(data) ;
00093   }
00094   //  std::getline(data, comment );
00095 }
00096 
00097 void ResiduDataBaseElement::write() {
00098   //  std::cout <<  _residuName  << "   " << _numberOfFragments << std::endl ; 
00099   for ( int j = 0 ; j < _numberOfFragments  ; ++j){
00100     _nameOfFragments[j].write() ;
00101   }
00102 }
00103 
00104 std::string ResiduDataBaseElement::getFragmentName(const std::string &atomName ){
00105   //  
00106   //
00107   for ( int j = 0 ; j < _numberOfFragments  ; ++j){
00108     if( _nameOfFragments[j].findAtomName(atomName)){
00109       return _nameOfFragments[j].getFragmentName() ;;
00110     }
00111   }
00112   std::cerr << "Error no atom "<<atomName<<" in residu "<<_residuName << std::endl;
00113   exit(1) ;
00114   return _residuName ;
00115 }
00116   //
00117 // ====================== END of ResiduDataBaseElement
00118 //
00119 FragmentsDataBase::FragmentsDataBase() : _numberOfResidus(0),_nameOfResidus(NULL),_setOfResidus(NULL),
00120                                          _nameOfDataBase("BASE_FRAGMENTS.txt")
00121   
00122 {}
00123 FragmentsDataBase::FragmentsDataBase(const int size) : _numberOfResidus(size),
00124                                                        _nameOfResidus(new std::string[size]),
00125                                                        _setOfResidus(new ResiduDataBaseElement[size]),
00126                                                        _nameOfDataBase("BASE_FRAGMENTS.txt")
00127 {}
00128 
00129 FragmentsDataBase::~FragmentsDataBase(){
00130   _numberOfResidus = 0 ;
00131   if(_nameOfResidus != NULL)
00132     { delete [] _nameOfResidus ;_nameOfResidus = NULL ;}
00133   if(_setOfResidus != NULL)
00134     { delete [] _setOfResidus ; _setOfResidus = NULL ;}
00135 }
00136 
00137 void FragmentsDataBase::setNumberOfResidus(const int size){
00138   _numberOfResidus = size ;
00139   if(_nameOfResidus != NULL)
00140     { delete [] _nameOfResidus ; }
00141   _nameOfResidus = new std::string[size] ;
00142   if(_setOfResidus != NULL)
00143     { delete [] _setOfResidus ; }
00144   _setOfResidus = new ResiduDataBaseElement[size] ;
00145 }
00146 void FragmentsDataBase::write(){
00147    std::cout << "Number of Residu in DataBase " << _numberOfResidus  << std::endl;
00148    for(int i = 0 ; i < _numberOfResidus; ++i ){
00149      std::cout << _nameOfResidus[i] << "  ";
00150    }
00151    std::cout << std::endl;
00152   for(int i = 0 ; i <  _numberOfResidus; ++i ){
00153     _setOfResidus[i].write() ; 
00154   }
00155   std::cout <<std::endl;
00156 }
00157 void FragmentsDataBase::read(std::ifstream & data){
00158   std::string line("#"), comment("#");
00159 
00160   while (!data.eof() && line[0] == comment[0]) {
00161     std::getline(data, line) ;
00162     //    std::cout << line << std::endl;
00163     }
00164   std::stringstream sline ; sline << line ;
00165   sline >> _numberOfResidus ;
00166   //  std::cout << "Number of Residu in DataBase " << _numberOfResidus  << std::endl;
00167   //
00168   this->setNumberOfResidus( _numberOfResidus) ;
00169   //
00170   for(int i = 0 ; i < _numberOfResidus; ++i ){
00171     data >> _nameOfResidus[i] ;
00172   }
00173   //
00174   // Skip comments
00175   //
00176   for(int i = 0 ; i <  4; ++i ){
00177     std::getline(data, line) ;
00178   }
00179   //
00180   // read 
00181   //
00182   for(int i = 0 ; i <  _numberOfResidus; ++i ){
00183     _setOfResidus[i].read(data) ;
00184   }
00185 }
00186 std::string  FragmentsDataBase::findFragmentName(const std::string &residuName, const std::string &atomName )
00187 {
00188   int numOfResidu = -1  ;
00189   std::string fragmentName ;
00190   for(int i = 0 ; i <  _numberOfResidus; ++i ){
00191     if( _nameOfResidus[i] == residuName){
00192       numOfResidu = i ; break ;
00193     }
00194   }
00195   if(numOfResidu == -1 ){
00196     fragmentName =  residuName ;
00197     
00198     std::cerr <<"Fragment "<<residuName<<" is not in Data Base " <<std::endl ;
00199   }
00200   else{
00201     fragmentName = _setOfResidus[numOfResidu].getFragmentName(atomName) ;
00202   }
00203   return fragmentName ;
00204 }
00205 bool  FragmentsDataBase::getFragmentNameFrom(const std::string &residuName, const std::string &atomName,  
00206                                           std::string &fragmentName)
00207 {
00208   int numOfResidu = -1  ;
00209   for(int i = 0 ; i <  _numberOfResidus; ++i ){
00210     if( _nameOfResidus[i] == residuName){
00211       numOfResidu = i ; break ;
00212     }
00213   }
00214   if(numOfResidu == -1 ){
00215     fragmentName =  residuName ;
00216     return false ;
00217     std::cerr <<"Fragment "<<residuName<<" is not in Data Base " <<std::endl ;
00218   }
00219   else{
00220     fragmentName = _setOfResidus[numOfResidu].getFragmentName(atomName) ;
00221   }
00222   return true ;
00223 }

Generated on Sat Jan 28 21:07:25 2006 for QC++ by  doxygen 1.4.4