string location_of(atom atom)
{
int path_id=literal_id(atom.path());
int line_id=literal_id(atom.line().trim());
return concat("location",pack(path_id,line_id,atom.number()).join(",").parens());
}
int literal_id(atom value)
{
//string
if(value.is_string())
return _literals.index(value.get());
//literal
return literal_id(value.get());
}
wrl::atom::atom(const atom& that)
{
param_map::const_iterator i;
// Copy that atom.
*this = that;
// Duplicate GL state.
if (that.fill) fill = new ogl::unit(*that.fill);
if (that.line) line = new ogl::unit(*that.line);
// Duplicate ODE state.
if ((edit_geom = that.new_edit_geom(0)))
{
dGeomSetData (edit_geom, this);
bGeomSetTransform(edit_geom, current_M);
}
// Flush and clone each parameter separately.
params.clear();
for (i = that.params.begin(); i != that.params.end(); ++i)
params[i->first] = new param(*i->second);
}
void test_single_cas(size_t id, size_t nrun) {
size_t dummy;
for (size_t i = 0; i < nrun; i++) {
lock_instr_test.compare_exchange_weak(dummy,
dummy+1,
std::memory_order_relaxed,
std::memory_order_relaxed);
}
}
typename basic_otp_mailbox_registry<Alloc, Mutex>::mailbox_ptr
basic_otp_mailbox_registry<Alloc, Mutex>::create_mailbox(
const atom& a_name, boost::asio::io_service* a_svc)
{
lock_guard<Mutex> guard(m_lock);
if (!a_name.empty()) {
typename std::map<atom, mailbox_ptr>::iterator it = m_by_name.find(a_name);
if (it != m_by_name.end())
return it->second; // Already registered!
}
epid<Alloc> l_pid = m_owner_node.create_pid();
mailbox_ptr mbox = new mailbox_type(m_owner_node, l_pid, a_name, a_svc);
if (!a_name.empty())
m_by_name.insert(std::pair<atom, mailbox_ptr>(a_name, mbox));
m_by_pid.insert(std::pair<epid<Alloc>, mailbox_ptr>(l_pid, mbox));
return mbox;
}
void test_many_cas(size_t id, size_t nrun) {
size_t dummy;
for (size_t i = 0; i < nrun; i++) {
while (!lock_instr_test.compare_exchange_weak(dummy,
dummy+1,
std::memory_order_relaxed,
std::memory_order_relaxed))
{}
}
}
void timer_reconnect(const boost::system::error_code& ec) {
if (ec == boost::asio::error::operation_aborted)
return; // timer reset
if (verbose() >= VERBOSE_TRACE)
std::cerr << "basic_otp_connection::timer_reconnect: " << ec.message() << std::endl;
m_transport = connection_type::create(
m_io_service, this, m_node->nodename().to_string(),
m_remote_nodename.to_string(), m_cookie, m_alloc);
}
bool basic_otp_mailbox_registry<Alloc, Mutex>::unregister(const atom& a_name)
{
if (!a_name.empty())
return false;
lock_guard<Mutex> guard(m_lock);
typename std::map<atom, mailbox_ptr>::iterator it = m_by_name.find(a_name);
if (it == m_by_name.end())
return;
it->second.name("");
m_by_name.erase(it);
}
string value_of(atom atom)
{
string type=atom.type();
string value=atom.get();
if(atom.is_number())
{
//number
if(value.is_integer())
type="integer";
else
{
check(value.is_real());
type="real";
}
}
else if(atom.is_string())
{
//string
type="literal";
value=stringify(literal_id(atom));
}
else if(atom.is_identifier())
{
//identifier
value=_identifiers.index(literal_id(atom)).string_();
}
else
{
//raw
type="literal";
value=stringify(literal_id(atom));
}
return concat(type,value.parens());
}
bool basic_otp_mailbox_registry<Alloc, Mutex>::add(const atom& a_name, mailbox_ptr a_mbox)
{
if (a_name.empty())
throw err_bad_argument("Empty registering name!");
if (!a_mbox->name().empty())
throw err_bad_argument("Mailbox already registered as", a_mbox->name());
lock_guard<Mutex> guard(m_lock);
if (m_by_name.find(a_name) != m_by_name.end())
return false;
m_by_name.insert(std::pair<atom, mailbox_ptr>(a_name, a_mbox));
a_mbox->name(a_name);
return true;
}
// Verify data encoding
void check(atom test, atom::type_t type, atom::enc_t enc, size_t size)
{
atom::type_t type_found;
atom::enc_t enc_found;
byte_vector test_bytes = test.encode_vector();
atom copy;
// Dump
printf("Atom: ");
test.print();
// What's in the atom?
type_found = test.get_type();
printf("\nData Type: %s\n", atom_type_to_string(type_found));
if (type != type_found)
{
printf("*** Failed (expected %s) ***\n", atom_type_to_string(type));
exit(1);
}
// How is it encoded?
enc_found = test.get_enc();
printf("Encoding: %s\n", atom_enc_to_string(enc_found));
if (enc != enc_found)
{
printf("*** Failed (expected %s) ***\n", atom_enc_to_string(enc));
exit(1);
}
// Debug
dump(test_bytes);
// Check total size
if (test.get_header_size() + size != test_bytes.size())
{
printf("*** Failed (expected %u bytes) ***\n",
(unsigned int)(test.get_header_size() + size));
exit(1);
}
// Reconstruct atom
printf("Testing reconstructed copy ...\n");
copy.decode_vector(test_bytes);
if (test != copy)
{
printf("*** Failed (decoded object differs) ***\n");
exit(1);
}
// Bump the counter
test_count++;
}
basic_otp_connection(
connect_completion_handler h,
boost::asio::io_service& a_svc,
basic_otp_node<Alloc,Mutex>* a_node, const atom& a_remote_node,
const std::string& a_cookie, int a_reconnect_secs = 0,
const Alloc& a_alloc = Alloc())
: m_io_service(a_svc)
, m_node(a_node)
, m_remote_nodename(a_remote_node)
, m_cookie(a_cookie)
, m_alloc(a_alloc)
, m_connected(false)
, m_reconnect_timer(m_io_service)
, m_reconnect_secs(a_reconnect_secs)
, m_abort(false)
{
BOOST_ASSERT(a_node != NULL);
m_on_connect_status = h;
m_transport = connection_type::create(
m_io_service, this, a_node->nodename().to_string(),
a_remote_node.to_string(), a_cookie, a_alloc);
}
void test_single_add(size_t id, size_t nrun) {
for (size_t i = 0; i < nrun; i++) {
lock_instr_test.fetch_add(1, std::memory_order_relaxed);
}
}
//! Returns true if the current atom is covalently bonded to a given atom.
bool atom::is_neighbor(const atom& a) const
{
assert(this != &a);
const double r = 1.1 * (covalent_radius() + a.covalent_radius());
return distance_sqr(coord, a.coord) < r * r;
}
size_t length() const { return m_name.length(); }
const string_t& str() const { return m_name.to_string(); }
const char* c_str() const { return m_name.c_str(); }
/// Returns true if the current atom is covalently bonded to a given atom.
bool has_covalent_bond(const atom& a) const
{
const float s = covalent_radius() + a.covalent_radius();
return distance_sqr(coord, a.coord) < s * s;
}
port(const atom& node, const int id, const int creation, const Alloc& a_alloc = Alloc())
throw (err_bad_argument)
{
detail::check_node_length(node.size());
init(node, id, creation, a_alloc);
}
receptor::receptor(istream& is, const box& b) : partitions(b.num_partitions)
{
// Initialize necessary variables for constructing a receptor.
atoms.reserve(5000); // A receptor typically consists of <= 5,000 atoms.
// Initialize helper variables for parsing.
string residue = "XXXX"; // Current residue sequence, used to track residue change, initialized to a dummy value.
vector<size_t> residues;
residues.reserve(1000); // A receptor typically consists of <= 1,000 residues, including metal ions and water molecules if any.
size_t num_lines = 0; // Used to track line number for reporting parsing errors, if any.
string line;
line.reserve(79); // According to PDBQT specification, the last item AutoDock atom type locates at 1-based [78, 79].
// Parse ATOM/HETATM.
while (getline(is, line))
{
++num_lines;
if (starts_with(line, "ATOM") || starts_with(line, "HETATM"))
{
// Parse and validate AutoDock4 atom type.
const string ad_type_string = line.substr(77, isspace(line[78]) ? 1 : 2);
const size_t ad = parse_ad_type_string(ad_type_string);
if (ad == AD_TYPE_SIZE) continue;
// Skip non-polar hydrogens.
if (ad == AD_TYPE_H) continue;
// Parse the Cartesian coordinate.
string name = line.substr(12, 4);
boost::algorithm::trim(name);
const atom a(line.substr(21, 1) + ':' + line.substr(17, 3) + right_cast<string>(line, 23, 26) + ':' + name, vec3(right_cast<fl>(line, 31, 38), right_cast<fl>(line, 39, 46), right_cast<fl>(line, 47, 54)), ad);
// For a polar hydrogen, the bonded hetero atom must be a hydrogen bond donor.
if (ad == AD_TYPE_HD)
{
const size_t residue_start = residues.back();
for (size_t i = atoms.size(); i > residue_start;)
{
atom& b = atoms[--i];
if (!b.is_hetero()) continue; // Only a hetero atom can be a hydrogen bond donor.
if (a.is_neighbor(b))
{
b.donorize();
break;
}
}
}
else // It is a heavy atom.
{
// Parse the residue sequence located at 1-based [23, 26].
if ((line[25] != residue[3]) || (line[24] != residue[2]) || (line[23] != residue[1]) || (line[22] != residue[0])) // This line is the start of a new residue.
{
residue[3] = line[25];
residue[2] = line[24];
residue[1] = line[23];
residue[0] = line[22];
residues.push_back(atoms.size());
}
atoms.push_back(a);
}
}
else if (starts_with(line, "TER"))
{
residue = "XXXX";
}
}
// Dehydrophobicize carbons if necessary.
const size_t num_residues = residues.size();
residues.push_back(atoms.size());
for (size_t r = 0; r < num_residues; ++r)
{
const size_t begin = residues[r];
const size_t end = residues[r + 1];
for (size_t i = begin; i < end; ++i)
{
const atom& a = atoms[i];
if (!a.is_hetero()) continue; // a is a hetero atom.
for (size_t j = begin; j < end; ++j)
{
atom& b = atoms[j];
if (b.is_hetero()) continue; // b is a carbon atom.
// If carbon atom b is bonded to hetero atom a, b is no longer a hydrophobic atom.
if (a.is_neighbor(b))
{
b.dehydrophobicize();
}
}
}
}
// Find all the heavy receptor atoms that are within 8A of the box.
vector<size_t> receptor_atoms_within_cutoff;
receptor_atoms_within_cutoff.reserve(atoms.size());
const size_t num_rec_atoms = atoms.size();
for (size_t i = 0; i < num_rec_atoms; ++i)
{
const atom& a = atoms[i];
if (b.project_distance_sqr(a.coordinate) < scoring_function::Cutoff_Sqr)
{
receptor_atoms_within_cutoff.push_back(i);
}
}
const size_t num_receptor_atoms_within_cutoff = receptor_atoms_within_cutoff.size();
// Allocate each nearby receptor atom to its corresponding partition.
for (size_t x = 0; x < b.num_partitions[0]; ++x)
for (size_t y = 0; y < b.num_partitions[1]; ++y)
for (size_t z = 0; z < b.num_partitions[2]; ++z)
{
vector<size_t>& par = partitions(x, y, z);
par.reserve(num_receptor_atoms_within_cutoff);
const array<size_t, 3> index1 = {{ x, y, z }};
const array<size_t, 3> index2 = {{ x + 1, y + 1, z + 1 }};
const vec3 corner1 = b.partition_corner1(index1);
const vec3 corner2 = b.partition_corner1(index2);
for (size_t l = 0; l < num_receptor_atoms_within_cutoff; ++l)
{
const size_t i = receptor_atoms_within_cutoff[l];
const atom& a = atoms[i];
const fl proj_dist_sqr = b.project_distance_sqr(corner1, corner2, a.coordinate);
if (proj_dist_sqr < scoring_function::Cutoff_Sqr)
{
par.push_back(i);
}
}
}
}
