#!/usr/bin/perl
#
# Panwen Wang, April 7th, 2009
# Submit a query to http://consurf.tau.ac.il/
# to get conservation scores of each residue.
#
 
 
use URI::Escape;
use LWP::UserAgent;
use LWP::Simple;
use HTTP::Request::Common qw(POST);
use strict;
 
my $ua = LWP::UserAgent->new;
 
if(@ARGV<1){
    print STDERR "\n $0: \n";
    print STDERR "\tPanwen Wang, April 7th, 2009";
    print STDERR "\tSubmit a query to http://consurf.tau.ac.il/ \n";
    print STDERR "\tto get conservation scores of each residue.\n";
    print STDERR "\n Parameters:\n";
    print STDERR "\t-p <pdb_ID>         pdb id in four letters\n";
    print STDERR "\t-c <chain>          chain label of given pdb\n";
    print STDERR "\t-a <algorithm>      Bayes/LikelihoodML\n";
    print STDERR "\t\tDEFAULT:Bayes\n";
    print STDERR "\t-m <MSAprogram>     MUSCLE/CLUSTALW\n";
    print STDERR "\t\tDEFAULT: MUSCLE\n";
    print STDERR "\t-d <DATABASE>       the Homologues database, SWISS-PROT/Uniprot\n";
    print STDERR "\t\tDEFAULT: SWISS-PROT\n";
    print STDERR "\t-n <MAX_NUM_HOMOL>  Max. Number of Homologues\n";
    print STDERR "\t\tDEFAULT: 50\n";
    print STDERR "\t-i <ITERATIONS>     No. of PSI-BLAST Iterations\n";
    print STDERR "\t\tDEFAULT: 1\n";
    print STDERR "\t-e <ESCORE>         PSI-BLAST E-value Cutoff\n";
    print STDERR "\t\tDEFAULT: 0.001\n";
    print STDERR "\t-s <MATRIX>         Model of substitution for proteins\n";
    print STDERR "\t\tJTT(DEFAULT)/mtREV(for mitochondrial proteins)/cpREV(for chloroplasts proteins)/WAG/Dayhoff\n";
    print STDERR "\t-l <email>          user's email\n";
    print STDERR "\t-o <output folder>  where the result files(1A0O_A.score) restore\n";
    print STDERR "\n Usage:\n";
    print STDERR "\t$0 -p 2UUY -c A -l xxx\@xxx.com -o ./conservation\n";
    print STDERR "\t$0 -p 2UUY -c A -l xxx\@xxx.com -o ./conservation -a LikelihoodML ...\n\n";
    exit;
}
 
my ($temp, $pdb_ID, $chain, $user_email, $ALGORITHM, $MSAprogram, $DATABASE, $MAX_NUM_HOMOL, $ITERATIONS, $ESCORE, $MATRIX, $out_dir);
 
while(@ARGV){
    $temp = shift;
    if($temp eq "-p") { $pdb_ID = shift; }
    elsif($temp eq "-c") { $chain = shift; }
    elsif($temp eq "-a") { $ALGORITHM = shift; }
    elsif($temp eq "-m") { $MSAprogram = shift; }
    elsif($temp eq "-d") { $DATABASE = shift; }
    elsif($temp eq "-n") { $MAX_NUM_HOMOL = shift; }
    elsif($temp eq "-i") { $ITERATIONS = shift; }
    elsif($temp eq "-e") { $ESCORE = shift; }
    elsif($temp eq "-s") { $MATRIX = shift; }
    elsif($temp eq "-l") { $user_email = shift; }
    elsif($temp eq "-o") { $out_dir = shift; }
    else {
        print STDERR "Warning: argument $temp igorned.\n";
    }
}
 
die "Error: argument '-p' is essential.\n" if(!defined($pdb_ID));
die "Error: argument '-c' is essential.\n" if(!defined($chain));
die "Error: argument '-l' is essential.\n" if(!defined($user_email));
die "Error: argument '-o' is essential.\n" if(!defined($out_dir));
$ALGORITHM = "Bayes"                       if(!defined($ALGORITHM));
$MSAprogram = "MUSCLE"                     if(!defined($MSAprogram));
$DATABASE = "SWISS-PROT"                   if(!defined($DATABASE));
$MAX_NUM_HOMOL = "50"                      if(!defined($MAX_NUM_HOMOL));
$ITERATIONS = "1"                          if(!defined($ITERATIONS));
$ESCORE = "0.001"                          if(!defined($ESCORE));
$MATRIX = "JTT"                            if(!defined($MATRIX));
 
# end of handling parameters
 
# read and encode the queries
#my $encoded_query;
##foreach my $query (@ARGV)
##    {
##    open(QUERY,$query);
##    while(<QUERY>)
##        {
##        $encoded_query = $encoded_query . uri_escape($_);
##        }
# }
 
# build the request
my $args = "pdb_ID=$pdb_ID&chain=$chain&user_email=$user_email&ALGORITHM=$ALGORITHM&MSAprogram=$MSAprogram&DATABASE=$DATABASE&MAX_NUM_HOMOL=$MAX_NUM_HOMOL&ITERATIONS=$ITERATIONS&ESCORE=$ESCORE&MATRIX=$MATRIX&send_user_mail=yes&BayesInterval=3";
 
print "Querying ...\n";
 
my $req = new HTTP::Request POST => 'http://consurf.tau.ac.il/cgi-bin/consurf.cgi';
$req->content_type('application/x-www-form-urlencoded');
$req->content($args);
 
# get the response
my $response = $ua->request($req);
 
# parse out the request id
$response->content =~ /The document has moved <a href=\"(.+)\">here/;
 
my $result_page = $1;
 
print "Waiting ...\n";
sleep 25;
 
# poll for results
for(;;){
    sleep 5;
 
    my $req = new HTTP::Request GET => $result_page;
    $response = $ua->request($req);
 
    my $content = $response->content;
    if($content =~ /ConSurf calculation is finished/){
        print "Getting result ...\n";
        my $prefix_url = $1 if($result_page =~ /(.+)output\.html/);
        my $result_file = "${prefix_url}pdb".lc($pdb_ID).".gradesPE";
        print "Saving result ...\n";
        getstore($result_file, "$out_dir/${pdb_ID}_$chain.score");
        #my $req1 = new HTTP::Request GET => $result_file;
        #my $response1 = $ua->request($req1);
        #open(OUT,">$out_dir/${pdb_ID}_$chain.score");
        #print OUT  $response1->content;
        last;
    } elsif($content =~ /For assistance please/){
        die("ERROR! ConSurf session has been terminated.\n");
    } else {
        print "Waiting ...\n";
        next;    
    }
    die("Sth. unexpected happened.\n");
} # end poll loop

package Atom;
use strict;
 
sub new {
    my $class    = shift;
    my $self    = {
        SERIAL        => undef,   # id of the atom
        NAME         => undef,    # full name of the atom, like CA
        RESNAME        => undef,    # name of the residue of the atom
        CHAINID        => undef,    # chain label of the atom
        RESSEQ        => undef,    # residue id of the atom
        X            => undef,    # x
        Y            => undef,    # y
        Z            => undef,    # z
        OCCUPANCY    => undef,    # occupancy
        TEMPFACTOR    => undef,    # temperature factor
    };
    bless $self, $class;
    return $self;
}
 
# Parameters: - / $line 
# Get information from an atom text line 
# or return an atom text line
sub line{
    my $self = shift;
    if (@_) { 
        my $line = shift;
        ($self->{SERIAL},$self->{NAME},$self->{RESNAME},$self->{CHAINID},$self->{RESSEQ},$self->{X},$self->{Y},$self->{Z},$self->{OCCUPANCY},$self->{TEMPFACTOR}) = ($line =~ /^ATOM\s+(\d+)\s+([A-Z0-9]+)\s*([A-Z]{3})\s+([A-Z0-9]{1})\s*([a-z0-9]+)\s+([0-9.-]+)\s+([0-9.-]+)\s+([0-9.-]+)\s+([0-9.-]+)\s+([0-9.-]+).+$/); 
        # ATOM   2843  C   ASN C 124     143.867  14.117  34.756  1.00 39.65
    }
    return     sprintf(
                "ATOM  %5d  %-3s %-3s %s%4s    %8.3f%8.3f%8.3f%6.2f%6.2f",
                $self->{SERIAL},
                $self->{NAME},
                $self->{RESNAME},
                $self->{CHAINID},
                $self->{RESSEQ},
                $self->{X},
                $self->{Y},
                $self->{Z},
                $self->{OCCUPANCY},
                $self->{TEMPFACTOR}
            );
}
 
# set or get serial of this atom
sub serial{
    my $self = shift;
    if (@_) { $self->{SERIAL} = shift; }
    return $self->{SERIAL};
}
 
# set or get name of this atom
sub name{
    my $self = shift;
    if (@_) { $self->{NAME} = shift; }
    return $self->{NAME};
}
 
# set or get resName of this atom
sub resName{
    my $self = shift;
    if (@_) { $self->{RESNAME} = shift; }
    return $self->{RESNAME};
}
 
# set or get chainId of this atom
sub chainId{
    my $self = shift;
    if (@_) { $self->{CHAINID} = shift; }
    return $self->{CHAINID};
}
 
# set or get resSeq of this atom
sub resSeq{
    my $self = shift;
    if (@_) { $self->{RESSEQ} = shift; }
    return $self->{RESSEQ};
}
 
#set or get x
sub x{
    my $self = shift;
    if (@_) { $self->{X} = shift; }
    return $self->{X};
}
 
#set or get y
sub y{
    my $self = shift;
    if (@_) { $self->{Y} = shift; }
    return $self->{Y};
}
 
#set or get z
sub z{
    my $self = shift;
    if (@_) { $self->{Z} = shift; }
    return $self->{Z};
}
 
#set or get occupancy
sub occupancy{
    my $self = shift;
    if (@_) { $self->{OCCUPANCY} = shift; }
    return $self->{OCCUPANCY};
}
 
#set or get temperature factor
sub tempFactor{
    my $self = shift;
    if (@_) { $self->{TEMPFACTOR} = shift; }
    return $self->{TEMPFACTOR};
}
 
#calculate the distance from this atom to another 
sub distanceFrom{
    my $self = shift;
    my $atom = shift;
    return sqrt(
        ($self->{X}-$atom->x)*($self->{X}-$atom->x)+
        ($self->{Y}-$atom->y)*($self->{Y}-$atom->y)+
        ($self->{Z}-$atom->z)*($self->{Z}-$atom->z)
    );
}
 
1;

package Residue;
use strict;
use pdbClass::Atom;
 
sub new{
    my $class     = shift;
    my $self    = {
        ATOMS    => [],
    };
    bless $self,$class;
    return $self;
}
 
# usage: atoms 
#        atoms($subscript)
#        atoms($serial,1)
# return all atoms or an atom by subscript
# or an atom by its serial/id.
sub atoms{
    my $self = shift;
    if (@_) {
        my $i = shift;
        if (@_) {
            my $j;
            for ($j=0; $j<@{$self->{ATOMS}}; $j++){
                if ($self->{ATOMS}[$j]->id eq $i) {
                    $i = $j; last;
                }
            }
            if ($j == @{$self->{ATOMS}}){
                die("ATOMS: label not exists!\n");
            }
        } elsif ($i<0 || $i>@{$self->{ATOMS}}){
            die("ATOMS: subscript out of range!\n");
        } 
        return $self->{ATOMS}[$i]; 
    }
    return @{$self->{ATOMS}};
}
 
sub name{  #get residue name
    my $self = shift;
    return $self->{ATOMS}[0]->resName;
}
 
sub chainId{ # get chain id
    my $self = shift;
    return $self->{ATOMS}[0]->chainId;
}
 
sub seq{ # get residue id
    my $self = shift;
    return $self->{ATOMS}[0]->resSeq;    
}
 
sub ca{  # get atom CA
    my $self = shift;
    foreach my $atom (@{$self->{ATOMS}}) {
        if($atom->name eq "CA"){ return $atom; }
    }
}
 
sub addAtom{ #add atom to this residue
    my $self = shift;
    push @{$self->{ATOMS}},@_;
}
 
sub size{ # amount of atoms
    my $self = shift;
    return scalar(@{$self->{ATOMS}});
}
 
sub abbr{ # get abbreviation name
    my $self = shift;
    my %aa = (
        'ALA' => 'A',
        'GLY' => 'G',
        'LEU' => 'L',
        'ILE' => 'I',
        'MET' => 'M',
        'SER' => 'S',
        'THR' => 'T',
        'TYR' => 'Y',
        'PHE' => 'F',
        'ASP' => 'D',
        'ASN' => 'N',
        'GLU' => 'E',
        'GLN' => 'Q',
        'ARG' => 'R',
        'HIS' => 'H',
        'CYS' => 'C',
        'TRP' => 'W',
        'VAL' => 'V',
        'LYS' => 'K',
        'PRO' => 'P',
    );
    return $aa{$self->{ATOMS}[0]->resName};
}
1;

package Chain;
use strict;
use pdbClass::Residue;
 
sub new{
    my $class     = shift;
    my $self    = {
        RESIDUES=> [],
    };
    bless $self,$class;
    return $self;
}
 
# usage: residues 
#        residues($subscript)
#        residues($id,1)
# return all residues or a residue by subscript
# or a residue by its id.
sub residues{
    my $self = shift;
    if (@_) {
        my $i = shift;
        if (@_) {
            my $j;
            for ($j=0; $j<@{$self->{RESIDUES}}; $j++){
                if ($self->{RESIDUES}[$j]->id eq $i) {
                    $i = $j; last;
                }
            }
            if ($j == @{$self->{RESIDUES}}){
                die("RESIDUES: label not exists!\n");
            }
        } elsif ($i<0 || $i>@{$self->{RESIDUES}}){
            die("RESIDUES: subscript out of range!\n");
        } 
        return $self->{RESIDUES}[$i]; 
    }
    return @{$self->{RESIDUES}};
}
 
sub id{  #get chain id
    my $self = shift;
    return $self->{RESIDUES}[0]->chainId;
}
 
sub addResidue{ #add residue to this chain
    my $self = shift;
    push @{$self->{RESIDUES}},@_;
}
 
sub size{ # how many residues this chain contains
    my $self = shift;
    return scalar(@{$self->{RESIDUES}});
}
 
# get a sequence by abbreviation of residues' name
sub sequence{ 
    my $self = shift;
    my $seq = "";
    foreach my $residue (@{$self->{RESIDUES}}){
        $seq .= $residue->abbr;
    }
    return $seq;
}
 
1;

package Model;
use strict;
use pdbClass::Chain;
 
sub new{
    my $class     = shift;
    my $self    = {
        CHAINS    => [],
        ID        => undef,
    };
    bless $self,$class;
    return $self;
}
 
# usage: chains 
#        chains($subscript)
#        chains($label,1)
# return all chains or a chain by subscript
# or a chain by its label.
sub chains{
    my $self = shift;
    if (@_) {
        my $i = shift;
        if (@_) {
            my $j;
            for ($j=0; $j<@{$self->{CHAINS}}; $j++){
                if ($self->{CHAINS}[$j]->id eq $i) {
                    $i = $j; last;
                }
            }
            if ($j == @{$self->{CHAINS}}){
                die("CHAINS: label not exists!\n");
            }
        } elsif ($i<0 || $i>@{$self->{CHAINS}}){
            die("CHAINS: subscript out of range!\n");
        } 
        return $self->{CHAINS}[$i]; 
    }
    return @{$self->{CHAINS}};
}
 
sub id{  #get model id
    my $self = shift;
    if (@_) { $self->{ID} = shift; }
    return $self->{ID};
}
 
sub addChain{ #add chain to this model
    my $self = shift;
    push @{$self->{CHAINS}},@_;
}
 
sub size{ # amount of chains
    my $self = shift;
    return scalar(@{$self->{CHAINS}});
}
 
1;

package Pdb;
use strict;
use pdbClass::Model;
 
sub new{
    my $class     = shift;
    my $self    = {
        MODELS    => [],
        ID        => undef,   # like 1A0O
        CLASH    => undef,   # like 1A0O_AB  (comes from 1A0O_AB.pdb)
    };
    bless $self,$class;
    return $self;
}
 
# load pdb from a pdb file
sub load{
    my $self = shift;
    if(!@_){die("Pdb file name needed!\n");}
    my $file = shift;
    $self->{ID} = substr($file,rindex($file,"/")+1,4);
    $self->{CLASH} = substr($file,rindex($file,"/")+1,-4);
    my ($modelFlag, $chainFlag, $residueFlag);
    my ($atom, $residue, $chain, $model);
 
    open(FILE,$file);
    while(my $line = <FILE>){
        if($line =~ m/^MODEL\s+(.+)$/){  # if contains models
            if($modelFlag ne $1){ 
                $modelFlag = $1;
                $model = Model->new;
                $model->id($modelFlag);
                push @{$self->{MODELS}}, $model;
            }
        }
        if($line =~ m/^ATOM.+$/){
            $atom = Atom->new;
            $atom->line($line);
            if(!defined($model)){   # if not contains models,
                $model = Model->new;# define one, and set id 0
                $model->id(0);
                push @{$self->{MODELS}}, $model;
            }
            if($chainFlag ne $atom->chainId){
                $chainFlag = $atom->chainId; 
                $chain = Chain->new;
                $model->addChain($chain); 
            }
            if($residueFlag ne $atom->resSeq){
                $residueFlag = $atom->resSeq;    
                $residue = Residue->new; 
                $chain->addResidue($residue);
            }    
            $residue->addAtom($atom);
        }
    }
    close(FILE);
}
 
# get or set clash
sub clash{
    my $self = shift;
    if (@_) { $self->{CLASH} = @_; }
    return $self->{CLASH};
}
 
# usage: models 
#        models($subscript)
#        models($label,1)
# return all models or a model by subscript
# or a model by its label.
sub models{
    my $self = shift;
    if (@_) {
        my $i = shift;
        if (@_) {
            my $j;
            for ($j=0; $j<@{$self->{MODELS}}; $j++){
                if ($self->{MODELS}[$j]->id eq $i) {
                    $i = $j; last;
                }
            }
            if ($j == @{$self->{MODELS}}){
                die("MODELS: label not exists!\n");
            }
        } elsif ($i<0 || $i>@{$self->{MODELS}}){
            die("MODELS: subscript out of range!\n");
        } 
        return $self->{MODELS}[$i]; 
    }
    return @{$self->{MODELS}};
}
 
sub id{  #get pdb id
    my $self = shift;
    if (@_) { $self->{ID} = @_; }
    return $self->{ID};
}
 
sub addModel{ #add models
    my $self = shift;
    push @{$self->{MODELS}},@_;
}
 
sub size{ # amount of models
    my $self = shift;
    return scalar(@{$self->{MODELS}});
}
 
1;

#ifndef _PDB_H_  
#define _PDB_H_ 
 
#include<iostream> 
#include<fstream> 
#include<cstdio> 
#include<string>  
#include<vector>  
 
#define atoms vector<atom>  
#define chains vector<chain>  
#define aint vector<atom>::size_type  
#define cint vector<chain>::size_type   
 
using namespace std;   
 
class atom{   
private:   
    short atom_id;   
    string atom_nick;   
    string atom_res;   
    char atom_chain;   
    short atom_res_id;   
    float atom_x, atom_y, atom_z, atom_w, atom_bfactor;   
    char atom_name;   
 
public:   
    atom(short, string, string, char, short, float, float, float, float, float, char);   
    atom(string);   
    string line();   
};   
 
atom::atom( short a_id,   
            string a_nick,   
            string r,   
            char c,   
            short r_id,   
            float a_x,   
            float a_y,   
            float a_z,   
            float a_w,   
            float b,   
            char a_name){   
    atom_id = a_id;   
    atom_nick = a_nick;   
    atom_res = r;   
    atom_chain = c;   
    atom_res_id = r_id;   
    atom_x = a_x;   
    atom_y = a_y;   
    atom_z = a_z;   
    atom_w = a_w;   
    atom_bfactor = b;   
    atom_name = a_name;   
}   
 
atom::atom(string l){   
    atom_id = atoi(l.substr(6,5).c_str());   
    atom_nick = l.substr(13,3);   
    atom_res = l.substr(17,3);   
    atom_chain = l[21];   
    atom_res_id = atoi(l.substr(22,4).c_str());   
    atom_x = atof(l.substr(30,8).c_str());   
    atom_y = atof(l.substr(38,8).c_str());   
    atom_z = atof(l.substr(46,8).c_str());   
    atom_w = atof(l.substr(54,6).c_str());   
    atom_bfactor = atof(l.substr(60,6).c_str());   
    atom_name = l.size()>77 ? l[77] : ' ';   
}   
 
string atom::line(){   
    char line[255];   
    (void)sprintf(  line,   
                    "ATOM  %5u  %-3s %-3s %c%4u    %8.3f%8.3f%8.3f%6.2f%6.2f           %c",   
                    atom_id,   
                    atom_nick.c_str(),   
                    atom_res.c_str(),   
                    atom_chain,   
                    atom_res_id,   
                    atom_x,   
                    atom_y,   
                    atom_z,   
                    atom_w,   
                    atom_bfactor,   
                    atom_name);   
    return string(line);   
}   
 
//===============================================   
class chain{   
private:   
    atoms chain_atms;   
    char chain_label;   
public:   
    chain(char);   
    void addAtom(atom);   
    void saveToFile(string);   
    aint size();   
    char label();   
    atom operator[](aint);   
};   
 
chain::chain(char l){ chain_label = l; }   
 
aint chain::size(){   
    return chain_atms.size();   
}   
 
atom chain::operator[](aint i){   
    if(i>=0 and i<chain_atms.size())   
        return chain_atms[i];   
}   
 
char chain::label(){   
    return chain_label;   
}   
 
void chain::addAtom(atom a){   
    chain_atms.push_back(a);   
    return;   
}   
 
void chain::saveToFile(string f){   
    ofstream in(f.c_str());   
    for(cint i=0; i<chain_atms.size(); i++){   
        in << chain_atms[i].line() << endl;   
    }   
    in << "TER" << endl;   
    in.close();   
    return;   
}   
 
//===============================================   
class pdb{   
private:   
    chains pdb_chns;   
 
public:   
    pdb(string);   
    cint size();   
    chain operator[](cint);   
};   
 
cint pdb::size(){   
    return pdb_chns.size();   
}   
 
chain pdb::operator[](cint i){   
    if(i>=0 and i<pdb_chns.size()) return pdb_chns[i];   
}   
 
pdb::pdb(string pdbfile){   
    string l;   
    char flag, chain_label;   
    ifstream out1(pdbfile.c_str());   
    while(getline(out1, l)){    //get the chain labels first   
        if(l.substr(0,4) == "ATOM"){   
            chain_label = l[21];   
            if(flag != chain_label){   
                chain chn(chain_label);   
                pdb_chns.push_back(chn);   
                flag = chain_label;   
            }   
        }   
    }   
    out1.close();   
    ifstream out2(pdbfile.c_str());   
    while(getline(out2, l)){   
        if(l.substr(0,4) == "ATOM"){   
            atom atm(l);   
            chain_label = l[21];   
            for(cint i=0; i<pdb_chns.size(); i++){   
                if(chain_label == pdb_chns[i].label())   
                    pdb_chns[i].addAtom(atm);   
            }   
        }   
    }   
    out2.close();   
}  
#endif