name string | code string | asm string | file string |
|---|---|---|---|
OpenMD::Molecule::getCom() | Vector3d Molecule::getCom() {
StuntDouble* sd;
std::vector<StuntDouble*>::iterator i;
Vector3d com {};
RealType totalMass {};
RealType mass {};
for (sd = beginIntegrableObject(i); sd != NULL;
sd = nextIntegrableObject(i)) {
mass = sd->getMass();
totalMass += mass;
com... | movq %rdi, %rax
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0xa0(%rsi), %rcx
movq 0xa8(%rsi), %rdx
xorpd %xmm0, %xmm0
cmpq %rdx, %rcx
je 0xa9be6
movq (%rcx), %rsi
testq %rsi, %rsi
je 0xa9be6
xorpd %xmm1, %xmm1
movsd 0x38(%rsi), %xmm2
movq 0x10(%rsi), %rdi
movq 0x18(%rsi), %r8
movq 0x18(%r8), %r8
... | /OpenMD[P]OpenMD/src/primitives/Molecule.cpp |
OpenMD::Molecule::getCom(int) | Vector3d Molecule::getCom(int snapshotNo) {
StuntDouble* sd;
std::vector<StuntDouble*>::iterator i;
Vector3d com {};
RealType totalMass {};
RealType mass {};
for (sd = beginIntegrableObject(i); sd != NULL;
sd = nextIntegrableObject(i)) {
mass = sd->getMass();
totalMass += m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0xa0(%rsi), %r15
xorpd %xmm1, %xmm1
cmpq 0xa8(%rsi), %r15
je 0xa9cfb
movq (%r15), %r12
testq %r12, %r12
je 0xa9cfb
movl %edx, %ebp
movq %rsi, %r14
movsd %xmm1, 0x8(%... | /OpenMD[P]OpenMD/src/primitives/Molecule.cpp |
OpenMD::Molecule::getComVel() | Vector3d Molecule::getComVel() {
StuntDouble* sd;
std::vector<StuntDouble*>::iterator i;
Vector3d velCom;
RealType totalMass = 0;
RealType mass;
for (sd = beginIntegrableObject(i); sd != NULL;
sd = nextIntegrableObject(i)) {
mass = sd->getMass();
totalMass += mass;
ve... | movq %rdi, %rax
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0xa0(%rsi), %rcx
movq 0xa8(%rsi), %rdx
xorpd %xmm0, %xmm0
cmpq %rdx, %rcx
je 0xa9f0d
movq (%rcx), %rsi
testq %rsi, %rsi
je 0xa9f0d
xorpd %xmm1, %xmm1
movsd 0x38(%rsi), %xmm2
movq 0x10(%rsi), %rdi
movq 0x18(%rsi), %r8
movq 0x18(%r8), %r8
... | /OpenMD[P]OpenMD/src/primitives/Molecule.cpp |
void OpenMD::Utils::details::lifted_deleter<OpenMD::CutoffGroup*>(OpenMD::CutoffGroup*) | void lifted_deleter(T val) {
delete val;
} | pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0xaa502
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xaa502
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x12430
movl $0x40, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x12430
| /OpenMD[P]OpenMD/src/utils/MemoryUtils.hpp |
OpenMD::ConstraintPair::~ConstraintPair() | ~ConstraintPair() {
delete consElem1_;
delete consElem2_;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0xaa55b
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0xaa54d
callq 0x23d2e
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xaa55b
callq 0x23d2e
movl $0x28, %esi
movq %r14, %rdi
callq 0x12430
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0xaa58d
m... | /OpenMD[P]OpenMD/src/constraints/ConstraintPair.hpp |
OpenMD::RigidBody::calcForcesAndTorques() | void RigidBody::calcForcesAndTorques() {
Vector3d afrc;
Vector3d atrq;
Vector3d apos;
Vector3d rpos;
Vector3d frc(0.0);
Vector3d trq(0.0);
Vector3d ef(0.0);
Vector3d pos = this->getPos();
AtomType* atype;
int eCount = 0;
int sl =
((snapshotMan_->getCurrentSnapshot())... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp # imm = 0x100
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
xorl %r12d, %r12d
movq %r12, 0x70(%rsp)
movq %r12, 0xd0(%rsp)
movaps %xmm0, 0xc0(%rsp)
movq %r12, 0xb0(%rsp)
movaps %xmm0, 0xa0(%rsp)
movq %r12, 0x90(%rsp)
movaps... | /OpenMD[P]OpenMD/src/primitives/RigidBody.cpp |
OpenMD::RigidBody::updateAtomVel() | void RigidBody::updateAtomVel() {
Mat3x3d skewMat;
Vector3d ji = getJ();
Mat3x3d I = getI();
skewMat(0, 0) = 0;
skewMat(0, 1) = ji[2] / I(2, 2);
skewMat(0, 2) = -ji[1] / I(1, 1);
skewMat(1, 0) = -ji[2] / I(2, 2);
skewMat(1, 1) = 0;
skewMat(1, 2) = ji[0] / I(0, 0);
skewMat(2... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
movq 0x18(%rcx), %rcx
movslq 0x30(%rdi), %rdx
movq 0x60(%rcx,%rax), %rax
leaq (%rdx,%rdx,2), %rcx
movsd 0x10(%rax,%rcx,8), %xmm0
movaps %xmm0, 0x80(%rsp)
xorps 0x3b11f(%rip)... | /OpenMD[P]OpenMD/src/primitives/RigidBody.cpp |
OpenMD::RigidBody::updateAtomVel(int) | void RigidBody::updateAtomVel(int frame) {
Mat3x3d skewMat;
;
Vector3d ji = getJ(frame);
Mat3x3d I = getI();
skewMat(0, 0) = 0;
skewMat(0, 1) = ji[2] / I(2, 2);
skewMat(0, 2) = -ji[1] / I(1, 1);
skewMat(1, 0) = -ji[2] / I(2, 2);
skewMat(1, 1) = 0;
skewMat(1, 2) = ji[0] / I(0... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movl %esi, %ebx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x10(%r14), %rcx
movslq 0x30(%r14), %rdx
movq 0x60(%rax,%rcx), %rax
leaq (%rdx,%rdx,2), %rcx
movsd 0x10(%rax,%rcx,8)... | /OpenMD[P]OpenMD/src/primitives/RigidBody.cpp |
OpenMD::RigidBody::getAtomPos(OpenMD::Vector3<double>&, unsigned int) | bool RigidBody::getAtomPos(Vector3d& pos, unsigned int index) {
if (index < atoms_.size()) {
Vector3d ref = body2Lab(refCoords_[index]);
pos = getPos() + ref;
return true;
} else {
snprintf(
painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"%d is an invalid index. ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %r12d
movq 0x130(%rdi), %rbx
subq 0x128(%rdi), %rbx
sarq $0x3, %rbx
cmpq %r12, %rbx
jbe 0xadd37
movq %rsi, %r14
movq %rdi, %r15
leaq (%r12,%r12,2), %rdx
shlq $0x3, %rdx
addq 0x158(%rdi), %rdx
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
callq 0xaeeec
movq... | /OpenMD[P]OpenMD/src/primitives/RigidBody.cpp |
OpenMD::RigidBody::addAtom(OpenMD::Atom*, OpenMD::AtomStamp*) | void RigidBody::addAtom(Atom* at, AtomStamp* ats) {
Vector3d coords;
Vector3d euler;
atoms_.push_back(at);
if (!ats->havePosition()) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"RigidBody error.\n"
"\tAtom %s does not have a position specified.\n"
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq 0x130(%rdi), %rsi
cmpq 0x138(%rdi), %rsi
je 0xae42f
movq %rax, (%rsi)
addq $0x8, 0x130(%rbx)
jmp 0xae440
leaq 0x128(%rbx), %rdi
leaq 0x8(%rsp), %rdx... | /OpenMD[P]OpenMD/src/primitives/RigidBody.cpp |
OpenMD::StuntDouble::body2Lab(OpenMD::Vector3<double> const&) | Vector3d body2Lab(const Vector3d& v) { return getA().transpose() * v; } | pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0x512f8
xorpd %xmm0, %xmm0
leaq 0x20(%rsp), %rax
movapd %xmm0, 0x30(%rax)
movapd %xmm0, 0x20(%rax)
movapd %xmm0, 0x10(%rax)
movapd %xmm0, (%rax)
movq $0x0, 0x40(%rax)
xorl %ecx, %ecx
movq %rax, ... | /OpenMD[P]OpenMD/src/primitives/StuntDouble.hpp |
OpenMD::AtomStamp::AtomStamp(int) | AtomStamp::AtomStamp(int index) :
havePos_(false), haveOrt_(false), hasOverride_(false), index_(index) {
DefineParameter(Type, "type");
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rcx
xorl %eax, %eax
movl %eax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
leaq 0x40(%rdi), %rcx
movl %eax, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movq %rcx, 0x50(%r... | /OpenMD[P]OpenMD/src/types/AtomStamp.cpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> OpenMD::containerToString<std::vector<double, std::allocator<double>>>(std::vector<double, std::allocator<double>> const&) | std::string containerToString(const ContainerType& cont) {
std::ostringstream oss;
oss << "(";
typename ContainerType::const_iterator i = cont.begin();
if (i != cont.end()) {
oss << *i;
++i;
}
for (; i != cont.end(); ++i) {
oss << ", ";
oss << *i;
}
oss << ")";
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x125e0
leaq 0x3999e(%rip), %rsi # 0xeaf1a
movl $0x1, %edx
movq %r15, %rdi
callq 0x12500
movq (%r14), %r13
cmpq 0x8(%r14), %r13
je 0xb15e0
movs... | /OpenMD[P]OpenMD/src/utils/StringUtils.hpp |
OpenMD::AtomType::copyAllData(OpenMD::AtomType*) | void AtomType::copyAllData(AtomType* orig) {
// makes an exact replica of another atom type down to the
// atom ID and any base attachments it may have.
// use with caution!
hasBase_ = orig->hasBase_;
base_ = orig->base_;
mass_ = orig->mass_;
name_ = string(orig->name_);
ident_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
movb 0x38(%rsi), %al
movb %al, 0x38(%rdi)
movq 0x40(%rsi), %rax
movq %rax, 0x40(%rdi)
movsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x10(%rdi)
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x18(%rsi), %rsi
movq... | /OpenMD[P]OpenMD/src/types/AtomType.cpp |
OpenMD::AtomType::isFixedCharge() | bool AtomType::isFixedCharge() { return hasProperty("Charge"); } | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3dfaf(%rip), %rsi # 0xf0023
leaq 0x3dfae(%rip), %rdx # 0xf0029
movq %rsp, %r14
movq %r14, %rdi
callq 0x1eea8
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb1ca0
movl %eax, %ebx
movq (%rsp), %rdi
cmpq ... | /OpenMD[P]OpenMD/src/types/AtomType.cpp |
OpenMD::AtomType::isFluctuatingCharge() | bool AtomType::isFluctuatingCharge() { return hasProperty("FlucQ"); } | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x35dfe(%rip), %rsi # 0xe7ef0
leaq 0x35dfc(%rip), %rdx # 0xe7ef5
movq %rsp, %r14
movq %r14, %rdi
callq 0x1eea8
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb1ca0
movl %eax, %ebx
movq (%rsp), %rdi
cmpq ... | /OpenMD[P]OpenMD/src/types/AtomType.cpp |
OpenMD::AtomType::allYourBase() | std::vector<AtomType*> AtomType::allYourBase() {
std::vector<AtomType*> myChain;
if (hasBase_) {
myChain = base_->allYourBase();
myChain.insert(myChain.begin(), this);
} else {
myChain.push_back(this);
}
return myChain;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpb $0x1, 0x38(%rsi)
jne 0xb24c4
movq 0x40(%r14), %rsi
movq %rsp, %rdi
callq 0xb243a
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%rsp), %r... | /OpenMD[P]OpenMD/src/types/AtomType.cpp |
OpenMD::AtomType::~AtomType() | virtual ~AtomType() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x78121(%rip), %rax # 0x12a818
movq %rax, (%rdi)
leaq 0x75c7f(%rip), %rax # 0x128380
movq %rax, 0xc0(%rdi)
addq $0xc8, %rdi
callq 0x23d9e
leaq 0x90(%rbx), %rdi
callq 0xb2772
leaq 0x60(%rbx), %rdi
callq 0xb27ea
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0xb273e
movq 0x58(%rbx), %rs... | /OpenMD[P]OpenMD/src/types/AtomType.hpp |
OpenMD::BendStamp::~BendStamp() | BendStamp::~BendStamp() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x772d5(%rip), %rax # 0x12a858
movq %rax, (%rdi)
movq 0xd8(%rdi), %rdi
testq %rdi, %rdi
je 0xb35a1
movq 0xe8(%rbx), %rsi
subq %rdi, %rsi
callq 0x12430
movq 0xb8(%rbx), %rdi
leaq 0xc8(%rbx), %rax
cmpq %rax, %rdi
je 0xb35bf
movq (%rax), %rsi
incq %rsi
callq 0x12430
movq 0x98(%rbx), %rd... | /OpenMD[P]OpenMD/src/types/BendStamp.cpp |
OpenMD::BendStamp::validate() | void BendStamp::validate() {
DataHolder::validate();
CheckParameter(GhostVectorSource, isNonNegative());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x60442
cmpb $0x0, 0x92(%rbx)
jne 0xb3721
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x9ca34
movl 0x94(%rbx), %ebp
movq (%r14), %rdi
leaq 0x18(%rsp), %r15
cmpq %r15, %rdi
je 0xb3684
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x12430
testl %eb... | /OpenMD[P]OpenMD/src/types/BendStamp.cpp |
OpenMD::BendTypeParser::BendTypeParser() | BendTypeParser::BendTypeParser() {
stringToEnumMap_["Harmonic"] = btHarmonic;
stringToEnumMap_["GhostBend"] = btGhostBend;
stringToEnumMap_["UreyBradley"] = btUreyBradley;
stringToEnumMap_["Cubic"] = btCubic;
stringToEnumMap_["Quartic"] = btQuartic;
stringToEnumMap_["Polynomi... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x36547(%rip), %rsi # 0xe9e28
leaq 0x36548(%rip), %rdx... | /OpenMD[P]OpenMD/src/types/BendTypeParser.cpp |
OpenMD::BendTypeParser::parseTypeAndPars(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<double, std::allocator<double>>) | BendType* BendTypeParser::parseTypeAndPars(const std::string& type,
std::vector<RealType> pars) {
std::string line(type);
std::vector<RealType>::iterator it;
for (it = pars.begin(); it != pars.end(); ++it) {
line.append("\t");
line.append(std::to_str... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, 0x40(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %rdi
movq %rax, %rsi
callq 0x185b0
movq (%r14), %r15
cmpq 0x8(%r14), %r15
je 0xb3c68
mov... | /OpenMD[P]OpenMD/src/types/BendTypeParser.cpp |
OpenMD::QuarticBendType::calcForce(double, double&, double&) | virtual void calcForce(RealType theta, RealType& V, RealType& dVdTheta) {
RealType delta = theta - theta0_;
RealType delta2 = delta * delta;
RealType delta3 = delta2 * delta;
RealType delta4 = delta3 * delta;
V = k0_ + k1_ * delta + k2_ * delta2 + k3_ * delta3 + k4_ * delta4;
dVdTh... | subsd 0x8(%rdi), %xmm0
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
movapd %xmm0, %xmm1
mulsd %xmm2, %xmm1
movapd %xmm0, %xmm3
movsd 0x28(%rdi), %xmm4
mulsd %xmm0, %xmm4
addsd 0x30(%rdi), %xmm4
mulsd %xmm1, %xmm3
movsd 0x20(%rdi), %xmm5
mulsd %xmm2, %xmm5
addsd %xmm4, %xmm5
movsd 0x18(%rdi), %xmm4
mulsd %xmm1, %xmm4
mulsd 0x... | /OpenMD[P]OpenMD/src/types/QuarticBendType.hpp |
OpenMD::Polynomial<double>::evaluateDerivative(double const&) | Real evaluateDerivative(const Real& x) {
Real result = Real();
ExponentType exponent;
CoefficientType coefficient;
for (iterator i = polyPairMap_.begin(); i != polyPairMap_.end(); ++i) {
exponent = i->first;
coefficient = i->second;
result += fastpow(x, exponent - 1) ... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
addq $0x8, %rbx
cmpq %rbx, %rax
je 0xb4cd8
movsd (%rsi), %xmm1
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movsd %xmm1, 0x8(%rsp)
movl 0x20(%rax), %ecx
movsd 0x3238b(%rip), %xmm0 # 0xe7018
cmpl $0x2, %ecx
jl 0xb4ca5
leal -0x1(%rcx), %edx
movsd 0x3237b(%rip... | /OpenMD[P]OpenMD/src/math/Polynomial.hpp |
OpenMD::BondStamp::BondStamp() | BondStamp::BondStamp() : hasOverride_(false) {
DefineOptionalParameterWithDefaultValue(BondOrder, "bondOrder", 1);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rcx
xorl %eax, %eax
movl %eax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
leaq 0x40(%rdi), %rcx
movl %eax, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movq %r... | /OpenMD[P]OpenMD/src/types/BondStamp.cpp |
OpenMD::BondStamp::~BondStamp() | BondStamp::~BondStamp() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x75495(%rip), %rax # 0x12ab68
movq %rax, (%rdi)
movq 0xd0(%rdi), %rdi
testq %rdi, %rdi
je 0xb56f1
movq 0xe0(%rbx), %rsi
subq %rdi, %rsi
callq 0x12430
movq 0xb0(%rbx), %rdi
leaq 0xc0(%rbx), %rax
cmpq %rax, %rdi
je 0xb570f
movq (%rax), %rsi
incq %rsi
callq 0x12430
leaq 0x73b0a(%rip), ... | /OpenMD[P]OpenMD/src/types/BondStamp.cpp |
OpenMD::operator<<(std::ostream&, OpenMD::PolynomialBondType&) | std::ostream& operator<<(std::ostream& os, PolynomialBondType& pbt) {
DoublePolynomial::const_iterator i;
i = pbt.polynomial_.begin();
if (i == pbt.polynomial_.end()) {
os << "This PolynomialBondType contains nothing" << std::endl;
return os;
}
os << "This PolynomialBondType contains ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rsi), %r15
leaq 0x18(%rsi), %rbp
cmpq %rbp, %r15
je 0xb59a3
movq %rsi, %r14
leaq 0x391f0(%rip), %rsi # 0xeeab5
movl $0x2d, %edx
movq %rbx, %rdi
callq 0x12500
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %r... | /OpenMD[P]OpenMD/src/types/PolynomialBondType.hpp |
OpenMD::MorseBondType::calcForce(double, double&, double&) | virtual void calcForce(RealType r, RealType& V, RealType& dVdr) {
RealType dr, eterm, eterm2;
dr = r - r0;
eterm = exp(-beta * dr);
eterm2 = eterm * eterm;
V = De * (1 - 2.0 * eterm + eterm2);
dVdr = 2.0 * De * beta * (eterm - eterm2);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
subsd 0x8(%rdi), %xmm0
movsd 0x18(%rdi), %xmm1
xorpd 0x31eaa(%rip), %xmm1 # 0xe8780
mulsd %xmm1, %xmm0
callq 0x12870
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm0, %xmm2
addsd %xmm0, %xmm2
movsd 0x30721(%rip), %xmm3 # 0xe7018
s... | /OpenMD[P]OpenMD/src/types/MorseBondType.hpp |
OpenMD::ConstraintStamp::ConstraintStamp() | ConstraintStamp::ConstraintStamp() {
DefineParameter(ConstrainedDistance, "constrainedDistance");
DefineOptionalParameterWithDefaultValue(PrintConstraintForce,
"printConstraintForce", false);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rcx
xorl %eax, %eax
movl %eax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
leaq 0x40(%rdi), %rcx
movl %eax, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movq %r... | /OpenMD[P]OpenMD/src/types/ConstraintStamp.cpp |
OpenMD::CutoffGroupStamp::~CutoffGroupStamp() | int getMemberAt(int index) { return members_[index]; } | pushq %rbx
movq %rdi, %rbx
leaq 0x7300d(%rip), %rax # 0x12ad50
movq %rax, (%rdi)
movq 0x68(%rdi), %rdi
testq %rdi, %rdi
je 0xb7d5b
movq 0x78(%rbx), %rsi
subq %rdi, %rsi
callq 0x12430
leaq 0x715a6(%rip), %rax # 0x129308
movq %rax, (%rbx)
leaq 0x38(%rbx), %rdi
callq 0x1f434
leaq 0x8(%rbx), %rdi
callq 0x6055c
movl... | /OpenMD[P]OpenMD/src/types/CutoffGroupStamp.hpp |
OpenMD::DirectionalAdapter::makeDirectional(OpenMD::SquareMatrix3<double>) | void DirectionalAdapter::makeDirectional(Mat3x3d I) {
if (isDirectional()) { at_->removeProperty(DirectionalTypeID); }
DirectionalAtypeParameters directionalParam {};
directionalParam.I = I;
at_->addProperty(std::make_shared<DirectionalAtypeData>(DirectionalTypeID,
... | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x781bf(%rip), %rsi # 0x1301e0
callq 0xb1ca0
testb %al, %al
je 0xb8039
movq (%rbx), %rdi
leaq 0x781ac(%rip), %rsi # 0x1301e0
callq 0xb1c5a
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rax
movaps %xmm0, 0x30(%rax)
movaps %xmm0,... | /OpenMD[P]OpenMD/src/types/DirectionalAdapter.cpp |
OpenMD::EAMAdapter::getRhoSpline() | CubicSplinePtr EAMAdapter::getRhoSpline() {
FuncflParameters funcflParam = getFuncflParam();
int nr = funcflParam.nr;
RealType dr = funcflParam.dr;
std::vector<RealType> rvals;
for (int i = 0; i < nr; i++)
rvals.push_back(RealType(i) * dr);
CubicSpl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0xb84f8
movl 0x20(%r14), %ebp
movsd 0x28(%r14), %xmm0
movsd %xmm0, 0x28(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
testl %ebp, %ebp
jle 0xb8cc8
xorl %r12d, %r12d
m... | /OpenMD[P]OpenMD/src/types/EAMAdapter.cpp |
OpenMD::EAMAdapter::makeOxygenFuncfl(double, double, double, double, double, double, double, double, double, double, std::vector<double, std::allocator<double>>) | void EAMAdapter::makeOxygenFuncfl(RealType re, RealType fe, RealType alpha,
RealType beta, RealType A, RealType B,
RealType kappa, RealType lambda,
RealType drho, RealType nrho,
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x250, %rsp # imm = 0x250
movq %rsi, %r14
movsd %xmm7, 0x58(%rsp)
movsd %xmm6, 0x50(%rsp)
movsd %xmm5, 0x48(%rsp)
movsd %xmm4, 0x40(%rsp)
movsd %xmm3, 0x38(%rsp)
movsd %xmm2, 0x30(%rsp)
movsd %xmm1, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
movq %rdi, %rb... | /OpenMD[P]OpenMD/src/types/EAMAdapter.cpp |
OpenMD::EAMAdapter::get_fe() | RealType EAMAdapter::get_fe() {
ZhouParameters zhouParam = getZhouParam();
return zhouParam.fe;
} | pushq %rbx
subq $0x120, %rsp # imm = 0x120
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xb8798
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
callq 0x78426
movq -0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xbacec
movq 0xf8(%rsp), %rsi
subq %rdi, %rsi
callq 0x12... | /OpenMD[P]OpenMD/src/types/EAMAdapter.cpp |
OpenMD::EAMAdapter::getB() | RealType EAMAdapter::getB() {
ZhouParameters zhouParam = getZhouParam();
return zhouParam.B;
} | pushq %rbx
subq $0x120, %rsp # imm = 0x120
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xb8798
movsd 0x30(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
callq 0x78426
movq -0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xbb03e
movq 0xf8(%rsp), %rsi
subq %rdi, %rsi
callq 0x1... | /OpenMD[P]OpenMD/src/types/EAMAdapter.cpp |
OpenMD::EAMAdapter::getGamma() | RealType EAMAdapter::getGamma() {
ZhouParameters zhouParam = getZhouParam();
return zhouParam.gamma;
} | pushq %rbx
subq $0x120, %rsp # imm = 0x120
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xb8798
movsd 0xb0(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
callq 0x78426
movq -0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xbb23f
movq 0xf8(%rsp), %rsi
subq %rdi, %rsi
callq 0x1... | /OpenMD[P]OpenMD/src/types/EAMAdapter.cpp |
OpenMD::EAMAdapter::getOrhoLimits() | std::vector<RealType> EAMAdapter::getOrhoLimits() {
ZhouParameters zhouParam = getZhouParam();
return zhouParam.OrhoLimits;
} | pushq %r14
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb8798
leaq 0xc8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4c696
leaq 0xf8(%rsp), %r14
movq %r14, %rdi
callq 0x78426
movq -0x18(%r14), %rdi
testq %rdi, %rdi
je 0xbb9c2
movq 0xf0(%rsp), %rsi
subq %rdi, %rsi
callq 0x124... | /OpenMD[P]OpenMD/src/types/EAMAdapter.cpp |
OpenMD::FixedChargeAdapter::makeFixedCharge(double) | void FixedChargeAdapter::makeFixedCharge(RealType charge) {
if (isFixedCharge()) { at_->removeProperty(FCtypeID); }
FixedChargeAtypeParameters fcParam {};
fcParam.charge = charge;
at_->addProperty(std::make_shared<FixedChargeAtypeData>(FCtypeID, fcParam));
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movsd %xmm0, 0x28(%rsp)
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x73804(%rip), %rsi # 0x130280
callq 0xb1ca0
testb %al, %al
je 0xbca94
movq (%rbx), %rdi
leaq 0x737f1(%rip), %rsi # 0x130280
callq 0xb1c5a
leaq 0x40(%rsp), %r8
movsd 0x28(%rsp), %xmm0
movsd %xmm0, (%r8)
movq (%... | /OpenMD[P]OpenMD/src/types/FixedChargeAdapter.cpp |
bool OpenMD::hasDuplicateElement<std::vector<int, std::allocator<int>>>(std::vector<int, std::allocator<int>> const&) | bool hasDuplicateElement(const ContainerType& cont) {
ContainerType tmp = cont;
std::sort(tmp.begin(), tmp.end());
tmp.erase(std::unique(tmp.begin(), tmp.end()), tmp.end());
return tmp.size() != cont.size();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1d5c6
movq (%r15), %rbx
movq 0x8(%r15), %r15
cmpq %r15, %rbx
je 0xc2c33
movq %r15, %rax
subq %rbx, %rax
sarq $0x2, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
m... | /OpenMD[P]OpenMD/src/types/FragmentStamp.cpp |
OpenMD::InversionTypeParser::InversionTypeParser() | InversionTypeParser::InversionTypeParser() {
stringToEnumMap_["AmberImproper"] = itAmberImproper;
stringToEnumMap_["ImproperCosine"] = itImproperCosine;
stringToEnumMap_["Harmonic"] = itHarmonic;
stringToEnumMap_["CentralAtomHeight"] = itCentralAtomHeight;
stringToEnumMap_["Dreiding"... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x24778(%rip), %rsi # 0xe9eb7
leaq 0x2477e(%rip), %rdx... | /OpenMD[P]OpenMD/src/types/InversionTypeParser.cpp |
OpenMD::AmberImproperTorsionType::AmberImproperTorsionType(double) | AmberImproperTorsionType(RealType v2) : PolynomialInversionType(), v2_(v2) {
// convert AmberImproper Torsion Type to Polynomial Inversion type
RealType c0 = v2;
RealType c2 = -v2;
setCoefficient(0, c0);
setCoefficient(2, c2);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
xorl %ecx, %ecx
movl %ecx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
leaq 0x65260(%rip), %rax # 0x12b218
movq %rax, (%rdi)
movaps %xmm0, 0x10(%rsp)
movsd %xmm0, 0x38(%rdi)... | /OpenMD[P]OpenMD/src/types/AmberImproperTorsionType.hpp |
OpenMD::LennardJonesAdapter::getLJParam() | LJAtypeParameters LennardJonesAdapter::getLJParam() {
if (!isLennardJones()) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"LennardJonesAdapter::getLJParam was passed an atomType (%s)\n"
"\tthat does not appear to be a Lennard-Jones atom.\n",
at_->getName()... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x69db9(%rip), %rsi # 0x1303d8
callq 0xb1ca0
testb %al, %al
jne 0xc668a
movq (%r14), %rsi
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0xb1e7a
movq (%r12), %rcx
leaq 0x66911(%rip), %r15 # 0x12cf54
... | /OpenMD[P]OpenMD/src/types/LennardJonesAdapter.cpp |
OpenMD::MoleculeStamp::~MoleculeStamp() | MoleculeStamp::~MoleculeStamp() {
Utils::deletePointers(atomStamps_);
Utils::deletePointers(bondStamps_);
Utils::deletePointers(bendStamps_);
Utils::deletePointers(torsionStamps_);
Utils::deletePointers(inversionStamps_);
Utils::deletePointers(rigidBodyStamps_);
Utils::deletePointers(cutoffG... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x64229(%rip), %rax # 0x12b388
movq %rax, (%rdi)
movq 0xe8(%rdi), %r14
movq 0xf0(%rdi), %r15
cmpq %r15, %r14
je 0xc7189
movq (%r14), %rdi
testq %rdi, %rdi
je 0xc7183
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0xc7170
movq 0x118(%rbx), %r14
movq 0x120... | /OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp |
OpenMD::MoleculeStamp::addBendStamp(OpenMD::BendStamp*) | bool MoleculeStamp::addBendStamp(BendStamp* bend) {
bendStamps_.push_back(bend);
return true;
} | pushq %rax
movq %rsi, %rax
movq %rsi, (%rsp)
movq 0x138(%rdi), %rsi
cmpq 0x140(%rdi), %rsi
je 0xc7685
movq %rax, (%rsi)
addq $0x8, 0x138(%rdi)
jmp 0xc7694
addq $0x130, %rdi # imm = 0x130
movq %rsp, %rdx
callq 0xc3416
movb $0x1, %al
popq %rcx
retq
| /OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp |
OpenMD::MoleculeStamp::checkCutoffGroups() | void MoleculeStamp::checkCutoffGroups() {
std::vector<AtomStamp*>::iterator ai;
std::vector<int>::iterator fai;
// add all atoms into freeAtoms_ set
for (ai = atomStamps_.begin(); ai != atomStamps_.end(); ++ai) {
freeAtoms_.push_back((*ai)->getIndex());
}
for (std::size_t i = 0; i < getN... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rdi, %rbx
movq 0xe8(%rdi), %r12
movq 0xf0(%rdi), %rax
cmpq %rax, %r12
je 0xcb677
leaq 0x100(%rbx), %r14
leaq 0x40(%rsp), %r15
movq (%r12), %rcx
movl 0xf4(%rcx), %ecx
movl %ecx, 0x40(%rsp)
movq 0x108(%rbx),... | /OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp |
bool OpenMD::MoleculeStamp::addIndexSensitiveStamp<std::vector<OpenMD::AtomStamp*, std::allocator<OpenMD::AtomStamp*>>, OpenMD::AtomStamp>(std::vector<OpenMD::AtomStamp*, std::allocator<OpenMD::AtomStamp*>>&, OpenMD::AtomStamp*) | bool addIndexSensitiveStamp(Cont& cont, T* stamp) {
// typename Cont::iterator i;
unsigned int index = stamp->getIndex();
bool ret = false;
size_t size = cont.size();
if (size >= index + 1) {
if (cont[index] != NULL) {
ret = false;
} else {
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl 0xf4(%rdx), %r15d
movq (%rsi), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
movq %rax, %rcx
sarq $0x3, %rcx
leal 0x1(%r15), %edx
cmpq %rdx, %rcx
jae 0xcc384
negq %rcx
leaq (%r15,%rcx), %rdx
incq %rdx
leaq 0x8(%rsp), %rcx
movq $0x0, (%rc... | /OpenMD[P]OpenMD/src/types/MoleculeStamp.hpp |
bool OpenMD::MoleculeStamp::addIndexSensitiveStamp<std::vector<OpenMD::RigidBodyStamp*, std::allocator<OpenMD::RigidBodyStamp*>>, OpenMD::RigidBodyStamp>(std::vector<OpenMD::RigidBodyStamp*, std::allocator<OpenMD::RigidBodyStamp*>>&, OpenMD::RigidBodyStamp*) | bool addIndexSensitiveStamp(Cont& cont, T* stamp) {
// typename Cont::iterator i;
unsigned int index = stamp->getIndex();
bool ret = false;
size_t size = cont.size();
if (size >= index + 1) {
if (cont[index] != NULL) {
ret = false;
} else {
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl 0x68(%rdx), %r15d
movq (%rsi), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
movq %rax, %rcx
sarq $0x3, %rcx
leal 0x1(%r15), %edx
cmpq %rdx, %rcx
jae 0xcc3f9
negq %rcx
leaq (%r15,%rcx), %rdx
incq %rdx
leaq 0x8(%rsp), %rcx
movq $0x0, (%rc... | /OpenMD[P]OpenMD/src/types/MoleculeStamp.hpp |
OpenMD::TorsionStamp::setMembers(std::tuple<int, int, int, int> const&) | void setMembers(const std::tuple<int, int, int, int>& tuple) {
auto [first, second, third, fourth] = tuple;
members_.push_back(first);
members_.push_back(second);
members_.push_back(third);
members_.push_back(fourth);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movups (%rsi), %xmm0
movaps %xmm0, (%rsp)
leaq 0x98(%rdi), %r14
movq 0xa0(%rdi), %rsi
movq 0xa8(%rdi), %rax
cmpq %rax, %rsi
je 0xcc590
movl 0xc(%rsp), %ecx
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xa0(%rbx)
jmp 0xcc5ab
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
call... | /OpenMD[P]OpenMD/src/types/TorsionStamp.hpp |
OpenMD::SimpleTypeData<OpenMD::MultipoleAtypeParameters>::~SimpleTypeData() | SimpleTypeData() : GenericData(), data_(ElemDataType()) {} | movq %rdi, %rax
leaq 0x5c2e4(%rip), %rcx # 0x129470
movq %rcx, (%rdi)
movq 0x8(%rdi), %rdi
addq $0x18, %rax
cmpq %rax, %rdi
je 0xcd1a7
movq (%rax), %rsi
incq %rsi
jmp 0x12430
retq
| /OpenMD[P]OpenMD/src/utils/GenericData.hpp |
OpenMD::NonBondedInteractionType::addProperty(std::shared_ptr<OpenMD::GenericData>) | void NonBondedInteractionType::addProperty(
std::shared_ptr<GenericData> genData) {
properties_.addProperty(genData);
} | pushq %rbx
subq $0x10, %rsp
addq $0x28, %rdi
movq (%rsi), %rax
movq %rax, (%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xcd261
movq 0x5ed65(%rip), %rcx # 0x12bfb8
cmpb $0x0, (%rcx)
je 0xcd25d
incl 0x8(%rax)
jmp 0xcd261
lock
incl 0x8(%rax)
movq %rsp, %rsi
callq 0xd435c
movq 0x8(%rsp), %rdi
te... | /OpenMD[P]OpenMD/src/types/NonBondedInteractionType.cpp |
OpenMD::NodesStamp::~NodesStamp() | NodesStamp() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x5e0e7(%rip), %rax # 0x12b450
movq %rax, (%rdi)
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0xcd384
movq 0x80(%rbx), %rsi
subq %rdi, %rsi
callq 0x12430
leaq 0x5bf7d(%rip), %rax # 0x129308
movq %rax, (%rbx)
leaq 0x38(%rbx), %rdi
callq 0x1f434
addq $0x8, %rbx
movq %rbx, %rdi
popq %r... | /OpenMD[P]OpenMD/src/types/NodesStamp.hpp |
OpenMD::PolarizableAdapter::getPolarizableParam() | PolarizableAtypeParameters PolarizableAdapter::getPolarizableParam() {
if (!isPolarizable()) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"PolarizableAdapter::getPolarizableParam was passed an atomType "
"(%s)\n"
"\tthat does not appear to be a polarizable... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x63166(%rip), %rsi # 0x130580
callq 0xb1ca0
testb %al, %al
jne 0xcd483
movq (%rbx), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0xb1e7a
movq (%r15), %rcx
leaq 0x5fb17(%rip), %r14 # 0x12cf54
leaq 0x22e83(%rip), %rdx ... | /OpenMD[P]OpenMD/src/types/PolarizableAdapter.cpp |
OpenMD::RestraintStamp::RestraintStamp() | RestraintStamp::RestraintStamp() {
DefineParameter(Type, "restraintType");
DefineOptionalParameter(MolIndex, "molIndex");
DefineOptionalParameter(ObjectSelection, "objectSelection");
DefineOptionalParameter(DisplacementSpringConstant,
"displacementSpringConstant");
Defin... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rdi, %rbx
leaq 0x10(%rdi), %rcx
xorl %eax, %eax
movl %eax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
leaq 0x40(%rdi), %rcx
movl %eax, 0x40(%rdi)
mov... | /OpenMD[P]OpenMD/src/types/RestraintStamp.cpp |
OpenMD::RestraintStamp::~RestraintStamp() | RestraintStamp::~RestraintStamp() {} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x5c8fd(%rip), %rax # 0x12b518
movq %rax, (%rdi)
leaq 0x5a5fb(%rip), %r14 # 0x129220
movq %r14, 0x330(%rdi)
movq 0x338(%rdi), %rdi
leaq 0x348(%rbx), %rax
cmpq %rax, %rdi
je 0xcec4a
movq (%rax), %rsi
incq %rsi
callq 0x12430
movq %r14, 0x2f8(%rbx)
movq 0x300(%... | /OpenMD[P]OpenMD/src/types/RestraintStamp.cpp |
OpenMD::RestraintStamp::validate() | void RestraintStamp::validate() {
DataHolder::validate();
CheckParameter(
Type, isEqualIgnoreCase("Object") || isEqualIgnoreCase("Molecular"));
CheckParameter(DisplacementSpringConstant, isNonNegative());
CheckParameter(AbsoluteSpringConstant, isNonNegative());
CheckParameter(TwistSpringCons... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, %rbx
callq 0x60442
cmpb $0x0, 0x92(%rbx)
jne 0xcf366
leaq 0x1b8(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x216f5(%rip), %rsi # 0xf05b8
leaq 0x216f4(%rip), %rdx # 0xf05be
leaq 0x1a8(%rsp), %rdi
... | /OpenMD[P]OpenMD/src/types/RestraintStamp.cpp |
OpenMD::RigidBodyStamp::~RigidBodyStamp() | int getIndex() { return index_; } | pushq %rbx
movq %rdi, %rbx
leaq 0x5baf1(%rip), %rax # 0x12b558
movq %rax, (%rdi)
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0xcfa82
movq 0x80(%rbx), %rsi
subq %rdi, %rsi
callq 0x12430
leaq 0x5987f(%rip), %rax # 0x129308
movq %rax, (%rbx)
leaq 0x38(%rbx), %rdi
callq 0x1f434
addq $0x8, %rbx
movq %rbx, %rdi
popq %r... | /OpenMD[P]OpenMD/src/types/RigidBodyStamp.hpp |
OpenMD::SimpleTypeData<OpenMD::StickyAtypeParameters>::~SimpleTypeData() | SimpleTypeData() : GenericData(), data_(ElemDataType()) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x59397(%rip), %rax # 0x129470
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0xd00f4
movq (%rax), %rsi
incq %rsi
callq 0x12430
movl $0x68, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x12430
nop
| /OpenMD[P]OpenMD/src/utils/GenericData.hpp |
OpenMD::SuttonChenAdapter::getSuttonChenParam() | SCAtypeParameters SuttonChenAdapter::getSuttonChenParam() {
if (!isSuttonChen()) {
snprintf(
painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"SuttonChenAdapter::getSuttonChenParam was passed an atomType (%s)\n"
"\tthat does not appear to be a Sutton-Chen atom.\n",
at_->getNa... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x60571(%rip), %rsi # 0x1306a0
callq 0xb1ca0
testb %al, %al
jne 0xd019a
movq (%r14), %rsi
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0xb1e7a
movq (%r12), %rcx
leaq 0x5ce01(%rip), %r15 # 0x12cf54
... | /OpenMD[P]OpenMD/src/types/SuttonChenAdapter.cpp |
OpenMD::TorsionStamp::TorsionStamp() | TorsionStamp::TorsionStamp() : hasOverride_(false) {
DefineOptionalParameter(GhostVectorSource, "ghostVectorSource");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rcx
xorl %eax, %eax
movl %eax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
leaq 0x40(%rdi), %rcx
movl %eax, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movq %r... | /OpenMD[P]OpenMD/src/types/TorsionStamp.cpp |
OpenMD::operator<<(std::ostream&, OpenMD::HarmonicTorsionType&) | std::ostream& operator<<(std::ostream& os, HarmonicTorsionType& htt) {
os << "This HarmonicTorsionType has below form:" << std::endl;
os << htt.d0_ << "*(phi - " << htt.phi0_ << ")/2" << std::endl;
return os;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1ff0a(%rip), %rsi # 0xf0a00
movl $0x28, %edx
callq 0x12500
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x12400
movsbl %al, %esi
movq %rbx, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x122b0
movsd 0x8(%r14), %xmm... | /OpenMD[P]OpenMD/src/types/HarmonicTorsionType.hpp |
OpenMD::operator<<(std::ostream&, OpenMD::OplsTorsionType&) | std::ostream& operator<<(std::ostream& os, OplsTorsionType& ott) {
os << "This OplsTorsionType has below form:" << std::endl;
os << ott.v1_ << "/2*(1+cos(phi))"
<< " + " << ott.v2_ << "/2*(1-cos(2*phi))"
<< " + " << ott.v3_ << "/2*(1+cos(3*phi))" << std::endl;
return os;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1fe73(%rip), %rsi # 0xf0a29
movl $0x24, %edx
callq 0x12500
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x12400
movsbl %al, %esi
movq %rbx, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x122b0... | /OpenMD[P]OpenMD/src/types/OplsTorsionType.hpp |
OpenMD::TorsionTypeParser::TorsionTypeParser() | TorsionTypeParser::TorsionTypeParser() : trans180_(true) {
stringToEnumMap_["GhostTorsion"] = ttGhostTorsion;
stringToEnumMap_["Cubic"] = ttCubic;
stringToEnumMap_["Quartic"] = ttQuartic;
stringToEnumMap_["Polynomial"] = ttPolynomial;
stringToEnumMap_["Charmm"] = ttCharmm;
st... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movb $0x1, 0x30(%rdi)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x190f4(%rip), %rsi # 0xe9f17
le... | /OpenMD[P]OpenMD/src/types/TorsionTypeParser.cpp |
OpenMD::TorsionTypeParser::parseTypeAndPars(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<double, std::allocator<double>>) | TorsionType* TorsionTypeParser::parseTypeAndPars(const std::string& type,
std::vector<RealType> pars) {
std::string line(type);
std::vector<RealType>::iterator it;
for (it = pars.begin(); it != pars.end(); ++it) {
line.append("\t");
line.append... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, 0x40(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %rdi
movq %rax, %rsi
callq 0x185b0
movq (%r14), %r15
cmpq 0x8(%r14), %r15
je 0xd1122
mov... | /OpenMD[P]OpenMD/src/types/TorsionTypeParser.cpp |
OpenMD::TorsionTypeParser::parseLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | TorsionType* TorsionTypeParser::parseLine(const std::string& line) {
StringTokenizer tokenizer(line);
TorsionType* torsionType = NULL;
int nTokens = tokenizer.countTokens();
if (nTokens < 1) {
throw OpenMDException("TorsionTypeParser: Not enough tokens");
}
TorsionTypeEnum t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x17109(%rip), %rsi # 0xe82da
leaq 0x17107(%rip), %rdx # 0xe82df
movq %rsp, %rdi
callq 0x1eea8
leaq 0x90(%rsp), %rdi
movq %rsp, %rdx
movq %r14, %rs... | /OpenMD[P]OpenMD/src/types/TorsionTypeParser.cpp |
OpenMD::TrappeTorsionType::TrappeTorsionType(double, double, double, double, bool) | TrappeTorsionType(RealType c0, RealType c1, RealType c2, RealType c3,
bool trans180) :
PolynomialTorsionType(),
c0_(c0), c1_(c1), c2_(c2), c3_(c3) {
// convert Trappe Torsion Type to Polynomial Torsion type
RealType b0 = c0 + c1 + 2.0 * c2 + c3;
RealType b1 = c1 ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x10(%rdi), %rcx
xorl %eax, %eax
movl %eax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
leaq 0x5981c(%rip), %rcx # 0x12b7f8
movq %rcx, (%rdi)
movsd %xmm0, 0x18(%rsp)
movsd %x... | /OpenMD[P]OpenMD/src/types/TrappeTorsionType.hpp |
OpenMD::HarmonicTorsionType::calcForce(double, double&, double&) | virtual void calcForce(RealType cosPhi, RealType& V, RealType& dVdCosPhi) {
// check roundoff
if (cosPhi > 1.0) {
cosPhi = 1.0;
} else if (cosPhi < -1.0) {
cosPhi = -1.0;
}
RealType phi = acos(cosPhi);
RealType sinPhi = sqrt(1.0 - cosPhi * cosPhi);
// trick... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movsd 0x14d1e(%rip), %xmm2 # 0xe7018
ucomisd %xmm2, %xmm0
ja 0xd2316
movsd 0x16498(%rip), %xmm1 # 0xe87a0
ucomisd %xmm0, %xmm1
movapd %xmm0, %xmm2
jbe 0xd2316
movapd %xmm1, %xmm2
movsd %xmm2, 0x8(%rsp)
movapd %xmm2, ... | /OpenMD[P]OpenMD/src/types/HarmonicTorsionType.hpp |
OpenMD::UFFAdapter::getUFFParam() | UFFAtypeParameters UFFAdapter::getUFFParam() {
if (!isUFF()) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"UFFAdapter::getUFFParam was passed an atomType (%s)\n"
"\tthat does not appear to be a UFF atom.\n",
at_->getName().c_str());
painCave.severity... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x5de45(%rip), %rsi # 0x130738
callq 0xb1ca0
testb %al, %al
jne 0xd295e
movq (%r14), %rsi
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0xb1e7a
movq (%r12), %rcx
leaq 0x5a63d(%rip), %r15 # 0x12cf54
... | /OpenMD[P]OpenMD/src/types/UFFAdapter.cpp |
OpenMD::UFFAdapter::makeUFF(double, double, double, double, double, double, double, double, double, double, double) | void UFFAdapter::makeUFF(RealType r1, RealType theta0, RealType x1,
RealType D1, RealType zeta, RealType Z1, RealType Vi,
RealType Uj, RealType Xi, RealType Hard,
RealType Radius) {
if (isUFF()) { at_->removeProperty(UFFtypeID); }
... | pushq %r14
pushq %rbx
subq $0xc8, %rsp
movsd %xmm7, 0x58(%rsp)
movsd %xmm6, 0x50(%rsp)
movsd %xmm5, 0x48(%rsp)
movsd %xmm4, 0x40(%rsp)
movsd %xmm3, 0x38(%rsp)
movsd %xmm2, 0x30(%rsp)
movsd %xmm1, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x5da8b(%rip), %rsi # 0x130738
callq 0xb1ca0
t... | /OpenMD[P]OpenMD/src/types/UFFAdapter.cpp |
OpenMD::MoLocator::getAtomMass(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, OpenMD::ForceField*) | RealType MoLocator::getAtomMass(const std::string& at, ForceField* myFF) {
RealType mass;
AtomType* atomType = myFF->getAtomType(at);
if (atomType != NULL) {
mass = atomType->getMass();
} else {
mass = 0.0;
std::cerr << "Can not find AtomType: " << at << std::endl;
}
return mas... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x5bb38
testq %rax, %rax
je 0xd40ae
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb1dc8
movq 0x57f33(%rip), %r14 # 0x12bfe8
leaq 0x1cdd6(%rip), %rsi # 0xf0e92
movl $0x17, %edx
movq %r14, %rdi
callq 0x12500
movq (%... | /OpenMD[P]OpenMD/src/utils/MoLocator.cpp |
OpenMD::PropertyMap::removeProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool PropertyMap::removeProperty(const std::string& propName) {
std::map<std::string, std::shared_ptr<GenericData>>::iterator iter;
iter = propMap_.find(propName);
if (iter != propMap_.end()) {
propMap_.erase(iter);
return true;
} else {
// logger.warn("Can not find property with nam... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0xd46da
movq %rax, %r15
addq $0x10, %rbx
cmpq %rbx, %rax
je 0xd44d5
movq %r14, %rdi
movq %r15, %rsi
callq 0xd4966
cmpq %rbx, %r15
setne %al
popq %rbx
popq %r14
popq %r15
retq
nop
| /OpenMD[P]OpenMD/src/utils/PropertyMap.cpp |
OpenMD::PropertyMap::getPropertyNames[abi:cxx11]() | std::vector<std::string> PropertyMap::getPropertyNames() {
std::vector<std::string> propNames;
std::map<std::string, std::shared_ptr<GenericData>>::iterator iter;
for (iter = propMap_.begin(); iter != propMap_.end(); ++iter)
propNames.push_back(iter->first);
return propNames;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x20(%rsi), %r15
addq $0x10, %r14
cmpq %r14, %r15
je 0xd4524
leaq 0x20(%r15), %rsi
movq %rbx, %rdi
callq 0x5e916
movq %r15, %rdi
callq 0x122c0
movq %rax, %r15
cmpq %r14, %rax
jne 0xd4508
m... | /OpenMD[P]OpenMD/src/utils/PropertyMap.cpp |
OpenMD::PropertyMap::hasProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool PropertyMap::hasProperty(const std::string& propName) {
std::map<std::string, std::shared_ptr<GenericData>>::iterator iter;
iter = propMap_.find(propName);
if (iter != propMap_.end())
return true;
else
return false;
} | pushq %rbx
movq %rdi, %rbx
addq $0x8, %rdi
callq 0xd46da
addq $0x10, %rbx
cmpq %rbx, %rax
setne %al
popq %rbx
retq
nop
| /OpenMD[P]OpenMD/src/utils/PropertyMap.cpp |
OpenMD::PropertyMap::getPropertyByName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::shared_ptr<GenericData> PropertyMap::getPropertyByName(
const std::string& propName) {
std::map<std::string, std::shared_ptr<GenericData>>::iterator iter;
iter = propMap_.find(propName);
if (iter != propMap_.end())
return iter->second;
else
return NULL;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsi), %rdi
movq %rdx, %rsi
callq 0xd46da
addq $0x10, %r14
cmpq %r14, %rax
je 0xd45fc
movq 0x40(%rax), %rcx
movq %rcx, (%rbx)
movq 0x48(%rax), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xd4608
movq 0x579c6(%rip), %rcx # 0x12bfb8
cmpb $0x0... | /OpenMD[P]OpenMD/src/utils/PropertyMap.cpp |
OpenMD::StringTokenizer::StringTokenizer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | StringTokenizer::StringTokenizer(const std::string& str,
const std::string& delim) :
tokenString_(str),
delim_(delim), returnTokens_(false), currentPos_(tokenString_.begin()),
end_(tokenString_.end()) {} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x185b0
leaq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x1... | /OpenMD[P]OpenMD/src/utils/StringTokenizer.cpp |
OpenMD::StringTokenizer::StringTokenizer(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, std::__cxx11::basic_string<char... | StringTokenizer::StringTokenizer(std::string::const_iterator& first,
std::string::const_iterator& last,
const std::string& delim) :
tokenString_(first, last),
delim_(delim), returnTokens_(false), currentPos_(tokenString_.begin()),
e... | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq (%rdx), %rdx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
callq 0xd53da
leaq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x185b0
movb $0x0, 0x40(%rbx)
movq (%r... | /OpenMD[P]OpenMD/src/utils/StringTokenizer.cpp |
OpenMD::StringTokenizer::countTokens() | int StringTokenizer::countTokens() {
std::string::const_iterator tmpIter = currentPos_;
int numToken = 0;
while (true) {
// skip delimiter first
while (tmpIter != end_ && isDelimiter(*tmpIter)) {
++tmpIter;
if (returnTokens_) {
// if delimiter i... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x48(%rdi), %r12
cmpq %r12, 0x50(%rdi)
je 0xd4d14
movq %rdi, %r14
leaq 0x20(%rdi), %r15
xorl %ebx, %ebx
movsbl (%r12), %esi
movq %r15, %rdi
xorl %edx, %edx
callq 0x125b0
movq 0x50(%r14), %rcx
cmpq $-0x1, %rax
je 0xd4ce7
incq %r12
movzbl 0x40(%r14), %eax
addl %... | /OpenMD[P]OpenMD/src/utils/StringTokenizer.cpp |
OpenMD::StringTokenizer::nextToken[abi:cxx11]() | std::string StringTokenizer::nextToken() {
std::string result;
if (currentPos_ != end_) {
std::insert_iterator<std::string> insertIter(result, result.begin());
while (currentPos_ != end_ && isDelimiter(*currentPos_)) {
if (returnTokens_) {
*insertIter++ = *currentPos_++;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x48(%rsi), %rax
cmpq 0x50(%rsi), %rax
je 0xd4e4d
movq %rsi, %r14
leaq 0x20(%rsi), %r15
movsbl (%rax), %esi
movq %r15, %rdi
xorl %edx, %edx
callq 0x125b0
cmpq $-... | /OpenMD[P]OpenMD/src/utils/StringTokenizer.cpp |
OpenMD::stripComments(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string stripComments(const std::string& S) {
unsigned int n = S.length();
std::string res;
// Flags to indicate that single line and multpile line comments
// have started or not.
bool s_cmt = false;
bool m_cmt = false;
// Traverse the line
for (unsigned int i = 0; i < n; i++) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rsi), %ebp
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testl %ebp, %ebp
je 0xd5538
movq %rsi, %r14
xorl %eax, %eax
xorl %r12d, %r12d
xorl %esi, %esi
testb $0x1, %al
je 0xd54b7
movl %r12d, %ecx
movq (%... | /OpenMD[P]OpenMD/src/utils/StringUtils.cpp |
OpenMD::OpenMD_itoa[abi:cxx11](int, unsigned int) | std::string OpenMD_itoa(int value, unsigned int base) {
const char digitMap[] = "0123456789abcdef";
std::string buf;
if (base == 0 || base > 16) { return buf; }
if (value == 0) {
buf = "0";
return buf;
}
// Take care negative int:
std::string sign;
int _value = value;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %r14d
movq %rdi, %r15
leaq 0x10(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq $0x0, -0x8(%rbx)
movb $0x0, (%rbx)
leal -0x11(%r14), %eax
cmpl $-0x11, %eax
ja 0xd5797
leaq 0x10(%r15), %rax
movq %rax, (%r15)
movb (%rbx), %al
movb %al, ... | /OpenMD[P]OpenMD/src/utils/StringUtils.cpp |
bool OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<Ope... | bool operator()(DataType data) const {
return cons1_(data) || cons2_(data);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rdi), %r15
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x185b0
movq %r15, %rdi
movq %r12, %rsi... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::... | OrParamConstraint(Cons1T cons1, Cons2T cons2) :
cons1_(cons1), cons2_(cons2) {
std::stringstream iss;
iss << cons1_.getConstraintDescription() << " or "
<< cons2_.getConstraintDescription() << "";
this->description_ = iss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x185b0
leaq 0x20(%rbx), %r14
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0x950fc
leaq 0x660(%rbx), %r12
leaq ... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::Icosahedron::ih(int) | std::vector<Vector3d> Icosahedron::ih(int n) {
if (n < 0) return Points;
if (n == 0) {
// center particle only
Points.push_back(Vector3d(0.0, 0.0, 0.0));
return Points;
}
//
// Generate edge particles
//
for (std::vector<Vector3d>::iterator i = Basis.begin(); i != Basis.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
js 0xdfbd4
je 0xdfbda
movl %edx, %ebp
movq %rbx, 0xf8(%rsp)
movq 0x50(%r14), %rbx
cmpq 0x58(%r14), %rbx
je 0xdf53a
leaq 0x8(%r14), %r15
cvtsi2sd %ebp, %xmm1
leaq ... | /OpenMD[P]OpenMD/src/clusters/Icosahedron.cpp |
OpenMD::Cuboctahedron::Cuboctahedron(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int) | Cuboctahedron::Cuboctahedron(std::string lattice, int cells, int planes) :
lattice_(lattice), L_(cells), M_(planes) {
Basis.clear();
Points.clear();
//
// Initialize Basis vectors.
//
toUpper(lattice);
if (lattice == "BCC") {
Basis.push_back(Vector3d(0.0, 0.0, 0.0));
Basi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
leaq 0x4b848(%rip), %rax # 0x12b9b0
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rax, 0x8(%rdi)
movq (%rsi), %rsi
movq 0x8(%... | /OpenMD[P]OpenMD/src/clusters/Cuboctahedron.cpp |
void OpenMD::DataStorage::internalResize<OpenMD::SquareMatrix3<double>>(std::vector<OpenMD::SquareMatrix3<double>, std::allocator<OpenMD::SquareMatrix3<double>>>&, unsigned long) | void DataStorage::internalResize(std::vector<T>& v, std::size_t newSize) {
std::size_t oldSize = v.size();
if (oldSize == newSize) {
return;
} else if (oldSize < newSize) {
v.insert(v.end(), newSize - oldSize, T());
} else {
typename std::vector<T>::iterator i;
i = v.begin();
... | movq %rdx, %rdi
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
subq %rax, %rdx
movq %rdx, %rcx
sarq $0x3, %rcx
movabsq $-0x71c71c71c71c71c7, %r9 # imm = 0x8E38E38E38E38E39
imulq %rcx, %r9
movq %rdi, %r8
subq %r9, %r8
je 0xe2c80
jbe 0xe2c81
subq $0x48, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, 0x30(%rcx)
movaps %xmm... | /OpenMD[P]OpenMD/src/brains/DataStorage.cpp |
OpenMD::CubicSpline::addPoint(double, double) | void CubicSpline::addPoint(const RealType xp, const RealType yp) {
x_.push_back(xp);
y_.push_back(yp);
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movq 0x30(%rdi), %rsi
cmpq 0x38(%rdi), %rsi
je 0xe3e62
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x30(%rbx)
jmp 0xe3e7c
leaq 0x28(%rbx), %rdi
leaq 0x18(%rsp), %rdx
movsd %xmm1, 0x8(%rsp)
callq 0x4d3b6
movsd 0x8(%rsp), %xmm1... | /OpenMD[P]OpenMD/src/math/CubicSpline.cpp |
OpenMD::CubicSpline::sort_permutation(std::vector<double, std::allocator<double>> const&) const | std::vector<int> CubicSpline::sort_permutation(
const std::vector<double>& v) const {
std::vector<int> p(v.size());
std::iota(p.begin(), p.end(), 0);
std::sort(p.begin(), p.end(), [&v](int a, int b) { return (v[a] < v[b]); });
return p;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rdi, %rbx
movq 0x8(%rdx), %rsi
subq (%rdx), %rsi
sarq $0x3, %rsi
leaq 0xf(%rsp), %rdx
callq 0x1d646
movq (%rbx), %r12
movq 0x8(%rbx), %r14
cmpq %r14, %r12
je 0xe4753
movq %r14, %r13
subq %r12, %r13
leaq -0x4(%r13), %rax
movq %... | /OpenMD[P]OpenMD/src/math/CubicSpline.cpp |
OpenMD::Polynomial<double>::operator+=(OpenMD::Polynomial<double> const&) | PolynomialType& operator+=(const PolynomialType& p) {
typename Polynomial<Real>::const_iterator i;
for (i = p.begin(); i != p.end(); ++i) {
this->addCoefficient(i->first, i->second);
}
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0xe54d6
movl 0x20(%r15), %esi
leaq 0x28(%r15), %rdx
movq %rbx, %rdi
callq 0xe55ee
movq %r15, %rdi
callq 0x12510
movq %rax, %r15
cmpq %r14, %rax
jne 0xe54b6
movq %rbx, %rax
popq %rbx
popq %r14
popq %... | /OpenMD[P]OpenMD/src/math/Polynomial.hpp |
OpenMD::ImproperCosineInversionType::ImproperCosineInversionType(std::vector<OpenMD::ImproperCosineInversionParameter, std::allocator<OpenMD::ImproperCosineInversionParameter>>&) | ImproperCosineInversionType::ImproperCosineInversionType(
std::vector<ImproperCosineInversionParameter>& parameters) {
std::vector<ImproperCosineInversionParameter>::iterator i;
i = std::max_element(parameters.begin(), parameters.end(),
LessThanPeriodicityFunctor());
if (i != ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rsi, %r14
movq %rdi, %r8
leaq 0x10(%rdi), %rax
movl $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
leaq 0x46599(%rip), %rax # 0... | /OpenMD[P]OpenMD/src/types/ImproperCosineInversionType.cpp |
OpenMD::ChebyshevT::GeneratePolynomials(int) | void ChebyshevT::GeneratePolynomials(int maxPower) {
GenerateFirstTwoTerms();
DoublePolynomial twoX;
twoX.setCoefficient(1, 2.0);
// recursive generate the high order term of Chebyshev Polynomials
// Cn+1(x) = Cn(x) * 2x - Cn-1(x)
for (int i = 2; i <= maxPower; ++i) {
DoublePolynomial cn... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %esi, %r14d
movq %rdi, %rbx
callq 0xe5c0c
leaq 0x70(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rsp, %rsi
movl $0x1, (%rsi)
leaq 0x68(%rs... | /OpenMD[P]OpenMD/src/math/ChebyshevT.cpp |
OpenMD::ChebyshevT::GenerateFirstTwoTerms() | void ChebyshevT::GenerateFirstTwoTerms() {
DoublePolynomial t0;
t0.setCoefficient(0, 1.0);
polyList_.push_back(t0);
DoublePolynomial t1;
t1.setCoefficient(1, 1.0);
polyList_.push_back(t1);
} | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x40(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, (%rax)
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x8(%rsp), %rsi
movl %ecx, (%rsi)
leaq 0x38(%rsp), %rdi
callq 0x79754
movabsq $0x3ff0000000000000, %r14 # imm = 0x3FF... | /OpenMD[P]OpenMD/src/math/ChebyshevT.cpp |
OpenMD::ifstrstream::open(char const*, std::_Ios_Openmode, bool) | void ifstrstream::open(const char* filename, std::ios_base::openmode mode,
bool checkFilename) {
if (!isRead) {
#if defined(_MSC_VER)
isRead =
internalOpen(filename, mode | std::ios_base::binary, checkFilename);
#else
isRead = internalOpen(filename, mode, checkFilename... | cmpb $0x0, 0x168(%rdi)
jne 0xe698f
pushq %rbx
movq %rdi, %rbx
xorl %ecx, %ecx
callq 0xe6676
movb %al, 0x168(%rbx)
popq %rbx
retq
| /OpenMD[P]OpenMD/src/io/ifstrstream.cpp |
main | int main(int argc, char** argv) {
// Select robot. Assume Create 2 unless argument says otherwise
create::RobotModel model = create::RobotModel::CREATE_2;
std::string port = "/dev/ttyUSB0";
int baud = 115200;
if (argc > 1 && std::string(argv[1]) == "create1") {
model = create::RobotModel::CREATE_1;
ba... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
movl %edi, %ebp
movq 0x2c5f(%rip), %rax # 0x6fd8
movq 0x10(%rax), %rcx
movq %rcx, 0x30(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x20(%rsp)
leaq 0xc93(%rip), %rsi # 0x5024
leaq 0x38(%rs... | /AutonomyLab[P]libcreate/examples/packets.cpp |
mbedtls_mpi_mul_int | int mbedtls_mpi_mul_int( mbedtls_mpi *X, const mbedtls_mpi *A, mbedtls_mpi_uint b )
{
mbedtls_mpi _B;
mbedtls_mpi_uint p[1];
_B.s = 1;
_B.n = 1;
_B.p = p;
p[0] = b;
return( mbedtls_mpi_mul_mpi( X, A, &_B ) );
} | subq $0x28, %rsp
leaq 0x10(%rsp), %rax
movl $0x1, (%rax)
movq $0x1, 0x8(%rax)
leaq 0x8(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rdx, (%rcx)
movq %rax, %rdx
callq 0xbec3
addq $0x28, %rsp
retq
| /project-everest[P]mbedtls/library/bignum.c |
mbedtls_mpi_cmp_int | int mbedtls_mpi_cmp_int( const mbedtls_mpi *X, mbedtls_mpi_sint z )
{
mbedtls_mpi Y;
mbedtls_mpi_uint p[1];
*p = ( z < 0 ) ? -z : z;
Y.s = ( z < 0 ) ? -1 : 1;
Y.n = 1;
Y.p = p;
return( mbedtls_mpi_cmp_mpi( X, &Y ) );
} | subq $0x28, %rsp
movq %rsi, %rax
negq %rax
cmovsq %rsi, %rax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
sarq $0x3f, %rsi
orl $0x1, %esi
leaq 0x10(%rsp), %rax
movl %esi, (%rax)
movq $0x1, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rax, %rsi
callq 0xbacf
addq $0x28, %rsp
retq
| /project-everest[P]mbedtls/library/bignum.c |
mbedtls_mpi_add_mpi | int mbedtls_mpi_add_mpi( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *B )
{
int ret, s = A->s;
if( A->s * B->s < 0 )
{
if( mbedtls_mpi_cmp_abs( A, B ) >= 0 )
{
MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( X, A, B ) );
X->s = s;
}
else
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl (%rsi), %ebp
movl (%rdx), %eax
imull %ebp, %eax
testl %eax, %eax
js 0xbe12
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xbba5
jmp 0xbe2f
movq %r15, %rdi
movq %r14, %rsi
callq 0xba60
movq %rbx, %rdi
test... | /project-everest[P]mbedtls/library/bignum.c |
mbedtls_rsa_gen_key | int mbedtls_rsa_gen_key( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
unsigned int nbits, int exponent )
{
int ret;
mbedtls_mpi H, G, L;
if( f_rng == NULL || nbits < 128 || exponent < 3 )
return( MBEDTLS_ERR... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %ecx, %r13d
movl $0xffffbf80, %ebp # imm = 0xFFFFBF80
testb $0x1, %r13b
jne 0x17eae
testq %rsi, %rsi
je 0x17eae
cmpl $0x80, %r13d
jb 0x17eae
movl %r8d, %ebx
cmpl $0x3, %r8d
jl 0x17eae
movq %rdx, %r15
movq %rdi, %r14
movq %rsi,... | /project-everest[P]mbedtls/library/rsa.c |
mbedtls_rsa_public | int mbedtls_rsa_public( mbedtls_rsa_context *ctx,
const unsigned char *input,
unsigned char *output )
{
int ret;
size_t olen;
mbedtls_mpi T;
if( rsa_check_context( ctx, 0 /* public */, 0 /* no blinding */ ) )
return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
mbedtls... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %esi, %esi
callq 0x1794f
movl $0xffffbf80, %ebp # imm = 0xFFFFBF80
testl %eax, %eax
jne 0x18383
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xa97c
movq 0x8(%r14), %rdx
movq %r12, %rdi
movq %... | /project-everest[P]mbedtls/library/rsa.c |
mbedtls_rsa_pkcs1_decrypt | int mbedtls_rsa_pkcs1_decrypt( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode, size_t *olen,
const unsigned char *input,
unsigned char *output,
... | movq %r9, %r10
movq %r8, %rax
movl 0x148(%rdi), %r8d
cmpl $0x1, %r8d
je 0x1932f
testl %r8d, %r8d
jne 0x1934c
movq %rax, %r8
movq %r10, %r9
jmp 0x1918f
pushq %rax
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq 0x18(%rsp)
pushq 0x18(%rsp)
pushq %r10
pushq %rax
callq 0x18ede
addq $0x20, %rsp
popq %rcx
retq
movl $0xffffbf00, %eax ... | /project-everest[P]mbedtls/library/rsa.c |
mbedtls_rsa_pkcs1_sign | int mbedtls_rsa_pkcs1_sign( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode,
mbedtls_md_type_t md_alg,
unsigned int hashlen,
const unsigned char *hash,
... | movl 0x148(%rdi), %eax
cmpl $0x1, %eax
je 0x19352
testl %eax, %eax
jne 0x19957
pushq %rax
pushq 0x18(%rsp)
pushq 0x18(%rsp)
callq 0x19614
addq $0x10, %rsp
popq %rcx
retq
movl $0xffffbf00, %eax # imm = 0xFFFFBF00
retq
| /project-everest[P]mbedtls/library/rsa.c |
mbedtls_rsa_rsassa_pss_verify | int mbedtls_rsa_rsassa_pss_verify( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode,
mbedtls_md_type_t md_alg,
unsigned int hashlen,
... | pushq %rax
movl 0x14c(%rdi), %eax
testl %eax, %eax
cmovel %r8d, %eax
pushq 0x18(%rsp)
pushq $-0x1
pushq %rax
pushq 0x28(%rsp)
callq 0x1995d
addq $0x20, %rsp
popq %rcx
retq
| /project-everest[P]mbedtls/library/rsa.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.