schrodinger.infra.canvas module

Canvas C++ wrappers

class schrodinger.infra.canvas.AtomData

::AtomData

__init__(*args, **kwargs)

cachedCoords

constrained

declareAromatic

fixed

hasCoords

hidden

ignored

owner

class schrodinger.infra.canvas.AtomicInvariant

::AtomicInvariant

__init__(*args, **kwargs)

getAtomicCharge(self) → char

getAtomicMass(self) → uchar

getAtomicNumber(self) → uchar

getBondsToNonHydrogen(self) → uchar

getTotalHydrogens(self) → uchar

getTotalValence(self) → uchar

class schrodinger.infra.canvas.BondData

::BondData

__init__(*args, **kwargs)

owner

schrodinger.infra.canvas.CHM_FORCE2D(mol, force2D, arg3) → bool

class schrodinger.infra.canvas.Chm2DCoordGen

::Chm2DCoordGen

__init__(*args, **kwargs)

static assignCoordsForHiddenAtoms(mol)

static assignCoordsForNullAtoms(mol)

static assignMissingCoords(mol)

static center(mol) → ChmPoint

static centerAndRescale(mol, desiredBondLength=1.3)

static checkForNAN(mol) → bool

static exportCoordinatesFromMinimizer(min, mol)

static flipHorizontal(mol)

static flipVertical(mol)

static generateAndApply(mol, arg2=H_Default, arg3=Default)

static generateCoordinates(mol, precision=SKETCHER_STANDARD_PRECISION)

static generateFromTemplateAndApply(mol, templateMol, molAtomNumbers, templateAtomNumbers, arg5=H_Default, arg6=Default, fixup=False, completelyByPassCoordgen=False, copyOverOriginalTemplateCoordinates=False)

static generateFromTemplateAndApply2(mol, templateMol, matches, arg4=H_Default, arg5=Default, fixup=False, completelyByPassCoordgen=False, copyOverOriginalTemplateCoordinates=False)

static getBounds(mol) → std::pair< ChmPoint,ChmPoint >

static getScale(mol) → float

static hasCorrectScale(mol, desiredBondLength=1.3, relativeTolerance=0.05) → bool

static initializeMinimizerFromMolecule(min, mol)

static isAvailable() → bool

static rotate(mol, degrees)

static rotateAbout(mol, degrees, center)

static sketcherBondStereoFromChmBond(chmBond, bond) → sketcherMinimizerBondStereoInfo

static sketcherChiralityFromChmChirality(info, atoms) → sketcherMinimizerAtomChiralityInfo

static translate(mol, offset)

static visibleAtomsAtOrigin(mol) → ChmBitset

schrodinger.infra.canvas.Chm2DCoordGen_assignCoordsForHiddenAtoms(mol)

schrodinger.infra.canvas.Chm2DCoordGen_assignCoordsForNullAtoms(mol)

schrodinger.infra.canvas.Chm2DCoordGen_assignMissingCoords(mol)

schrodinger.infra.canvas.Chm2DCoordGen_center(mol) → ChmPoint

schrodinger.infra.canvas.Chm2DCoordGen_centerAndRescale(mol, desiredBondLength=1.3)

schrodinger.infra.canvas.Chm2DCoordGen_checkForNAN(mol) → bool

schrodinger.infra.canvas.Chm2DCoordGen_exportCoordinatesFromMinimizer(min, mol)

schrodinger.infra.canvas.Chm2DCoordGen_flipHorizontal(mol)

schrodinger.infra.canvas.Chm2DCoordGen_flipVertical(mol)

schrodinger.infra.canvas.Chm2DCoordGen_generateAndApply(mol, arg2=H_Default, arg3=Default)

schrodinger.infra.canvas.Chm2DCoordGen_generateCoordinates(mol, precision=SKETCHER_STANDARD_PRECISION)

schrodinger.infra.canvas.Chm2DCoordGen_generateFromTemplateAndApply(mol, templateMol, molAtomNumbers, templateAtomNumbers, arg5=H_Default, arg6=Default, fixup=False, completelyByPassCoordgen=False, copyOverOriginalTemplateCoordinates=False)

schrodinger.infra.canvas.Chm2DCoordGen_generateFromTemplateAndApply2(mol, templateMol, matches, arg4=H_Default, arg5=Default, fixup=False, completelyByPassCoordgen=False, copyOverOriginalTemplateCoordinates=False)

schrodinger.infra.canvas.Chm2DCoordGen_getBounds(mol) → std::pair< ChmPoint,ChmPoint >

schrodinger.infra.canvas.Chm2DCoordGen_getScale(mol) → float

schrodinger.infra.canvas.Chm2DCoordGen_hasCorrectScale(mol, desiredBondLength=1.3, relativeTolerance=0.05) → bool

schrodinger.infra.canvas.Chm2DCoordGen_initializeMinimizerFromMolecule(min, mol)

schrodinger.infra.canvas.Chm2DCoordGen_isAvailable() → bool

schrodinger.infra.canvas.Chm2DCoordGen_rotate(mol, degrees)

schrodinger.infra.canvas.Chm2DCoordGen_rotateAbout(mol, degrees, center)

schrodinger.infra.canvas.Chm2DCoordGen_sketcherBondStereoFromChmBond(chmBond, bond) → sketcherMinimizerBondStereoInfo

schrodinger.infra.canvas.Chm2DCoordGen_sketcherChiralityFromChmChirality(info, atoms) → sketcherMinimizerAtomChiralityInfo

schrodinger.infra.canvas.Chm2DCoordGen_translate(mol, offset)

schrodinger.infra.canvas.Chm2DCoordGen_visibleAtomsAtOrigin(mol) → ChmBitset

class schrodinger.infra.canvas.ChmAssignments

::ChmIterator< int64 >

__init__(*args, **kwargs)

__len__()

Return len(self).

asVector(self) → std::vector< long long,std::allocator< long long > > const &

asVector(self) → std::vector< long long,std::allocator< long long > >

at(self, index) → long long &

at(self, index) → long long const

chmtostring(self) → std::string

hasNext(self) → bool

hasPrev(self) → bool

isValid(self) → bool

next(self) → long long

prev(self) → long long

rewind(self)

size(self) → int

sort(self)

class schrodinger.infra.canvas.ChmAtom

::ChmAtom

__init__(*args, **kwargs)

canBeChiral(self) → bool

chmtostring(self) → std::string

clone(self) → ChmAtom

countNeighborsByAtomicNumber(self, filterBy) → int

firstNeighbor(self) → ChmAtom

flipChirality(self)

getAtomicNumber(self) → periodicTable::atomicNumber

getAttachedHydrogens(self) → ChmAtoms

getBond(self, index) → ChmBond

getBondCount(self, wantImplicitHydrogens=False) → int

getBondTo(self, otherAtom) → ChmBond

getBonds(self, wantImplicitHydrogens=False) → ChmBonds

getChiralCenters(self) → ChmAtoms

getChiralDeterminant(self, atomOrdering, mappedAtomsCount, force3D) → double

getChiralDeterminant(self, permutation) → double

getChiralDeterminant(self) → double

getChiralityInfo(self) → ChmChiralityInfo

getChiralityType(self) → ChmChiralityType

getCoords(self) → ChmPoint

getElementalInfo(self) → ChmElement

getFormalCharge(self) → int

getHeavyBondCount(self) → int

getHeavyBonds(self) → ChmBonds

getHeavyNeighbors(self) → ChmAtoms

getHybridization(self) → ChmAtomHybridization

getHydrogenCount(self) → int

getImplicitHydrogenCount(self) → int

getImplicitNeighbors(self) → ChmAtoms

getInvariant(self) → AtomicInvariant

getIsotope(self, specified=None) → int

getLabel(self, oneBased=False) → std::string

getLonePairCount(self, considerConjugation=False) → int

getMDLParity(self) → int

getMol(self) → ChmMol

getMolIndex(self) → int

getMolSize(self) → int

getNeighbors(self, wantImplicitHydrogens=False, wantExplicitHydrogens=True) → ChmAtoms

getNeighborsByAtomicNumber(self, filterBy) → ChmAtoms

getNeighborsMasked(self, exclude) → ChmAtoms

getPartialCharge(self) → float

getRGroup(self) → int

getReactionAtomIndex(self) → int

getRingBondCount(self) → int

getRingSize(self) → int

getSmilesChirality(self) → ChmSmilesChirality

getSymbol(self) → std::string

getSymbolForSMARTS(self) → std::string

getTotalValence(self) → int

getUnpairedElectronCount(self) → uint

getUserData(self) → int

getVisibleHydrogenCount(self) → int

getX(self) → float

getY(self) → float

getZ(self) → float

has3DCoords(self) → bool

hasCoords(self) → bool

hasMetallicNeighbor(self) → bool

hasNeighborOfElementType(self, an) → bool

hasOnlyWedge(self) → bool

hasPolarNeighbor(self) → bool

hasRingNeighbor(self) → bool

hasSpecifiedIsotope(self, specified=None) → bool

hasWedge(self) → bool

isAcid(self) → bool

isAliphatic(self) → bool

isAromatic(self) → bool

isBondedTo(self, rhs) → bool

isCarbon(self) → bool

isCarbonyl(self) → bool

isChiral(self) → bool

isChiralAttachment(self) → bool

isConjugated(self) → bool

isConstrained(self) → bool

isDummy(self) → bool

isEZAttachment(self) → bool

isEZAttachmentToN(self) → bool

isEster(self) → bool

isFixed(self) → bool

isHalogen(self) → bool

isHeavy(self) → bool

isHetero(self) → bool

isHidden(self) → bool

isHydrogen(self, excludeIsotopicVariants=False) → bool

isIgnored(self) → bool

isImplicit(self) → bool

isInMol(self) → bool

isInRing(self) → bool

isMetal(self) → int

isNitrogen(self) → bool

isOxygen(self) → bool

isPhosphorous(self) → bool

isPolar(self) → bool

isPolarHydrogen(self) → bool

isPyroleN(self) → bool

isSP(self) → bool

isSP2(self) → bool

isSP3(self) → bool

isSulfur(self) → bool

isTerminal(self) → bool

isVisible(self) → bool

isWildcard(self) → bool

perceiveTetrahedralChirality(self)

setAtomicNumber(self, arg2)

setChiralityType(self, chirality)

setConstrained(self, on)

setCoords(self, point)

setFixed(self, on)

setFormalCharge(self, charge)

setHidden(self, on)

setHybridization(self, hyb)

setHydrogensHidden(self, on)

setIgnored(self, on)

setIsotope(self, val)

setPartialCharge(self, charge)

setRGroup(self, group)

setReactionAtomIndex(self, rxn)

setSmilesChirality(self, code)

setUnpairedElectronCount(self, unpaired) → uint

setUserData(self, data)

setVisibility(self, arg2) → bool

setXYZ(self, x, y, z)

testVisibility(self, arg2) → bool

validateChirality(self)

wedgeCount(self) → int

class schrodinger.infra.canvas.ChmAtomHybridizationTyper

::ChmAtomHybridizationTyper

__init__(*args, **kwargs)

type(self, mol, arg3=False) → ChmAssignments

class schrodinger.infra.canvas.ChmAtomIterator

::ChmIterator< ChmAtom >

__init__(*args, **kwargs)

__len__()

Return len(self).

asVector(self) → std::vector< ChmAtom,std::allocator< ChmAtom > > const &

asVector(self) → std::vector< ChmAtom,std::allocator< ChmAtom > >

at(self, index) → ChmAtom

at(self, index) → ChmAtom

chmtostring(self) → std::string

hasNext(self) → bool

hasPrev(self) → bool

isValid(self) → bool

next(self) → ChmAtom

prev(self) → ChmAtom

rewind(self)

size(self) → int

sort(self)

class schrodinger.infra.canvas.ChmAtomOption

::ChmAtomOption

H_All = 8

H_AsIs = -1

H_Chiral = 4

H_Default = 1

H_ExplicitChiral = 5

H_ExplicitOnly = 1

H_ExplicitPolar = 3

H_ExplicitPolarAndChiral = 6

H_Never = 0

H_Polar = 2

__init__(*args, **kwargs)

class schrodinger.infra.canvas.ChmAtomTyper

::ChmAtomTyper

__init__(*args, **kwargs)

calculateScalar(self, mol, wantImplicitHydrogens=False, et=extendedTypeLast) → double

calculateWeightedScalar(self, mol, smoothingWeights, wantImplicitHydrogens=False, et=extendedTypeLast) → double

extendedType(self, mol, wantImplicitHydrogens=False) → ChmExtendedAssignments

extendedTypeAvg = 1

extendedTypeLast = 0

extendedTypeSum = 2

extendedValueTypeMean(self, mol, wantImplicitHydrogens=False) → ChmValueAssignmentIterator

extendedValueTypeSum(self, mol, wantImplicitHydrogens=False) → ChmValueAssignmentIterator

getAllPossibleAssignments(self) → ChmValueAssignmentIterator

makeGaussianWeights(self, maxPath, sigma) → std::vector< double,std::allocator< double > >

makeWeights(self, maxPath, fallOffPower) → std::vector< double,std::allocator< double > >

setRules(self, rulesString)

setRulesFile(self, rulesFile)

type(self, mol, wantImplicitHydrogens=False) → ChmAssignments

valueType(self, mol, wantImplicitHydrogens=False) → ChmValueAssignmentIterator

valueTypeWithSmoothing(self, mol, smoothingWeights, wantImplicitHydrogens=False) → ChmValueAssignmentIterator

class schrodinger.infra.canvas.ChmAtomTyperAlogP

::ChmAtomTyperAlogP

__init__(*args, **kwargs)

class schrodinger.infra.canvas.ChmAtomTyperEstate

::ChmAtomTyperEstate

__init__(*args, **kwargs)

calculateScalar(self, mol, wantImplicitHydrogens=False, et=extendedTypeLast) → double

getFallOffPower(self) → int

getMaxPath(self) → int

getWeights(self) → std::vector< double,std::allocator< double > > const &

setParam(self, maxPath, fallOffPower)

class schrodinger.infra.canvas.ChmAtomTyperEstateBinned

::ChmAtomTyperEstateBinned

__init__(*args, **kwargs)

type(self, mol, wantImplicitHydrogens=False) → ChmAssignments

class schrodinger.infra.canvas.ChmAtomTyperMR

::ChmAtomTyperMR

__init__(*args, **kwargs)

class schrodinger.infra.canvas.ChmAtomTyperPSA

::ChmAtomTyperPSA

__init__(*args, **kwargs)

class schrodinger.infra.canvas.ChmAtomTyperPolarMiller

::ChmAtomTyperPolarMiller

__init__(*args, **kwargs)

getAtomicPolarizabilities(self) → std::vector< double,std::allocator< double > >

class schrodinger.infra.canvas.ChmAtoms

::ChmAtoms

__init__(*args, **kwargs)

barycenterOf(self) → ChmPointT< float,true >

centerOf(self) → ChmPointT< float,true >

centerOf(self, include) → ChmPointT< float,true >

distanceTo(self, pt) → float

distanceTo(self, atom) → float

getMW(self) → double

toBitset(self) → ChmBitset

class schrodinger.infra.canvas.ChmAtomsAndBonds

::ChmAtomsAndBonds

__init__(*args, **kwargs)

atoms

bonds

class schrodinger.infra.canvas.ChmBitComparable32

::ChmBitComparable< uint >

__init__(*args, **kwargs)

__len__()

Return len(self).

count(self) → uint64

countCommonOff(self, rhs) → uint64

countCommonOn(self, rhs) → uint64

countDifference(self, rhs) → uint64

distDixon(self, rhs, forceBinary=False) → double

distEuclidean(self, rhs, forceBinary=False) → double

distHamming(self, rhs, normalized=False, forceBinary=False, overrideSize=None) → double

distPatternDifference(self, rhs, forceBinary=False, overrideSize=None) → double

distShape(self, rhs, forceBinary=False, overrideSize=None) → double

distSize(self, rhs, forceBinary=False, overrideSize=None) → double

distSoergel(self, rhs, forceBinary=False) → double

distSquaredEuclidean(self, rhs, forceBinary=False) → double

distTanimoto(self, rhs, forceBinary=False) → double

distVariance(self, rhs, forceBinary=False, overrideSize=None) → double

getType(self) → int

simBuser(self, rhs, forceBinary=False, overrideSize=None) → double

simCosine(self, rhs, forceBinary=False) → double

simDice(self, rhs, forceBinary=False) → double

simHamann(self, rhs, forceBinary=False, overrideSize=None) → double

simKulczynski(self, rhs, forceBinary=False) → double

simMatching(self, rhs, forceBinary=False, overrideSize=None) → double

simMcConnaughey(self, rhs, forceBinary=False) → double

simMinMax(self, rhs, forceBinary=False) → double

simModifiedTanimoto(self, rhs, forceBinary=False, overrideSize=None) → double

simPearson(self, rhs, forceBinary=False, overrideSize=None) → double

simPetke(self, rhs, forceBinary=False) → double

simRogersTanimoto(self, rhs, forceBinary=False, overrideSize=None) → double

simSimpson(self, rhs, forceBinary=False) → double

simTanimoto(self, rhs, forceBinary=False) → double

simTversky(self, rhs, alpha, beta, forceBinary=False) → double

simYule(self, rhs, forceBinary=False, overrideSize=None) → double

size(self) → uint64

class schrodinger.infra.canvas.ChmBitComparable64

::ChmBitComparable< uint64 >

__init__(*args, **kwargs)

__len__()

Return len(self).

count(self) → uint64

countCommonOff(self, rhs) → uint64

countCommonOn(self, rhs) → uint64

countDifference(self, rhs) → uint64

distDixon(self, rhs, forceBinary=False) → double

distEuclidean(self, rhs, forceBinary=False) → double

distHamming(self, rhs, normalized=False, forceBinary=False, overrideSize=None) → double

distPatternDifference(self, rhs, forceBinary=False, overrideSize=None) → double

distShape(self, rhs, forceBinary=False, overrideSize=None) → double

distSize(self, rhs, forceBinary=False, overrideSize=None) → double

distSoergel(self, rhs, forceBinary=False) → double

distSquaredEuclidean(self, rhs, forceBinary=False) → double

distTanimoto(self, rhs, forceBinary=False) → double

distVariance(self, rhs, forceBinary=False, overrideSize=None) → double

getType(self) → int

simBuser(self, rhs, forceBinary=False, overrideSize=None) → double

simCosine(self, rhs, forceBinary=False) → double

simDice(self, rhs, forceBinary=False) → double

simHamann(self, rhs, forceBinary=False, overrideSize=None) → double

simKulczynski(self, rhs, forceBinary=False) → double

simMatching(self, rhs, forceBinary=False, overrideSize=None) → double

simMcConnaughey(self, rhs, forceBinary=False) → double

simMinMax(self, rhs, forceBinary=False) → double

simModifiedTanimoto(self, rhs, forceBinary=False, overrideSize=None) → double

simPearson(self, rhs, forceBinary=False, overrideSize=None) → double

simPetke(self, rhs, forceBinary=False) → double

simRogersTanimoto(self, rhs, forceBinary=False, overrideSize=None) → double

simSimpson(self, rhs, forceBinary=False) → double

simTanimoto(self, rhs, forceBinary=False) → double

simTversky(self, rhs, alpha, beta, forceBinary=False) → double

simYule(self, rhs, forceBinary=False, overrideSize=None) → double

size(self) → uint64

class schrodinger.infra.canvas.ChmBitset

::ChmBitset

__contains__(key, /)

Return key in self.

__init__(*args, **kwargs)

__len__(self) → uint64

all(self) → bool

any(self) → bool

blockReverse(self)

chmtostring(self) → std::string

clear(self)

clear(self, index) → None

compare(self, rhs) → int

contains(self, rhs) → bool

countCommonOff(self, rhs) → uint64

countCommonOff(self, rhs) → uint64

countCommonOn(self, rhs) → uint64

countCommonOn(self, rhs) → uint64

countDifference(self, rhs) → uint64

countDifference(self, rhs) → uint64

empty(self) → bool

flip(self)

flip(self, index) → None

static fromBinary(onesAndZeros) → ChmBitset

static fromBlob(raw) → ChmBitset

get(self, index) → bool

getHash(self) → uint

getHash64(self) → uint64

getWord(self, index) → uint &

hasDifference(self, rhs) → bool

intersects(self, rhs) → bool

isContainedBy(self, rhs) → bool

isSubsetOf(self, rhs) → bool

none(self) → bool

physicalSize(self) → size_t

reserve(self, blocks)

resize(self, logicalSize)

reverse(self)

set(self)

set(self, index) → None

set(self, index, on) → None

store(self, inputStream)

storeRaw(self, inputStream)

swap(self, rhs)

toBitString(self) → std::string

toBlob(self) → std::string

toHexString(self) → std::string

toHexString(self, arg2) → None

toMmbs(self, base=1) → int

toString(self, oneBased=False, wantCounts=False) → std::string

toVector(self, oneBased=False) → std::vector< uint,std::allocator< uint > >

class schrodinger.infra.canvas.ChmBitset64

::ChmBitset64

__contains__(key, /)

Return key in self.

__init__(*args, **kwargs)

__len__(self) → uint64

all(self) → bool

any(self) → bool

blockReverse(self)

chmtostring(self) → std::string

clear(self)

clear(self, index) → None

compare(self, rhs) → int

contains(self, rhs) → bool

countCommonOff(self, rhs) → uint64

countCommonOff(self, rhs) → uint64

countCommonOn(self, rhs) → uint64

countCommonOn(self, rhs) → uint64

countDifference(self, rhs) → uint64

countDifference(self, rhs) → uint64

flip(self)

flip(self, index) → None

static fromBinary(onesAndZeros) → ChmBitset64

static fromBlob(raw) → ChmBitset64

static fromHex(hexstring) → ChmBitset64

static fromHex(hexstring, len) → ChmBitset64

get(self, index) → bool

getHash(self) → uint

getHash64(self) → uint64

getWord(self, index) → uint64 &

hasDifference(self, rhs) → bool

intersects(self, rhs) → bool

isContainedBy(self, rhs) → bool

isSubsetOf(self, rhs) → bool

none(self) → bool

physicalSize(self) → size_t

reserve(self, blocks)

resize(self, logicalSize)

reverse(self)

set(self)

set(self, index) → None

set(self, index, on) → None

store(self, outputStream)

storeRaw(self, outputStream)

swap(self, rhs)

toBitString(self) → std::string

toBlob(self) → std::string

toHexString(self) → std::string

toHexString(self, arg2) → None

toString(self, oneBased=False, wantCounts=False) → std::string

toVector(self, oneBased=False) → std::vector< uint64,std::allocator< uint64 > >

toVector(self, dest, oneBased=False) → None

schrodinger.infra.canvas.ChmBitset64_fromBinary(onesAndZeros) → ChmBitset64

schrodinger.infra.canvas.ChmBitset64_fromBlob(raw) → ChmBitset64

schrodinger.infra.canvas.ChmBitset64_fromHex(hexstring) → ChmBitset64

schrodinger.infra.canvas.ChmBitset64_fromHex(hexstring, len) → ChmBitset64

class schrodinger.infra.canvas.ChmBitsetIterator

::ChmIterator< ChmBitset >

__init__(*args, **kwargs)

__len__()

Return len(self).

asVector(self) → ChmBitsetVector

asVector(self) → ChmBitsetVector

at(self, index) → ChmBitset

at(self, index) → ChmBitset

chmtostring(self) → std::string

hasNext(self) → bool

hasPrev(self) → bool

isValid(self) → bool

next(self) → ChmBitset

prev(self) → ChmBitset

rewind(self)

size(self) → int

sort(self)

class schrodinger.infra.canvas.ChmBitsetVector

std::vector< ChmBitset >

__init__(*args, **kwargs)

__len__()

Return len(self).

append(self, x)

assign(self, n, x)

back(self) → ChmBitset

begin(self) → std::vector< ChmBitset >::iterator

capacity(self) → std::vector< ChmBitset >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< ChmBitset >::iterator

erase(self, pos) → std::vector< ChmBitset >::iterator

erase(self, first, last) → std::vector< ChmBitset >::iterator

front(self) → ChmBitset

get_allocator(self) → std::vector< ChmBitset >::allocator_type

insert(self, pos, x) → std::vector< ChmBitset >::iterator

insert(self, pos, n, x) → None

iterator(self) → SwigPyIterator

pop(self) → ChmBitset

pop_back(self)

push_back(self, x)

rbegin(self) → std::vector< ChmBitset >::reverse_iterator

rend(self) → std::vector< ChmBitset >::reverse_iterator

reserve(self, n)

resize(self, new_size)

resize(self, new_size, x) → None

size(self) → std::vector< ChmBitset >::size_type

swap(self, v)

schrodinger.infra.canvas.ChmBitset_fromBinary(onesAndZeros) → ChmBitset

schrodinger.infra.canvas.ChmBitset_fromBlob(raw) → ChmBitset

class schrodinger.infra.canvas.ChmBond

::ChmBond

__init__(*args, **kwargs)

atom1(self) → ChmAtom

atom2(self) → ChmAtom

chmtostring(self) → std::string

clearBondDirectionHint(self)

directionDown = 6

directionNone = 0

directionUp = 1

flipBondDirectionHint(self)

getBondDirectionHint(self) → ChmBond::bondDirectionHint

getBondLength(self) → float

getCis(self, atomIndex1, atomIndex4)

getMaeOrder(self) → int

getMolIndex(self) → int

getMolSize(self) → int

getOrder(self) → ChmBondOrder

getRingSize(self) → int

getStereo(self) → ChmBondStereo

getStereoDeterminant(self, externalOrder, f1, f2, f3, f4) → double

getSymbolForSMARTS(self) → std::string

getTrans(self, atomIndex1, atomIndex4)

getUserData(self) → int

hasBondDirectionHint(self) → bool

idealLength(self) → double

isAromatic(self) → bool

isChiral(self) → bool

isConjugated(self) → bool

isDouble(self) → bool

isDown(self) → bool

isHidden(self) → bool

isInRing(self) → bool

isRotatable(self) → bool

isSingle(self) → bool

isStereo(self) → bool

isTerminal(self) → bool

isTriple(self) → bool

isUp(self) → bool

isVisible(self) → bool

mate(self, reference) → ChmAtom

noHint = 15

otherAtom(self, reference) → ChmAtom

setBondDirectionHint(self, hint)

setCis(self, atomIndex1, atomIndex4)

setCis(self, atom1, atom4) → None

setOrder(self, arg2)

setRingSize(self, arg2)

setStereo(self, arg2)

setTrans(self, atomIndex1, atomIndex4)

setTrans(self, atom1, atom4) → None

setUserData(self, data)

validateStereo(self)

class schrodinger.infra.canvas.ChmBondIterator

::ChmIterator< ChmBond >

__init__(*args, **kwargs)

__len__()

Return len(self).

asVector(self) → std::vector< ChmBond,std::allocator< ChmBond > > const &

asVector(self) → std::vector< ChmBond,std::allocator< ChmBond > >

at(self, index) → ChmBond

at(self, index) → ChmBond

chmtostring(self) → std::string

hasNext(self) → bool

hasPrev(self) → bool

isValid(self) → bool

next(self) → ChmBond

prev(self) → ChmBond

rewind(self)

size(self) → int

sort(self)

class schrodinger.infra.canvas.ChmBonds

::ChmBonds

__init__(*args, **kwargs)

bondsToAtoms(self) → std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >

toBitset(self) → ChmBitset

class schrodinger.infra.canvas.ChmCSVBinaryOut

::ChmCSVBinaryOut

__init__(*args, **kwargs)

static parseHeader(items, binPref='BIT') → ChmSparseBitset

static parseHeader64(items, binPref='BIT') → ChmSparseBitset64

schrodinger.infra.canvas.ChmCSVBinaryOut_parseHeader(items, binPref='BIT') → ChmSparseBitset

schrodinger.infra.canvas.ChmCSVBinaryOut_parseHeader64(items, binPref='BIT') → ChmSparseBitset64

class schrodinger.infra.canvas.ChmChiralityInfo

::ChmChiralityInfo

__init__(*args, **kwargs)

atom1

atom2

atomLookingFrom

centralAtom

direction

class schrodinger.infra.canvas.ChmClusterGrouper

::ChmClusterGrouper

__init__(*args, **kwargs)

group(self, source, info_file, out_file, numGroups, skipSingletons, collectDuplicates)

class schrodinger.infra.canvas.ChmColumnUIDFilter

::ChmColumnUIDFilter

__init__(*args, **kwargs)

static fromFile(filename) → ChmColumnUIDFilter

getAutoScaleInfo(self) → std::map< uint64,std::pair< double,double >,std::less< uint64 >,std::allocator< std::pair< uint64 const,std::pair< double,double > > > > const &

hasAutoScaleInfo(self) → bool

setAutoScaleInfo(self, info)

schrodinger.infra.canvas.ChmColumnUIDFilter_fromFile(filename) → ChmColumnUIDFilter

class schrodinger.infra.canvas.ChmCombinationOut32

::ChmCombinationOut32

__init__(*args, **kwargs)

addDefaultSources(self)

addSource(self, source)

clearAllSources(self)

generate(self, mol, distanceMatrix=None) → ChmSparseBitset

generateMap(self, mol, distanceMatrix=None) → ChmFPMap32

open(self, filename, dataFields=None, logicalSize=None, scaleType=FPScaleNone)

class schrodinger.infra.canvas.ChmCombinationOut64

::ChmCombinationOut64

__init__(*args, **kwargs)

addDefaultSources(self)

addSource(self, source)

clearAllSources(self)

generate(self, mol, distanceMatrix=None) → ChmSparseBitset64

generateMap(self, mol, distanceMatrix=None) → ChmFPMap64

open(self, filename, dataFields=None, logicalSize=None, scaleType=FPScaleNone)

class schrodinger.infra.canvas.ChmCompressedBitset

::ChmCompressedBitset

__init__(*args, **kwargs)

bitwiseAnd(self, rhs, wantPopulationCount) → ChmCompressedBitset

bitwiseNot(self) → ChmCompressedBitset

bitwiseOr(self, rhs, wantPopulationCount) → ChmCompressedBitset

bitwiseXor(self, rhs, wantPopulationCount) → ChmCompressedBitset

chmtostring(self) → std::string

countCommonOff(self, rhs) → uint64

countCommonOff(self, rhs) → uint64

countCommonOn(self, rhs) → uint64

countCommonOn(self, rhs) → uint64

countDifference(self, rhs) → uint64

countDifference(self, rhs) → uint64

defaultLogicalSize = -1

static fromString(idstring) → ChmCompressedBitset

getCompressionRatio(self) → float

getCompressionWithHeader(self) → float

getHash(self) → uint

getHash64(self) → uint64

getStorage(self) → size_t

getUncompressedStorage(self) → uint64

isWordAligned(self) → bool

redoCount(self) → uint

store(self, sdata)

store(self, outputStream, extra=True) → None

store(self, os) → None

swap(self, rhs)

toBitString(self) → std::string

toBitset(self) → ChmBitset

toSet(self, hits)

toString(self) → std::string

toString(self, outputStream) → None

toVector(self) → std::vector< uint,std::allocator< uint > >

toVector(self, hits) → None

class schrodinger.infra.canvas.ChmCompressedBitset64

::ChmCompressedBitset64

__init__(*args, **kwargs)

bitwiseAnd(self, rhs, wantPopulationCount) → ChmCompressedBitset64

bitwiseNot(self) → ChmCompressedBitset64

bitwiseOr(self, rhs, wantPopulationCount) → ChmCompressedBitset64

bitwiseXor(self, rhs, wantPopulationCount) → ChmCompressedBitset64

chmtostring(self) → std::string

countCommonOff(self, rhs) → uint64

countCommonOff(self, rhs) → uint64

countCommonOn(self, rhs) → uint64

countCommonOn(self, rhs) → uint64

countDifference(self, rhs) → uint64

countDifference(self, rhs) → uint64

defaultLogicalSize = -66

static fromString(idstring) → ChmCompressedBitset64

getCompressionRatio(self) → float

getCompressionWithHeader(self) → float

getHash(self) → uint

getHash64(self) → uint64

getStorage(self) → uint64

getUncompressedStorage(self) → uint64

isWordAligned(self) → bool

redoCount(self) → uint64

store(self, sdata)

store(self, outputStream, extra=True) → None

store(self, os) → None

swap(self, rhs)

toBitString(self) → std::string

toSet(self, hits)

toString(self) → std::string

toString(self, outputStream) → None

toVector(self) → std::vector< uint64,std::allocator< uint64 > >

toVector(self, hits) → None

schrodinger.infra.canvas.ChmCompressedBitset64_fromString(idstring) → ChmCompressedBitset64

class schrodinger.infra.canvas.ChmCompressedBitsetIterator

::ChmCompressedBitsetIterator

__init__(*args, **kwargs)

hasNext(self) → bool

next(self) → uint

rewind(self)

class schrodinger.infra.canvas.ChmCompressedBitsetIterator64

::ChmCompressedBitsetIterator64

__init__(*args, **kwargs)

hasNext(self) → bool

next(self) → uint64

rewind(self)

class schrodinger.infra.canvas.ChmCompressedBitsetWordIterator

::ChmCompressedBitsetWordIterator

__init__(*args, **kwargs)

finishWord(self)

getRepeatLength(self) → uint

hasNext(self) → bool

isFill(self) → bool

isOneFill(self) → bool

isZeroFill(self) → bool

next(self) → uint

rewind(self)

skip(self, n)

class schrodinger.infra.canvas.ChmCompressedBitsetWordIterator64

::ChmCompressedBitsetWordIterator64

__init__(*args, **kwargs)

finishWord(self)

getRepeatLength(self) → uint64

hasNext(self) → bool

isFill(self) → bool

isOneFill(self) → bool

isZeroFill(self) → bool

next(self) → uint64

rewind(self)

skip(self, n)

schrodinger.infra.canvas.ChmCompressedBitset_fromString(idstring) → ChmCompressedBitset

class schrodinger.infra.canvas.ChmCoordGenOption

::ChmCoordGenOption

Default = 1

NoScaling = 0

Physical = 1

Rendering = 2

__init__(*args, **kwargs)

class schrodinger.infra.canvas.ChmCustomMetric

::ChmCustomMetric

__init__(*args, **kwargs)

calculateMetric(self, arg2, arg3, arg4, arg5) → double

isSimilarity(self) → bool

class schrodinger.infra.canvas.ChmCustomOut32

::ChmCustomOut32

__init__(*args, **kwargs)

write(self, bs, id)

write(self, bs, id, extraData) → None

class schrodinger.infra.canvas.ChmCustomOut64

::ChmCustomOut64

__init__(*args, **kwargs)

write(self, bs, id)

write(self, bs, id, extraData) → None

class schrodinger.infra.canvas.ChmDelimitedPatterns

::ChmDelimitedPatterns

__init__(*args, **kwargs)

close(self)

getAllColNames(self) → std::vector< std::string,std::allocator< std::string > >

static getDelimiter(filename) → char

static getDelimiterAndQualifier(filename) → std::pair< char,char >

getFilename(self) → std::string const &

getHeaderLine(self) → std::string

getIncludedColIndexes(self) → std::vector< size_t,std::allocator< size_t > >

getIncludedColNames(self) → std::vector< std::string,std::allocator< std::string > >

getIncludedCols(self) → int

getIndex(self, field) → int

getIndexWithinSelection(self, field) → int

getLastLine(self) → std::string

getNumericalColNames(self) → std::vector< std::string,std::allocator< std::string > >

getObsColumnAsDoubles(self) → std::vector< double,std::allocator< double > >

getObservationIncludedIndex(self) → size_t

getObservationIndex(self) → size_t

getObservationName(self) → std::string

getTotalCols(self) → int

getValuesOfColumn(self, index, values)

hasHeader(self) → bool

isBinaryColumn(self, index, onBits) → bool

setObservationName(self, name)

skip(self)

schrodinger.infra.canvas.ChmDelimitedPatterns_getDelimiter(filename) → char

schrodinger.infra.canvas.ChmDelimitedPatterns_getDelimiterAndQualifier(filename) → std::pair< char,char >

class schrodinger.infra.canvas.ChmDendriticOut32

::ChmDendriticOut32

__init__(*args, **kwargs)

generate(self, mol, distanceMatrix=None) → ChmSparseBitset

generateMap(self, mol, distanceMatrix=None) → ChmFPMap32

getMaxPath(self) → int

getMaxSpan(self) → int

getMinPath(self) → int

setMaxPath(self, maxPath_)

setMaxSpan(self, maxSpan_)

setMinPath(self, minPath_)

class schrodinger.infra.canvas.ChmDendriticOut64

::ChmDendriticOut64

__init__(*args, **kwargs)

generate(self, mol, distanceMatrix=None) → ChmSparseBitset64

generateMap(self, mol, distanceMatrix=None) → ChmFPMap64

getMaxPath(self) → int

getMaxSpan(self) → int

getMinPath(self) → int

setMaxPath(self, maxPath_)

setMaxSpan(self, maxSpan_)

setMinPath(self, minPath_)

class schrodinger.infra.canvas.ChmDenseFPOut

::ChmDenseFPOut

__init__(*args, **kwargs)

close(self)

getCurrentRowCount(self) → uint

open(self, filename, logicalSize, params)

write(self, bs)

write(self, bs, id) → None

class schrodinger.infra.canvas.ChmDescriptorInfo

::ChmDescriptorInfo

__init__(*args, **kwargs)

getDriver(self) → std::string

getRole(self) → std::string

m_longname

m_role

m_shortname

m_source

roleFP = 3

roleUnknown = 0

roleX = 2

roleY = 1

class schrodinger.infra.canvas.ChmDescriptorMarshaler

::ChmDescriptorMarshaler

__init__(*args, **kwargs)

getCanvasDescriptorsSwitch(self) → std::string

marshal(self, testMode=False) → std::string

writeCfgFile(self, file) → bool

class schrodinger.infra.canvas.ChmDescriptorSourceMapper

::ChmDescriptorSourceMapper

__init__(*args, **kwargs)

canvasFPGen = 3

canvasMolDescriptors = 1

static getInfo(name) → ChmDescriptorInfo

static getInfoAll(names) → std::vector< ChmDescriptorInfo,std::allocator< ChmDescriptorInfo > >

mopac = 5

qikprop = 4

static sourceToString(arg1) → std::string

sourceUnknown = 0

topo = 2

schrodinger.infra.canvas.ChmDescriptorSourceMapper_getInfo(name) → ChmDescriptorInfo

schrodinger.infra.canvas.ChmDescriptorSourceMapper_getInfoAll(names) → std::vector< ChmDescriptorInfo,std::allocator< ChmDescriptorInfo > >

schrodinger.infra.canvas.ChmDescriptorSourceMapper_sourceToString(arg1) → std::string

class schrodinger.infra.canvas.ChmEstateDescriptors

::ChmEstateDescriptors

__init__(*args, **kwargs)

getAllEstates(self) → std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > >

getAllKeys(self) → std::vector< std::string,std::allocator< std::string > >

getAllKeysSortedByValue(self) → std::vector< std::string,std::allocator< std::string > >

getAverage(self, mol, maxPath, fallOffPower, wantImpH=False) → std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > >

getKeyBool(self, mol, wantImplicitH=False) → std::map< std::string,bool,std::less< std::string >,std::allocator< std::pair< std::string const,bool > > >

getKeyCount(self, mol, wantImpH=False) → std::map< std::string,uint,std::less< std::string >,std::allocator< std::pair< std::string const,uint > > >

getSum(self, mol, maxPath, fallOffPower, wantImpH=False) → std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > >

class schrodinger.infra.canvas.ChmEstateKey

::ChmEstateKey

__init__(*args, **kwargs)

refNum

style

value

exception schrodinger.infra.canvas.ChmException

class schrodinger.infra.canvas.ChmFPCombiner

::ChmFPCombiner

__init__(*args, **kwargs)

addFile(self, fileName)

clearFiles(self)

combine(self, outputFileName, compress=False, cat=False)

combineInOrder(self, outputFileName, endToEnd=False, compress=False)

deleteFiles(self)

isUnfiltered(self) → bool

class schrodinger.infra.canvas.ChmFPCombiner64

::ChmFPCombiner64

__init__(*args, **kwargs)

addFile(self, fileName)

clearFiles(self)

combine(self, outputFileName, compress=False, cat=False)

combineInOrder(self, outputFileName, endToEnd=False, compress=False)

deleteFiles(self)

isUnfiltered(self) → bool

class schrodinger.infra.canvas.ChmFPIn32

::ChmFPIn< ChmSparseBitset >

__init__(*args, **kwargs)

copyTo(self, dest)

decoder(self) → ChmFPDecode const &

filter(self, minFreq, maxFreq, maxBits, reduceBits)

getCounts(self) → std::vector< std::pair< ChmFPIn< ChmSparseBitset >::KEY_TYPE,ChmFPIn< ChmSparseBitset >::POS_TYPE >,std::allocator< std::pair< ChmFPIn< ChmSparseBitset >::KEY_TYPE,ChmFPIn< ChmSparseBitset >::POS_TYPE > > > const &

getCovariance(self, covar, means)

getCovarianceofTranspose(self, covar, means)

getDisplayTypeInfo(self) → std::string

getExtraColumnNames(self) → std::vector< std::string,std::allocator< std::string > > const &

getFilename(self) → std::string

getFrequencyHash(self) → uint64

getInvariantBits(self) → ChmSparseBitset

getMapping(self, key) → ChmFPIn< ChmSparseBitset >::KEY_TYPE

getMatrix(self, unionData)

getOnBits(self) → ChmSparseBitset

getPos(self) → ChmFPIn< ChmSparseBitset >::OFFSET_TYPE

getPositionsByBitCount(self, posCount)

getRequired(self) → ChmSparseBitset

getRowCount(self) → ChmFPIn< ChmSparseBitset >::COUNT_TYPE

getRowNames(self) → std::vector< std::string,std::allocator< std::string > >

getScaledCovariance(self, covar, means, scalingFactors, tolerance)

getScaledCovarianceofTranspose(self, covar, means, scalingFactors, tolerance)

getTypeInfo(self) → std::string

getTypeInfoEx(self) → ChmFPTypeInfo

getUnionCount(self) → ChmFPIn< ChmSparseBitset >::COUNT_TYPE

getValues(self) → std::vector< std::pair< ChmFPIn< ChmSparseBitset >::KEY_TYPE,double >,std::allocator< std::pair< ChmFPIn< ChmSparseBitset >::KEY_TYPE,double > > > const &

getVariances(self) → std::vector< std::pair< ChmFPIn< ChmSparseBitset >::KEY_TYPE,double >,std::allocator< std::pair< ChmFPIn< ChmSparseBitset >::KEY_TYPE,double > > >

hasNext(self) → bool

static isCorrectPrecision(filename) → bool

next(self) → ChmSparseBitset

nextExtra(self) → ChmSparseBitset

nextReduced(self) → ChmBitset

nextReducedExtra(self) → ChmBitset

nextReducedValues(self) → std::vector< float,std::allocator< float > >

nextReducedValuesExtra(self) → std::vector< float,std::allocator< float > >

rewind(self)

setPos(self, pos)

shannonEntropy(self) → double

schrodinger.infra.canvas.ChmFPIn32_isCorrectPrecision(filename) → bool

class schrodinger.infra.canvas.ChmFPIn64

::ChmFPIn< ChmSparseBitset64 >

__init__(*args, **kwargs)

copyTo(self, dest)

decoder(self) → ChmFPDecode const &

filter(self, minFreq, maxFreq, maxBits, reduceBits)

getCounts(self) → std::vector< std::pair< ChmFPIn< ChmSparseBitset64 >::KEY_TYPE,ChmFPIn< ChmSparseBitset64 >::POS_TYPE >,std::allocator< std::pair< ChmFPIn< ChmSparseBitset64 >::KEY_TYPE,ChmFPIn< ChmSparseBitset64 >::POS_TYPE > > > const &

getCovariance(self, covar, means)

getCovarianceofTranspose(self, covar, means)

getDisplayTypeInfo(self) → std::string

getExtraColumnNames(self) → std::vector< std::string,std::allocator< std::string > > const &

getFilename(self) → std::string

getFrequencyHash(self) → uint64

getInvariantBits(self) → ChmSparseBitset64

getMapping(self, key) → ChmFPIn< ChmSparseBitset64 >::KEY_TYPE

getMatrix(self, unionData)

getOnBits(self) → ChmSparseBitset64

getPos(self) → ChmFPIn< ChmSparseBitset64 >::OFFSET_TYPE

getPositionsByBitCount(self, posCount)

getRequired(self) → ChmSparseBitset64

getRowCount(self) → ChmFPIn< ChmSparseBitset64 >::COUNT_TYPE

getRowNames(self) → std::vector< std::string,std::allocator< std::string > >

getScaledCovariance(self, covar, means, scalingFactors, tolerance)

getScaledCovarianceofTranspose(self, covar, means, scalingFactors, tolerance)

getTypeInfo(self) → std::string

getTypeInfoEx(self) → ChmFPTypeInfo

getUnionCount(self) → ChmFPIn< ChmSparseBitset64 >::COUNT_TYPE

getValues(self) → std::vector< std::pair< ChmFPIn< ChmSparseBitset64 >::KEY_TYPE,double >,std::allocator< std::pair< ChmFPIn< ChmSparseBitset64 >::KEY_TYPE,double > > > const &

getVariances(self) → std::vector< std::pair< ChmFPIn< ChmSparseBitset64 >::KEY_TYPE,double >,std::allocator< std::pair< ChmFPIn< ChmSparseBitset64 >::KEY_TYPE,double > > >

hasNext(self) → bool

static isCorrectPrecision(filename) → bool

next(self) → ChmSparseBitset64

nextExtra(self) → ChmSparseBitset64

nextReduced(self) → ChmBitset

nextReducedExtra(self) → ChmBitset

nextReducedValues(self) → std::vector< float,std::allocator< float > >

nextReducedValuesExtra(self) → std::vector< float,std::allocator< float > >

rewind(self)

setPos(self, pos)

shannonEntropy(self) → double

schrodinger.infra.canvas.ChmFPIn64_isCorrectPrecision(filename) → bool

class schrodinger.infra.canvas.ChmFPMap32

::ChmFPMap< ChmSparseBitset >

__init__(*args, **kwargs)

chmtostring(self) → std::string

customize(self)

filter(self, requiredAtoms, requiredCnt=1) → ChmSparseBitset

getAtomsMaskForCode(self, hashCode) → ChmBitsetVector

getBondsMaskForCode(self, hashCode) → ChmBitsetVector

getCode(self, index) → ChmFPMap< ChmSparseBitset >::key_type

getCodeCount(self) → uint

getCodeForAtom(self, atomIndex) → ChmFPMap< ChmSparseBitset >::key_type

getItem(self, index) → ChmFPMapItem32

getItemCount(self) → uint

getItemsForAtom(self, atomIndex) → std::vector< ChmFPMapItem< ChmFPMap< ChmSparseBitset >::key_type >,std::allocator< ChmFPMapItem< ChmFPMap< ChmSparseBitset >::key_type > > >

getOnBits(self) → ChmSparseBitset

getOnBitsCopy(self) → ChmSparseBitset

getOnBitsCount(self) → uint

getUniqueItems(self, uniqueItems)

hasCode(self, hashCode) → bool

m_atomCount

m_atomTypingStyle

m_bondCount

m_isSubStructural

m_onBits

m_scaleType

m_sortedItems

makeUniqueCode(self) → uint64

removeByAtomMask(self, atoms) → ChmFPMap32

store(self, arg2)

class schrodinger.infra.canvas.ChmFPMap64

::ChmFPMap< ChmSparseBitset64 >

__init__(*args, **kwargs)

chmtostring(self) → std::string

customize(self)

filter(self, requiredAtoms, requiredCnt=1) → ChmSparseBitset64

getAtomsMaskForCode(self, hashCode) → ChmBitsetVector

getBondsMaskForCode(self, hashCode) → ChmBitsetVector

getCode(self, index) → ChmFPMap< ChmSparseBitset64 >::key_type

getCodeCount(self) → uint

getCodeForAtom(self, atomIndex) → ChmFPMap< ChmSparseBitset64 >::key_type

getItem(self, index) → ChmFPMapItem64

getItemCount(self) → uint

getItemsForAtom(self, atomIndex) → std::vector< ChmFPMapItem< ChmFPMap< ChmSparseBitset64 >::key_type >,std::allocator< ChmFPMapItem< ChmFPMap< ChmSparseBitset64 >::key_type > > >

getOnBits(self) → ChmSparseBitset64

getOnBitsCopy(self) → ChmSparseBitset64

getOnBitsCount(self) → uint

getUniqueItems(self, uniqueItems)

hasCode(self, hashCode) → bool

m_atomCount

m_atomTypingStyle

m_bondCount

m_isSubStructural

m_onBits

m_scaleType

m_sortedItems

makeUniqueCode(self) → uint64

removeByAtomMask(self, atoms) → ChmFPMap64

store(self, arg2)

class schrodinger.infra.canvas.ChmFPMapItem32

::ChmFPMapItem< uint >

__init__(*args, **kwargs)

addItem(self, atoms, bonds, _atomIndices)

chmtostring(self) → std::string

getAtomAndBondCount(self) → uint

getAtomCount(self) → uint

getBondCount(self) → uint

getItemCount(self) → uint

getMatchCount(self) → uint

m_atomCount

m_atomIndices

m_atomSize

m_atomsThatMatch

m_bondCount

m_bondSize

m_bondsThatMatch

m_hashCode

store(self, os)

class schrodinger.infra.canvas.ChmFPMapItem64

::ChmFPMapItem< uint64 >

__init__(*args, **kwargs)

addItem(self, atoms, bonds, _atomIndices)

chmtostring(self) → std::string

getAtomAndBondCount(self) → uint

getAtomCount(self) → uint

getBondCount(self) → uint

getItemCount(self) → uint

getMatchCount(self) → uint

m_atomCount

m_atomIndices

m_atomSize

m_atomsThatMatch

m_bondCount

m_bondSize

m_bondsThatMatch

m_hashCode

store(self, os)

class schrodinger.infra.canvas.ChmFPOut32

::ChmFPOut32

__init__(*args, **kwargs)

addZeros(self, toAdd)

close(self)

close(self, minFreq, maxFreq, maxBits) → None

close(self, minFreq, maxFreq, maxBits, reduceBits) → None

generate(self, mol, distanceMatrix=None) → ChmSparseBitset

generateMap(self, mol, distanceMatrix=None) → ChmFPMap32

getCurrentRowCount(self) → uint

getFilename(self) → std::string

getTypeInfo(self) → std::string

m_scaleType

needsDM(self) → bool

needsStereo(self) → bool

open(self, filename, dataFields=None, logicalSize=None, scaleType=FPScaleNone, overrideTypeInfo=None, compressed=False, maxLog2=18, requiredBits=None, summaryOnly=False, noSummary=False, omitJobDir=False)

write(self, mol, excludeAtomMask=None)

write(self, mol, extraData, excludeAtomMask=None) → None

write(self, mol, id, excludeAtomMask=None) → None

write(self, mol, id, extraData, excludeAtomMask=None) → None

writeNameAndProps(self, mol, id, extraData)

class schrodinger.infra.canvas.ChmFPOut64

::ChmFPOut64

__init__(*args, **kwargs)

addZeros(self, toAdd)

close(self)

close(self, minFreq, maxFreq, maxBits) → None

close(self, minFreq, maxFreq, maxBits, reduceBits) → None

generate(self, mol, distanceMatrix=None) → ChmSparseBitset64

generateMap(self, mol, distanceMatrix=None) → ChmFPMap64

getCurrentRowCount(self) → uint

getFilename(self) → std::string

getTypeInfo(self) → std::string

m_scaleType

needsDM(self) → bool

needsStereo(self) → bool

open(self, filename, dataFields=None, logicalSize=None, scaleType=FPScaleNone, overrideTypeInfo=None, compressed=False, maxLog2=18, requiredBits=None, summaryOnly=False, noSummary=False, omitJobDir=False)

write(self, mol, excludeAtomMask=None)

write(self, mol, extraData, excludeAtomMask=None) → None

write(self, mol, id, excludeAtomMask=None) → None

write(self, mol, id, extraData, excludeAtomMask=None) → None

writeNameAndProps(self, mol, id, extraData)

class schrodinger.infra.canvas.ChmFPSplitter

::ChmFPSplitter

__init__(*args, **kwargs)

getInputFileName(self) → std::string

getMaxFpFilesOpen(self) → uint

getOutputFileNames(self) → std::vector< std::string,std::allocator< std::string > >

getPrecision(self) → int

getRowCount(self) → uint

class schrodinger.infra.canvas.ChmFPTypeInfo

::ChmFPTypeInfo

__init__(*args, **kwargs)

static areCompatible(fp1, fp2) → bool

static fromFile(fpInfoFile) → ChmFPTypeInfo

getBool(self, key) → bool

getDalkeHeader(self) → std::string

getDisplayInfo(self) → std::string

getDisplayInfoEx(self) → std::string

getFloat(self, key) → float

getInt(self, key) → int

getMaxBits(self) → uint64

getMaxFreq(self) → float

getMinFreq(self) → float

getProp(self, key, missingOk=False) → std::string

getProps(self) → std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > const &

getRightShift(self) → uint

getScaleType(self) → FingerprintScaleType

getUID(self) → int64

hasProp(self, key) → bool

hasValues(self) → bool

is32Bit(self) → bool

is64Bit(self) → bool

isCompatible(self, rhs) → bool

isConsistentWith(self, rhs, ignoreFiltering, ignoreScale) → bool

isCustom(self) → bool

isCustomType(self) → bool

isFiltered(self) → bool

isFilteredOrReduced(self) → bool

isReduced(self) → bool

isSupersetOf(self, rhs) → bool

isValid(self) → bool

makeTableName(self) → std::string

makeXORTableName(self) → std::string

testProp(self, key, value) → bool

toFPOut(self) → ChmFPOut32

toFPOut64(self) → ChmFPOut64

toString(self) → std::string

schrodinger.infra.canvas.ChmFPTypeInfo_areCompatible(fp1, fp2) → bool

schrodinger.infra.canvas.ChmFPTypeInfo_fromFile(fpInfoFile) → ChmFPTypeInfo

class schrodinger.infra.canvas.ChmFPWrapper

::ChmFPWrapper

__init__(*args, **kwargs)

class schrodinger.infra.canvas.ChmFingerprints

::ChmFingerprints

__init__(*args, **kwargs)

static getRGACodes(mol) → ChmSparseBitset

schrodinger.infra.canvas.ChmFingerprints_getRGACodes(mol) → ChmSparseBitset

class schrodinger.infra.canvas.ChmGasteigerCharge

::ChmGasteigerCharge

__init__(*args, **kwargs)

calcGasteigerCharges(self, arg2, maxIter=7, delta=0.001) → bool

getAtomTypes(self) → std::vector< int64,std::allocator< int64 > >

getCharges(self, includeImplicitH=True) → std::vector< double,std::allocator< double > >

getStepAtomicCharge(self, atom, iter) → double

getStepAtomicEneg(self, atom, iter) → double

getTotalIteration(self) → size_t

class schrodinger.infra.canvas.ChmHbond

::ChmHbond

__init__(*args, **kwargs)

assignAcceptors(self, mol)

assignDonors(self, mol)

isAcceptor(self, atomIndex) → bool

isDonor(self, atomIndex) → bool

isUsingDefaultAcceptorFile(self) → bool

isUsingDefaultDonorFile(self) → bool

overrideAcceptorFile(self, acceptorFile)

overrideDonorFile(self, donorFile)

printHBADef(self)

printHBDDef(self)

class schrodinger.infra.canvas.ChmHierarchicalClustering

::ChmHierarchicalClustering

CompleteLinkage = 2

FlexibleBetaLinkage = 8

GroupAverageLinkage = 3

SchrodingerLinkage = 9

SingleLinkage = 1

UnweightedCentroidLinkage = 4

UseEither = 0

UseLower = 4

UseMaxAB = 2

UseMinAB = 1

UseUpper = 3

WardsMinimumVarianceLinkage = 6

WeightedAverageLinkage = 5

WeightedCentroidLinkage = 7

__init__(*args, **kwargs)

cluster(self, source, dendrogram_filename, intermediate_info_filename, statistics_filename, arg6, collectDuplicates) → double

cluster(self, source, dendrogram_filename, grouping_detail_filename, threshold, arg6, collectDuplicates) → double

class schrodinger.infra.canvas.ChmKPLSParser

::ChmKPLSParser

__init__(*args, **kwargs)

getAUC(self, numFactor) → std::string

getCISDAll(self, numFactor) → std::vector< std::string,std::allocator< std::string > >

getCISDs(self, numFactor) → std::vector< std::string,std::allocator< std::string > >

getConfidenceIntervals(self, numFactor) → std::vector< std::string,std::allocator< std::string > >

getFPTypeInfo(self) → std::string

getMaxFactor(self) → size_t

getMinFactor(self) → size_t

getNamesAll(self) → std::vector< std::string,std::allocator< std::string > >

getNumObsInTrainingTestTotal(self) → std::vector< int,std::allocator< int > >

getObsAll(self) → std::vector< std::string,std::allocator< std::string > >

getPredAll(self, numFactor) → std::vector< std::string,std::allocator< std::string > >

getQsqr(self, numFactor) → std::string

getRsqr(self, numFactor) → std::string

getSD(self, numFactor) → std::string

getSigma(self) → double

getTestSetObs(self) → std::vector< std::string,std::allocator< std::string > >

getTestSetPred(self, numFactor) → std::vector< std::string,std::allocator< std::string > >

getTestSetRMSE(self, numFactor) → std::string

getTrainingSetObs(self) → std::vector< std::string,std::allocator< std::string > >

getTrainingSetPred(self, numFactor) → std::vector< std::string,std::allocator< std::string > >

getVariableNames(self) → std::vector< std::string,std::allocator< std::string > >

getYvar(self) → std::string

haveConfidenceInterval(self) → bool

haveTestSet(self) → bool

haveTrainingSet(self) → bool

writePredictions(self, filename, namefield='name', delim='\t', extraParameter=-1)

class schrodinger.infra.canvas.ChmLicenseAutoQsar

::ChmLicenseAutoQsar

__init__(*args, **kwargs)

getType(self) → canvasLicenseType

static isValid() → bool

schrodinger.infra.canvas.ChmLicenseAutoQsar_isValid() → bool

class schrodinger.infra.canvas.ChmLicenseElements

::ChmLicenseElements

__init__(*args, **kwargs)

getType(self) → canvasLicenseType

static isValid() → bool

class schrodinger.infra.canvas.ChmLicenseElementsOrFull

::ChmLicenseElementsOrFull

__init__(*args, **kwargs)

isValid(self) → bool

schrodinger.infra.canvas.ChmLicenseElements_isValid() → bool

class schrodinger.infra.canvas.ChmLicenseFull

::ChmLicenseFull

__init__(*args, **kwargs)

getType(self) → canvasLicenseType

static isValid() → bool

class schrodinger.infra.canvas.ChmLicenseFullOrMain

::ChmLicenseFullOrMain

__init__(*args, **kwargs)

isValid(self) → bool

schrodinger.infra.canvas.ChmLicenseFull_isValid() → bool

class schrodinger.infra.canvas.ChmLicenseMain

::ChmLicenseMain

__init__(*args, **kwargs)

getType(self) → canvasLicenseType

static isValid() → bool

reset(self)

schrodinger.infra.canvas.ChmLicenseMain_isValid() → bool

class schrodinger.infra.canvas.ChmLicenseMatSci

::ChmLicenseMatSci

__init__(*args, **kwargs)

getType(self) → canvasLicenseType

static isValid() → bool

schrodinger.infra.canvas.ChmLicenseMatSci_isValid() → bool

class schrodinger.infra.canvas.ChmLicenseShared

::ChmLicenseShared

__init__(*args, **kwargs)

getType(self) → canvasLicenseType

static isValid() → bool

schrodinger.infra.canvas.ChmLicenseShared_isValid() → bool

class schrodinger.infra.canvas.ChmLicenseXCluster

::ChmLicenseXCluster

__init__(*args, **kwargs)

getType(self) → canvasLicenseType

static isValid() → bool

schrodinger.infra.canvas.ChmLicenseXCluster_isValid() → bool

class schrodinger.infra.canvas.ChmLinearOut32

::ChmLinearOut32

__init__(*args, **kwargs)

generate(self, mol, distanceMatrix=None) → ChmSparseBitset

generateMap(self, mol, distanceMatrix=None) → ChmFPMap32

getHalfStep(self) → bool

getMaxPath(self) → int

getMaxRingPath(self) → int

getMinPath(self) → int

setHalfStep(self, halfstep)

setMaxPath(self, maxPath_)

setMaxRingPath(self, maxRingPath_)

setMinPath(self, minPath_)

class schrodinger.infra.canvas.ChmLinearOut64

::ChmLinearOut64

__init__(*args, **kwargs)

generate(self, mol, distanceMatrix=None) → ChmSparseBitset64

generateMap(self, mol, distanceMatrix=None) → ChmFPMap64

getHalfStep(self) → bool

getMaxPath(self) → int

getMaxRingPath(self) → int

getMinPath(self) → int

setHalfStep(self, halfstep)

setMaxPath(self, maxPath_)

setMaxRingPath(self, maxRingPath_)

setMinPath(self, minPath_)

class schrodinger.infra.canvas.ChmMCSRecord

::ChmMCSRecord

DetailBitset = 1

DetailMapping = 2

DetailNone = 0

__init__(*args, **kwargs)

abCount

atomCount

atoms

bondCount

bonds

code

containmentGroup

fepNoRingBreak = 1

fepNone = 0

fepRingBreak = 2

findInvalidAtomsAndBonds(self, mol) → std::pair< ChmBitset,ChmBitset >

fixInvalidAtomsAndBonds(self, mol, atomPositionsToRemove, bondPositionsToRemove)

m_score

mapAtoms

mapBonds

markMappedAtomsAndBonds(self, mol)

mcsSmarts

molCount

molID

molSMILES

page

policy

printCSVHeader(self, os, outputDelim)

printCSVProperties(self, os, mol, outputDelim, oneBased, wantUniqueSMILES)

printPWHeader(self, os, outputDelim)

score(self) → double

setAsMaeProperties(self, ctHandle, molTitle, colorInt)

setAsSDProperties(self, mol)

weight(self) → double

wscore(self) → double

class schrodinger.infra.canvas.ChmMaccsOut32

::ChmMaccsOut32

__init__(*args, **kwargs)

generate(self, mol, distanceMatrix=None) → ChmSparseBitset

generateMap(self, mol, distanceMatrix=None) → ChmFPMap32

class schrodinger.infra.canvas.ChmMaccsOut64

::ChmMaccsOut64

__init__(*args, **kwargs)

generate(self, mol, distanceMatrix=None) → ChmSparseBitset64

generateMap(self, mol, distanceMatrix=None) → ChmFPMap64

class schrodinger.infra.canvas.ChmMatch

::ChmMatch

__init__(*args, **kwargs)

getMatchedAtoms(self) → ChmAtoms

getMatchedAtomsInfo(self) → SwigChmAtomIntPairVector

getReactionIndices(self) → std::vector< int,std::allocator< int > >

class schrodinger.infra.canvas.ChmMatchEx

::ChmMatchEx

__init__(*args, **kwargs)

getMatchedAtomIndices(self, base=0) → std::vector< int,std::allocator< int > >

getMatchedAtoms(self) → ChmAtoms

getMatchedAtomsInfo(self) → SwigChmAtomIntPairVector

getMatchedBondIndices(self, base=0) → std::vector< int,std::allocator< int > >

getMatchedBonds(self) → ChmBonds

getReactionIndices(self) → std::vector< int,std::allocator< int > >

class schrodinger.infra.canvas.ChmMatchExIterator

::ChmIterator< ChmMatchEx >

__init__(*args, **kwargs)

__len__()

Return len(self).

asVector(self) → std::vector< ChmMatchEx,std::allocator< ChmMatchEx > > const &

asVector(self) → std::vector< ChmMatchEx,std::allocator< ChmMatchEx > >

at(self, index) → ChmMatchEx

at(self, index) → ChmMatchEx

chmtostring(self) → std::string

hasNext(self) → bool

hasPrev(self) → bool

isValid(self) → bool

next(self) → ChmMatchEx

prev(self) → ChmMatchEx

rewind(self)

size(self) → int

sort(self)

class schrodinger.infra.canvas.ChmMatchIterator

::ChmIterator< ChmMatch >

__init__(*args, **kwargs)

__len__()

Return len(self).

asVector(self) → std::vector< ChmMatch,std::allocator< ChmMatch > > const &

asVector(self) → std::vector< ChmMatch,std::allocator< ChmMatch > >

at(self, index) → ChmMatch

at(self, index) → ChmMatch

chmtostring(self) → std::string

hasNext(self) → bool

hasPrev(self) → bool

isValid(self) → bool

next(self) → ChmMatch

prev(self) → ChmMatch

rewind(self)

size(self) → int

sort(self)

class schrodinger.infra.canvas.ChmMatcherData

::ChmMatcherData

__init__(*args, **kwargs)

allowRelative

hydrogensInterchangeable

ignoreImplicitHydrogens

limit

mol

query

rigorousValidationOfSource

unique

class schrodinger.infra.canvas.ChmMatches

::ChmMatches

__init__(*args, **kwargs)

filter(self, atoms) → ChmMatches

class schrodinger.infra.canvas.ChmMatchesEx

::ChmMatchesEx

__init__(*args, **kwargs)

filter(self, atoms) → ChmMatchesEx

class schrodinger.infra.canvas.ChmMatrixUnsignedInt

::ChmMatrix< uint >

__init__(*args, **kwargs)

autoScale(self, tolerance=1.0e-24)

base(self) → unsigned int const *

center(self)

chmtostring(self) → std::string

clear(self)

cols(self) → uint

doubleCenter(self)

fastItem(self, i, j) → unsigned int &

fastReadItem(self, i, j) → unsigned int const &

fill(self, value)

getColumnMeans(self, means)

getColumnMeansAndDeviations(self, means, stdDeviations)

getCovariance(self, covariance)

getCovariance(self, rhs, covariance) → None

getCovariance(self, covariance, means) → None

getCovariance(self, covariance, means, scalingFactors, tolerance=1.0e-24) → None

getDM(self, distanceMatrix, lambda1=2, lambda2=0.5)

getLaplacian(self, laplacian)

getLaplacian(self, laplacian) → None

getMahalanobisDM(self, distanceMatrix, lambda1=2, lambda2=0.5) → int

getRMSD(self, rmsd)

getRMSD(self, rhs, rmsd) → None

getScaledCovariance(self, covariance, tolerance=1.0e-24)

getScaledCovariance(self, rhs, covariance, tolerance=1.0e-24) → None

getScaledMahalanobisDM(self, distanceMatrix, lambda1=2, lambda2=0.5, tolerance=1.0e-24) → int

invert(self)

isSquare(self) → bool

item(self, i, j) → unsigned int &

pivot(self, piv) → ChmMatrixUnsignedInt

pivot(self, piv, fromIndex, toIndex) → ChmMatrixUnsignedInt

readItem(self, i, j) → unsigned int const &

resize(self, dim)

resize(self, rows, cols) → None

rows(self) → uint

swap(self, rhs)

transpose(self) → ChmMatrixUnsignedInt

type(self) → bool

class schrodinger.infra.canvas.ChmMinimalRPParser

::ChmMinimalRPParser

__init__(*args, **kwargs)

m_xvarNames

m_yvarNames

writePredictions(self, filename, namefield='name', delim='\t', extraParameter=-1)

class schrodinger.infra.canvas.ChmMmctAdaptor

::ChmMmctAdaptor

NoStereo = 0

StereoFromAnnotation = 3

StereoFromAnnotationAndGeometry = 5

StereoFromAnnotationAndGeometry_Safe = 6

StereoFromAnnotation_Safe = 4

StereoFromGeometry = 1

StereoFromGeometry_Safe = 2

__init__(*args, **kwargs)

static applyBondOrdersAndCharges(source, dest)

static calculateSASA(ctHandle, probeRadiusAngstroms=1.4, resolutionAngstroms=0.2, excludeH=True, divideByTotalAtomSurfaceArea=False, usePBC=False) → double

static calculateSASA(ctHandle, mmbsSubsetAtoms, probeRadiusAngstroms=1.4, resolutionAngstroms=0.2, divideByTotalAtomSurfaceArea=False, usePBC=False) → double

static calculateSASA(ctHandle, mmbsSubsetAtomsCount, mmbsSubsetAtomsConsider, probeRadiusAngstroms=1.4, resolutionAngstroms=0.2, divideByTotalAtomSurfaceArea=False, usePBC=False) → double

static calculateSASAByAtom(ctHandle, probeRadiusAngstroms=1.4, resolutionAngstroms=0.2, excludeH=True, divideByTotalAtomSurfaceArea=False, usePBC=False) → std::vector< double,std::allocator< double > >

static calculateSASAByAtom(ctHandle, mmbsSubsetAtoms, probeRadiusAngstroms=1.4, resolutionAngstroms=0.2, divideByTotalAtomSurfaceArea=False, usePBC=False) → std::vector< double,std::allocator< double > >

static calculateSASAByAtom(ctHandle, mmbsSubsetAtomsCount, mmbsSubsetAtomsConsider, probeRadiusAngstroms=1.4, resolutionAngstroms=0.2, divideByTotalAtomSurfaceArea=False, usePBC=False) → std::vector< double,std::allocator< double > >

static calculateVolume(ctHandle, gridAngstroms=1.0, excludeH=True) → double

static collectMaeProperties(maefile, props, wantMMStereo, pf)

create(self, a_ctHandle, a_mol, stereo=NoStereo, hydrogenTreatment=H_ExplicitOnly, wantProperties=True, wantMMStereoProps=False, readAtomBondProperties=True, allowRadicals=False)

create(self, a_ctHandle, stereo=NoStereo, hydrogenTreatment=H_ExplicitOnly, wantProperties=True, wantMMStereoProps=False, readAtomBondProperties=True, allowRadicals=False) → ChmMol

create(self, a_mol, wantProperties=True, hydrogenTreatment=H_AsWritten) → MM_Index

static estimateRecordCount(maefile, scanDepth, isExact) → uint64

getAcyclicBonds(self, a_ctHandle) → std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >

getAromaticityInfo(self, a_ctHandle) → std::vector< bool,std::allocator< bool > >

static getComponents(source, mappings) → std::vector< ChmMMIndex,std::allocator< ChmMMIndex > >

static getComponents(source) → std::vector< ChmMMIndex,std::allocator< ChmMMIndex > >

getRingBonds(self, a_ctHandle) → std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >

getTitle(self, maestring) → std::string

kekulize(self, target) → bool

load(self, maesource, rf, mols, positions, offset, blockSize, stereo, hydrogenTreatment, wantProperties, wantMMStereoProps, readPartial, fieldAsName, textOnly, decode, wantMolData) → bool

readProperties(self, a_ctHandle, properties, wantMMStereoProps, decode)

readProperties(self, maestring, properties, wantMMStereoProps, stripOutProp, decode) → bool

static safeDelete(ctHandle, warn=False)

simpleLoad(self, maefile, decode=False, wantEmpty=True) → std::vector< ChmMol,std::allocator< ChmMol > >

simpleLoadWithFilter(self, maefile, logicalRowFilter, decode=False, wantEmpty=True) → std::vector< ChmMol,std::allocator< ChmMol > >

simpleLoadWithFilterRegEx(self, maefile, filter, regularExpressionToMatch, decode=False, wantEmpty=True) → std::vector< ChmMol,std::allocator< ChmMol > >

simpleLoadWithFilterRegExs(self, maefile, filter, regularExpressionsToMatch, decode=False, wantEmpty=True) → std::vector< ChmMol,std::allocator< ChmMol > >

schrodinger.infra.canvas.ChmMmctAdaptor_applyBondOrdersAndCharges(source, dest)

schrodinger.infra.canvas.ChmMmctAdaptor_calculateSASA(ctHandle, probeRadiusAngstroms=1.4, resolutionAngstroms=0.2, excludeH=True, divideByTotalAtomSurfaceArea=False, usePBC=False) → double

schrodinger.infra.canvas.ChmMmctAdaptor_calculateSASA(ctHandle, mmbsSubsetAtoms, probeRadiusAngstroms=1.4, resolutionAngstroms=0.2, divideByTotalAtomSurfaceArea=False, usePBC=False) → double

schrodinger.infra.canvas.ChmMmctAdaptor_calculateSASA(ctHandle, mmbsSubsetAtomsCount, mmbsSubsetAtomsConsider, probeRadiusAngstroms=1.4, resolutionAngstroms=0.2, divideByTotalAtomSurfaceArea=False, usePBC=False) → double

schrodinger.infra.canvas.ChmMmctAdaptor_calculateSASAByAtom(ctHandle, probeRadiusAngstroms=1.4, resolutionAngstroms=0.2, excludeH=True, divideByTotalAtomSurfaceArea=False, usePBC=False) → std::vector< double,std::allocator< double > >

schrodinger.infra.canvas.ChmMmctAdaptor_calculateSASAByAtom(ctHandle, mmbsSubsetAtoms, probeRadiusAngstroms=1.4, resolutionAngstroms=0.2, divideByTotalAtomSurfaceArea=False, usePBC=False) → std::vector< double,std::allocator< double > >

schrodinger.infra.canvas.ChmMmctAdaptor_calculateSASAByAtom(ctHandle, mmbsSubsetAtomsCount, mmbsSubsetAtomsConsider, probeRadiusAngstroms=1.4, resolutionAngstroms=0.2, divideByTotalAtomSurfaceArea=False, usePBC=False) → std::vector< double,std::allocator< double > >

schrodinger.infra.canvas.ChmMmctAdaptor_calculateVolume(ctHandle, gridAngstroms=1.0, excludeH=True) → double

schrodinger.infra.canvas.ChmMmctAdaptor_collectMaeProperties(maefile, props, wantMMStereo, pf)

schrodinger.infra.canvas.ChmMmctAdaptor_estimateRecordCount(maefile, scanDepth, isExact) → uint64

schrodinger.infra.canvas.ChmMmctAdaptor_getComponents(source, mappings) → std::vector< ChmMMIndex,std::allocator< ChmMMIndex > >

schrodinger.infra.canvas.ChmMmctAdaptor_getComponents(source) → std::vector< ChmMMIndex,std::allocator< ChmMMIndex > >

schrodinger.infra.canvas.ChmMmctAdaptor_safeDelete(ctHandle, warn=False)

class schrodinger.infra.canvas.ChmMmctSmilesGenerator

::ChmMmctSmilesGenerator

__init__(*args, **kwargs)

canonicalize(self, smiles) → std::string

getHashCode(self, a_ctHandle, arg3=StereoFromAnnotationAndGeometry) → uint

getHashCode64(self, a_ctHandle, arg3=StereoFromAnnotationAndGeometry) → uint64

getSMARTS(self, a_ctHandle, arg3=H_Default, arg4=X_Default, wantStereo=False, wantMapping=False, atomMappings=None, useAtomicNumberOnAcyclicAtoms=False, wantCharge=True) → std::string

getSmiles(self, a_ctHandle, arg3=StereoFromAnnotationAndGeometry, wildCardHeavyAtoms=False) → std::string

getSmilesAndMap(self, a_ctHandle, arg3=StereoFromAnnotationAndGeometry) → std::string

getSubsetSMARTS(self, a_ctHandle, atomInclusionMask, markRings=False, arg5=H_Default, arg6=X_Default, wantStereo=False, wantMapping=False, atomMappings=None, useAtomicNumberOnAcyclicAtoms=False, wantCharge=True) → std::string

getTautomerCode(self, a_ctHandle, arg3=StereoFromAnnotationAndGeometry) → uint

getTautomerCode64(self, a_ctHandle, arg3=StereoFromAnnotationAndGeometry) → uint64

getUniqueSmiles(self, a_ctHandle, arg3=StereoFromAnnotationAndGeometry, wildCardHeavyAtoms=False) → std::string

getUniqueSmilesAndMap(self, a_ctHandle, arg3=StereoFromAnnotationAndGeometry) → std::string

neutralize(self, smiles) → std::string

neutralize2(self, smiles) → std::string

setCharge(self, a_val)

setChiral(self, a_val)

setForceAllBondOrders(self, a_val)

setForceHydrogens(self, a_val)

validateSmilesString(self, smiles) → bool

validateSmilesString(self, smiles, errorString) → bool

class schrodinger.infra.canvas.ChmModelParser

::ChmModelParser

__init__(*args, **kwargs)

clear(self)

static getResultsParser(file) → ChmModelParser

getTestSetNames(self) → std::vector< std::string,std::allocator< std::string > >

getTrainingSetNames(self) → std::vector< std::string,std::allocator< std::string > >

read(self, arg2, arg3)

writePredictions(self, filename, namefield='name', delim='\t', extraParameter=-1)

schrodinger.infra.canvas.ChmModelParser_getResultsParser(file) → ChmModelParser

class schrodinger.infra.canvas.ChmModelReporter

::ChmModelReporter

__init__(*args, **kwargs)

appendErr(self, str)

appendLog(self, str)

appendWarning(self, str)

getStatus(self) → ChmModelStatus

m_maxFactor

m_method

m_qsqr

m_rcorr

m_regB

m_regBSE

m_regF

m_regP

m_regSD

m_regStability

m_regVarNames

m_regrsqr

m_regrsqrCv

m_rmsErr_test

m_rmsErr_train

m_testList

m_trainList

m_yobsBinTestBayes

m_yobsBinTrainBayes

m_yobsLabelTestBayes

m_yobsLabelTrainBayes

m_yobsTest

m_yobsTestNnet

m_yobsTestOK

m_yobsTestOKNnet

m_yobsTrain

m_yobsTrainNnet

m_ypredBinTestBayes

m_ypredBinTrainBayes

m_ypredLabelTestBayes

m_ypredLabelTrainBayes

m_ypredTestNnetVec

m_ypredTestVec

m_ypredTrainNnetVec

m_ypredTrainVec

printErr(self, os)

printLog(self, os)

printWarning(self, os)

setStatus(self, s)

success(self) → bool

static translateCode(st) → std::string

schrodinger.infra.canvas.ChmModelReporter_translateCode(st) → std::string

class schrodinger.infra.canvas.ChmModelTypeInfo

::ChmModelTypeInfo

__init__(*args, **kwargs)

getChmDescriptorInfo(self) → std::vector< ChmDescriptorInfo,std::allocator< ChmDescriptorInfo > >

getFP(self) → std::vector< std::string,std::allocator< std::string > >

getModelType(self) → ChmModelTypeInfo::modelType

getSource(self) → std::string

getX(self) → std::vector< std::string,std::allocator< std::string > >

getY(self) → std::vector< std::string,std::allocator< std::string > >

modelBayes = 11

modelKPLS = 14

modelMLR = 16

modelMultiKPLS = 15

modelNnet = 13

modelPCAReg = 17

modelPLS = 18

modelRP = 12

modelUnknown = 0

show(self, testMode=False) → std::string

class schrodinger.infra.canvas.ChmMol

::ChmMol

__init__(*args, **kwargs)

addAtom(self, arg2)

addBond(self, a1, a2, order=Single) → ChmBond

addDoubleBond(self, a1, a2, cisTrans=BondNotApplicable)

addMoleculeRaw(self, arg2, arg3)

addSingleBond(self, a1, a2)

addTripleBond(self, a1, a2)

addZeroOrderBond(self, a1, a2)

areBonded(self, atomIndex1, atomIndex2) → bool

checkCoords(self)

checkStereo(self)

chiralCenters(self, includeUndefined=False) → int

chmtostring(self) → std::string

cisTransBonds(self) → int

clear(self)

clearAtomProperty(self, atom, key)

clearConfs(self)

clearCoords(self)

clearProperties(self)

clone(self, randomizeNumbering=False, atomsToDiscard=None, raw=False) → ChmMol

cloneProperties(self, mol)

deleteProperty(self, key)

destroyAtom(self, arg2, packIndices=True)

destroyAtom(self, index, packIndices=True) → None

destroyBond(self, bond)

destroyBond(self, index) → None

static fromMAE(maeString) → ChmMol

static fromMDL(arg1, autoName=False, validateCisTrans=False, perceiveHybridization=True, rigorousAromaticity=True) → ChmMol

static fromSMILES()

genCoords(self)

getAtom(self, arg2) → ChmAtom

getAtomCount(self, wantImplicitHydrogens=False) → int

getAtoms(self, wantImplicitHydrogens=False) → ChmAtoms

getAtomsByMask(self, mask) → ChmAtoms

getBond(self, arg2) → ChmBond

getBond(self, a1, a2) → ChmBond

getBondCount(self, wantImplicitHydrogens=False) → int

getBondMaskForAtomMask(self, atomMask) → ChmBitset

getBonds(self, wantImplicitHydrogens=False) → ChmBonds

getBondsForAtomMask(self, atomMask) → ChmBonds

getComponentCount(self) → uint

getConformation(self, arg2) → ChmConformation

getConformationCount(self) → int

getConnectionTable(self, wantImplicitHydrogens=False) → ChmSymmetricMatrixUnsignedInt

getConnectionTableWithBondOrders(self, wantImplicitHydrogens=False, wantMaeOrder=False) → ChmSymmetricMatrixUnsignedInt

getCoordinates(self, coords)

getDistanceMatrix(self, wantImplicitHydrogens=False, storeInfiniteDistancesAsZero=True, throwExceptionIfMultipleFragments=False) → ChmSymmetricMatrixUnsignedInt

getDistanceMatrix3D(self, wantImplicitHydrogens=False, wantRoot=True) → ChmSymmetricMatrix< float >

getFirstImplicitHydrogenIndex(self) → int

getHash(self) → uint

getHash64(self) → uint64

getHeavyAtomCount(self) → int

getHeavyAtoms(self) → ChmAtoms

getHeavyBondCount(self) → int

getHeavyBonds(self) → ChmBonds

getMW(self) → double

getName(self) → std::string

getNetCharge(self) → int

getProperties(self) → PROPDATA

getPropertiesBegin(self) → CHMMOLPROPINFO::const_iterator

getPropertiesEnd(self) → CHMMOLPROPINFO::const_iterator

getPropertiesFor(self, atom) → std::vector< PROPPAIR,std::allocator< PROPPAIR > >

getPropertiesFor(self, bond) → std::vector< PROPPAIR,std::allocator< PROPPAIR > >

getProperty(self, arg2) → std::string

getPropertyCount(self) → size_t

getPropertyForAtom(self, arg2, arg3) → std::string

getPropertyForBond(self, arg2, arg3) → std::string

getRingCount(self, deterministic=False) → int

getRotatableBonds(self) → ChmBonds

getSMARTS(self, arg2=H_Default, arg3=X_Default, wantStereo=False, wantMapping=False, atomMappings=None, useAtomicNumberOnAcyclicAtoms=False, useBaseOne=False, wantCharge=True) → std::string

getSMARTS(self, atomMask, bondMask, markRings=False, arg5=H_Default, arg6=X_Default, wantStereo=False, wantMapping=False, overrideAtomLabels=None, overrideBondLabels=None, atomMappings=None, useAtomicNumberOnAcyclicAtoms=False, useBaseOne=False, wantCharge=True) → std::string

getSMARTS(self, atomMask, markRings=False, arg4=H_Default, arg5=X_Default, wantStereo=False, wantMapping=False, atomMappings=None, useAtomicNumberOnAcyclicAtoms=False, useBaseOne=False, wantCharge=True) → std::string

getSMARTS(self, atomInfo, bondInfo, arg4=H_Default, arg5=X_Default, wantStereo=True, wantMapping=False, atomMappings=None, useAtomicNumberOnAcyclicAtoms=False, useBaseOne=False, wantCharge=True) → std::string

getTautomerCode(self, considerEZStereo=True, considerRSStereo=True) → uint

getTautomerCode64(self, considerEZStereo=True, considerRSStereo=True) → uint64

getUserData(self) → uint

getZeroOrderBonds(self) → std::vector< CHMZOBITEM,std::allocator< CHMZOBITEM > >

has2DCoords(self, duplicateOK=False, implicitToo=True) → bool

has3DCoords(self, duplicateOK=False, implicitToo=True) → bool

hasAllHydrogens(self) → bool

hasBondDirectionHint(self) → bool

hasCoords(self) → bool

hasDistinctCoords(self, arg2=H_ExplicitOnly) → bool

hasImplicitHydrogens(self) → bool

hasIsotope(self) → bool

hasProperty(self, arg2) → bool

isEmpty(self) → bool

isKekulized(self) → bool

kekulize(self)

makeWildcard(self)

markHydrogens(self, arg2) → int

markProchiral(self, onlyTerminal=False)

needsBondDirectionHint(self) → bool

neutralize(self)

packIndices(self) → bool

perceiveHybridization(self)

perceiveHydrogens(self, wantRadicals=False)

perceiveRings(self, rigorousAromaticity=False, force=False)

placeHydrogens(self)

removeAtom(self, atom, packIndices=True)

removeAtomByIndex(self, index, packIndices=True)

removeAtoms(self, atoms, packIndices=True)

removeFormalCharges(self)

removeHydrogens(self, hydrogenTreatment)

removeHydrogens(self) → None

removeImplicitHydrogens(self)

removeNonPolarHydrogens(self)

setAbsoluteChiralityFlag(self, on)

setAtomProperty(self, atom, key, value)

setBondProperty(self, bond, key, value)

setCoordinates(self, newCoords)

setMaeProperty(self, key, value)

setMaeProperty(self, key, value) → None

setMaeProperty(self, key, value, precision=DEFAULT_PROP_PRECISION) → None

setMaeProperty(self, key, value) → None

setName(self, arg2)

setProperty()

setUserData(self, data)

store(self, os, wantCoordinates=True, overrideName=None)

subset(self, desiredAtoms, breakAliphaticRings=True, breakAromaticRings=False) → ChmMol

toCanonicalSMILES(self, wantAllH=False, test=False) → std::string

toChmQuery(self, allH=False, wantX=False) → ChmQuery

toChmQuery(self, atomInfo, bondInfo) → ChmQuery

toGenericSMARTS(self, wantBondOrder=False, wantCharge=False, wantAromaticity=False, genericAtomToo=False, wantStereo=False, wantAllHydrogens=False, wantAllClosureBonds=False) → std::string

toMAE(self, wantProperties, addH) → std::string

toMDL(self, arg2=H_Default, withprops=True, withCoords=True, overrideName=None, v3format=0, wantDollarSigns=True, echoMaeType=False, check=False) → std::string

toMDL(self, os, arg3=H_Default, withprops=True, withCoords=True, overrideName=None, v3format=0, wantDollarSigns=True, echoMaeType=False, check=False) → None

toSMILES(self, wantKekulized=False, wantAllH=False, wantStereo=True, wantCharge=True, test=False, forceOrder=False, rigorousAromaticity=True) → std::string

toString(self) → std::string

toUniqueSMILES(self, wantAllH=False, test=False) → std::string

translateAlleneStereo(self, atomChain, MorP)

translateCisTransStereo(self, atomChain, CisTrans, permissive=0)

translateTetrahedralStereo(self, central, priorities, RorS, permissive=0)

undefinedChiralCenters(self) → int

unmarkProchiral(self)

validateCisTrans(self)

schrodinger.infra.canvas.ChmMol_fromMAE(maeString) → ChmMol

schrodinger.infra.canvas.ChmMol_fromMDL(arg1, autoName=False, validateCisTrans=False, perceiveHybridization=True, rigorousAromaticity=True) → ChmMol

schrodinger.infra.canvas.ChmMol_fromSMILES()

class schrodinger.infra.canvas.ChmMolprint2D32

::ChmMolprint2D32

__init__(*args, **kwargs)

generate(self, mol, distanceMatrix=None) → ChmSparseBitset

generateMap(self, mol, distanceMatrix=None) → ChmFPMap32

class schrodinger.infra.canvas.ChmMolprint2D64

::ChmMolprint2D64

__init__(*args, **kwargs)

generate(self, mol, distanceMatrix=None) → ChmSparseBitset64

generateMap(self, mol, distanceMatrix=None) → ChmFPMap64

class schrodinger.infra.canvas.ChmMultiYDelimitedPatterns

::ChmMultiYDelimitedPatterns

__init__(*args, **kwargs)

close(self)

getAllColNames(self) → std::vector< std::string,std::allocator< std::string > >

getDelimiter(self) → char

getFirstObsColumnAsDoubles(self) → std::vector< double,std::allocator< double > >

getIncludedColIndexes(self) → std::vector< size_t,std::allocator< size_t > >

getIncludedColNames(self) → std::vector< std::string,std::allocator< std::string > >

getIncludedCols(self) → size_t

getIncludedXvarNames(self, indexes) → std::vector< std::string,std::allocator< std::string > >

getLastLine(self) → std::string

getNumericalColNames(self) → std::vector< std::string,std::allocator< std::string > >

getObservationIncludedIndexes(self) → std::vector< size_t,std::allocator< size_t > >

getObservationIndexes(self) → std::vector< size_t,std::allocator< size_t > >

getObservationNames(self) → std::vector< std::string,std::allocator< std::string > >

getTotalCols(self) → size_t

getValuesOfColumn(self, index, values)

hasHeader(self) → bool

setObservationNames(self, names)

skip(self)

class schrodinger.infra.canvas.ChmObjChmAtomImpl

::ChmObj< ChmAtomImpl >

__init__(*args, **kwargs)

chmtostring(self) → std::string

debug(self) → std::string

getUID(self) → size_t

isValid(self) → bool

class schrodinger.infra.canvas.ChmObjChmAtomTyperImpl

::ChmObj< ChmAtomTyperImpl >

__init__(*args, **kwargs)

chmtostring(self) → std::string

debug(self) → std::string

getUID(self) → size_t

isValid(self) → bool

class schrodinger.infra.canvas.ChmObjChmMatcherImpl

::ChmObj< ChmSmartsMatcherImpl >

__init__(*args, **kwargs)

chmtostring(self) → std::string

debug(self) → std::string

getUID(self) → size_t

isValid(self) → bool

class schrodinger.infra.canvas.ChmObjChmQueryImpl

::ChmObj< ChmQueryImpl >

__init__(*args, **kwargs)

chmtostring(self) → std::string

debug(self) → std::string

getUID(self) → size_t

isValid(self) → bool

class schrodinger.infra.canvas.ChmPLSParser

::ChmPLSParser

__init__(*args, **kwargs)

getLoading(self, var, pcIndex) → std::string

getMaxFactor(self) → size_t

getMinFactor(self) → size_t

getNumObsInTrainingTestTotal(self) → std::vector< int,std::allocator< int > >

getNumOfXvarsWithLoading(self) → size_t

getPearsonR(self, numFactor) → std::string

getQsqr(self, numFactor) → std::string

getRegF(self, numFactor) → std::string

getRegP(self, numFactor) → std::string

getRsqr(self, numFactor) → std::string

getRsqrCv(self, numFactor) → std::string

getSD(self, numFactor) → std::string

getStability(self, numFactor) → std::string

getTestSetObs(self) → std::vector< std::string,std::allocator< std::string > >

getTestSetPred(self, numFactor) → std::vector< std::string,std::allocator< std::string > >

getTestSetRMSE(self, numFactor) → std::string

getTrainingSetObs(self) → std::vector< std::string,std::allocator< std::string > >

getTrainingSetPred(self, numFactor) → std::vector< std::string,std::allocator< std::string > >

getVariableNames(self) → std::vector< std::string,std::allocator< std::string > >

getYvar(self) → std::string

hasLoading(self, var) → bool

haveTestSet(self) → bool

haveTrainingSet(self) → bool

writePredictions(self, filename, namefield='name', delim='\t', extraParameter=-1)

class schrodinger.infra.canvas.ChmPairwiseFPIn

::ChmPairwiseFPIn

__init__(*args, **kwargs)

cols(self) → size_t

getColumn(self, column, columnData, castAsDistances=False)

getColumn(self, column, columnData, castAsDistances=False) → None

getColumnName(self, index) → std::string

getColumnNames(self) → std::vector< std::string,std::allocator< std::string > > const &

getData(self, castAsDistances=False) → std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >

getData(self, data, castAsDistances=False) → None

getData(self, data, rowIDs, castAsDistances=False) → None

getData(self, data, castAsDistances=False) → None

getData(self, data, rowIDs, castAsDistances=False) → None

getData(self, data, castAsDistances=False) → None

getData(self, data, rowIDs, castAsDistances=False) → None

getRow(self, index, castAsDistances=False) → std::vector< float,std::allocator< float > >

getRow(self, index, row, castAsDistances=False) → bool

getRow(self, index, row, name, castAsDistances=False) → bool

getRowName(self, index) → std::string

isDistanceMatrix(self) → bool

isSimilarityMatrix(self) → bool

isSquare(self) → bool

isSymmetric(self) → bool

isValid(self) → bool

rows(self) → size_t

sortFilter(self, outputFileName, mode, topR=0, topC=0, outputFormat=0)

class schrodinger.infra.canvas.ChmPairwiseFPOut

::ChmPairwiseFPOut

__init__(*args, **kwargs)

formatBinary = 0

formatCSV = 1

formatLong = 3

formatWide = 2

getFlattening(self) → double

getHumanReadable(self) → bool

getLowerBound(self) → double

getMaximumViolations(self) → int

getMetric(self) → ChmMetricStyle

getOutputType(self) → ChmPairwiseFPOut::outputType

getUpperBound(self) → double

hasLowerBound(self) → bool

hasUpperBound(self) → bool

process(self, fpFileName, readBlockSize=1000)

process(self, fpFileName, start, end, readBlockSize=1000) → None

process(self, fpFileName1, fpFileName2, readBlockSize=1000) → None

process(self, fpFileName1, start1, end1, fpFileName2, start2, end2, readBlockSize=1000) → None

process(self, fpFileName1, start1, end1, fpFileName2, readBlockSize=1000) → None

process(self, fpFileName1, fpFileName2, start2, end2, readBlockSize=1000) → None

setCustomMetric(self, metric)

setFlattening(self, value=25)

setHumanReadable(self, on)

setLowerBound(self, value)

setMaximumViolations(self, value)

setMetric(self, style)

setOutputType(self, on)

setTverskyMetric(self, alpha, beta)

setUpperBound(self, value)

class schrodinger.infra.canvas.ChmPairwiseFPOut32

::ChmPairwiseFPOut32

__init__(*args, **kwargs)

getFlattening(self) → double

getHumanReadable(self) → bool

getLowerBound(self) → double

getMaximumViolations(self) → int

getMetric(self) → ChmMetricStyle

getOutputType(self) → ChmPairwiseFPOut::outputType

getUpperBound(self) → double

hasLowerBound(self) → bool

hasUpperBound(self) → bool

process(self, fpFileName, readBlockSize=1000)

process(self, fpFileName, start, end, readBlockSize=1000) → None

process(self, fpFileName1, fpFileName2, readBlockSize=1000) → None

process(self, fpFileName1, start1, end1, fpFileName2, start2, end2, readBlockSize=1000) → None

setCustomMetric(self, metric)

setFlattening(self, value=25)

setHumanReadable(self, on)

setLowerBound(self, value)

setMaximumViolations(self, value)

setMetric(self, style)

setOutputType(self, on)

setUpperBound(self, value)

class schrodinger.infra.canvas.ChmPairwiseFPOut64

::ChmPairwiseFPOut64

__init__(*args, **kwargs)

getFlattening(self) → double

getHumanReadable(self) → bool

getLowerBound(self) → double

getMaximumViolations(self) → int

getMetric(self) → ChmMetricStyle

getOutputType(self) → ChmPairwiseFPOut::outputType

getUpperBound(self) → double

hasLowerBound(self) → bool

hasUpperBound(self) → bool

process(self, fpFileName, readBlockSize=1000)

process(self, fpFileName, start, end, readBlockSize=1000) → None

process(self, fpFileName1, fpFileName2, readBlockSize=1000) → None

process(self, fpFileName1, start1, end1, fpFileName2, start2, end2, readBlockSize=1000) → None

setCustomMetric(self, metric)

setFlattening(self, value=25)

setHumanReadable(self, on)

setLowerBound(self, value)

setMaximumViolations(self, value)

setMetric(self, style)

setOutputType(self, on)

setUpperBound(self, value)

class schrodinger.infra.canvas.ChmPairwiseOut32

::ChmPairwiseOut32

__init__(*args, **kwargs)

generate(self, mol, distanceMatrix=None) → ChmSparseBitset

generate(self, distanceMatrix) → ChmSparseBitset

generateMap(self, mol, distanceMatrix=None) → ChmFPMap32

generateMap(self, distanceMatrix) → ChmFPMap32

set3D(self, on)

setBinWidth(self, width)

setFuzzyDistance(self, fuzzy)

setMaxDistance(self, max)

setMinDistance(self, min)

class schrodinger.infra.canvas.ChmPairwiseOut64

::ChmPairwiseOut64

__init__(*args, **kwargs)

generate(self, mol, distanceMatrix=None) → ChmSparseBitset64

generate(self, distanceMatrix) → ChmSparseBitset64

generateMap(self, mol, distanceMatrix=None) → ChmFPMap64

generateMap(self, distanceMatrix) → ChmFPMap64

set3D(self, on)

setBinWidth(self, width)

setFuzzyDistance(self, fuzzy)

setMaxDistance(self, max)

setMinDistance(self, min)

class schrodinger.infra.canvas.ChmPathTools

::ChmPathTools

__init__(*args, **kwargs)

static classifyAtoms(mol, atomClasses)

static computeLaplacian(mol) → ChmSymmetricMatrix< int >

static computeLaplacian(connectionTable, degrees) → ChmSymmetricMatrix< int >

static computePathsUpToLength(mol, length) → ChmSymmetricMatrixUnsignedInt

static computeShortestPaths(connectionTable, zeroOutDisconnected=True, throwExceptionIfDisconnnected=True) → ChmSymmetricMatrixUnsignedInt

static deriveMapping(source, sourcemcs, reference, referencemcs, mapatoms, mapbonds, rmsd, flipY) → std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >

static deriveMapping(source, reference, alignBy, rmsd, flipY) → std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >

static fuseRings(n)

static getComponentCount(mol) → uint

static getComponents(mol) → std::vector< ChmMol,std::allocator< ChmMol > >

static getComponents(mol, mappings) → std::vector< ChmMol,std::allocator< ChmMol > >

static getComponentsMappings(mol) → std::vector< std::vector< uint,std::allocator< uint > >,std::allocator< std::vector< uint,std::allocator< uint > > > >

static getCoreAtoms(mol, desiredHeavyAtomCount=20, binWidth=0.5) → ChmBitset

static getDistancesToCentroid(data, distancesToCentroid)

static getFeaturePaths(mol, atomsFeature1, atomsFeature2)

static getSSSR(mol, deterministic=False)

static getSSSRAndAcyclicAtoms(mol, deterministic=False)

static getShortestPathsBetweenAtoms(mol, startAtomIndex, endAtomIndex)

static getShortestPathsBetweenAtomsWithSideChains(mol, startAtomIndex, endAtomIndex)

static getSymmetryGroups(mol, groups, wantEZStereo=True, wantRSStereo=True, wantHydrogens=False, depth=10, atomTyping=7)

static getmmsymLikeGroup(mol, atomTyping) → std::vector< int,std::allocator< int > >

static isConnected(mol) → bool

static scoreConnections(mol, atom, ignoreAtoms, wantRingLogic) → std::vector< connectInfo,std::allocator< connectInfo > >

static scoreConnections(mol, bond, ignoreAtoms) → std::vector< connectInfo,std::allocator< connectInfo > >

static strip(mol) → ChmMol

static stripToScaffold(mol) → ChmMol

schrodinger.infra.canvas.ChmPathTools_classifyAtoms(mol, atomClasses)

schrodinger.infra.canvas.ChmPathTools_computeLaplacian(mol) → ChmSymmetricMatrix< int >

schrodinger.infra.canvas.ChmPathTools_computeLaplacian(connectionTable, degrees) → ChmSymmetricMatrix< int >

schrodinger.infra.canvas.ChmPathTools_computePathsUpToLength(mol, length) → ChmSymmetricMatrixUnsignedInt

schrodinger.infra.canvas.ChmPathTools_computeShortestPaths(connectionTable, zeroOutDisconnected=True, throwExceptionIfDisconnnected=True) → ChmSymmetricMatrixUnsignedInt

schrodinger.infra.canvas.ChmPathTools_deriveMapping(source, sourcemcs, reference, referencemcs, mapatoms, mapbonds, rmsd, flipY) → std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >

schrodinger.infra.canvas.ChmPathTools_deriveMapping(source, reference, alignBy, rmsd, flipY) → std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >

schrodinger.infra.canvas.ChmPathTools_fuseRings(n)

schrodinger.infra.canvas.ChmPathTools_getComponentCount(mol) → uint

schrodinger.infra.canvas.ChmPathTools_getComponents(mol) → std::vector< ChmMol,std::allocator< ChmMol > >

schrodinger.infra.canvas.ChmPathTools_getComponents(mol, mappings) → std::vector< ChmMol,std::allocator< ChmMol > >

schrodinger.infra.canvas.ChmPathTools_getComponentsMappings(mol) → std::vector< std::vector< uint,std::allocator< uint > >,std::allocator< std::vector< uint,std::allocator< uint > > > >

schrodinger.infra.canvas.ChmPathTools_getCoreAtoms(mol, desiredHeavyAtomCount=20, binWidth=0.5) → ChmBitset

schrodinger.infra.canvas.ChmPathTools_getDistancesToCentroid(data, distancesToCentroid)

schrodinger.infra.canvas.ChmPathTools_getFeaturePaths(mol, atomsFeature1, atomsFeature2)

schrodinger.infra.canvas.ChmPathTools_getSSSR(mol, deterministic=False)

schrodinger.infra.canvas.ChmPathTools_getSSSRAndAcyclicAtoms(mol, deterministic=False)

schrodinger.infra.canvas.ChmPathTools_getShortestPathsBetweenAtoms(mol, startAtomIndex, endAtomIndex)

schrodinger.infra.canvas.ChmPathTools_getShortestPathsBetweenAtomsWithSideChains(mol, startAtomIndex, endAtomIndex)

schrodinger.infra.canvas.ChmPathTools_getSymmetryGroups(mol, groups, wantEZStereo=True, wantRSStereo=True, wantHydrogens=False, depth=10, atomTyping=7)

schrodinger.infra.canvas.ChmPathTools_getmmsymLikeGroup(mol, atomTyping) → std::vector< int,std::allocator< int > >

schrodinger.infra.canvas.ChmPathTools_isConnected(mol) → bool

schrodinger.infra.canvas.ChmPathTools_scoreConnections(mol, atom, ignoreAtoms, wantRingLogic) → std::vector< connectInfo,std::allocator< connectInfo > >

schrodinger.infra.canvas.ChmPathTools_scoreConnections(mol, bond, ignoreAtoms) → std::vector< connectInfo,std::allocator< connectInfo > >

schrodinger.infra.canvas.ChmPathTools_strip(mol) → ChmMol

schrodinger.infra.canvas.ChmPathTools_stripToScaffold(mol) → ChmMol

class schrodinger.infra.canvas.ChmPattern

::ChmPattern

__init__(*args, **kwargs)

__len__()

Return len(self).

allNumAsDouble(self) → std::vector< double,std::allocator< double > >

chmtostring(self) → std::string

empty(self) → bool

getDouble(self, index) → double

getID(self) → std::string

getString(self, index, wasQuoted=None) → std::string

size(self) → uint

class schrodinger.infra.canvas.ChmPatterns

::ChmPatterns

__init__(*args, **kwargs)

getBitMask(self) → ChmBitset

getColMask(self) → ChmBitset

getColumnName(self, index) → std::string

getRowMask(self) → ChmBitset

hasNext(self) → bool

isNumericalCol(self, index) → bool

nextPattern(self) → ChmPattern

numericalCols(self) → size_t

rewind(self)

setBitMask(self, mask)

setColMask(self, mask)

setRowMask(self, mask)

skip(self, numberOfRows=1)

class schrodinger.infra.canvas.ChmProfiler

::ChmProfiler

__init__(*args, **kwargs)

compute(self, smiles, id)

compute(self, smiles, id, prop_pairs) → None

getFingerprintCopy(self) → ChmSparseBitset

getFingerprintRef(self) → ChmSparseBitset

getPropertyPairs(self) → ChmProfilerPropPairs const &

getRequestedProperties(self) → std::vector< std::string,std::allocator< std::string > > const &

static get_num_aromatic_rings(mol) → int

static get_num_rotatable_bonds(mol) → int

schrodinger.infra.canvas.ChmProfiler_get_num_aromatic_rings(mol) → int

schrodinger.infra.canvas.ChmProfiler_get_num_rotatable_bonds(mol) → int

class schrodinger.infra.canvas.ChmQuartetOut32

::ChmQuartetOut32

__init__(*args, **kwargs)

generate(self, mol, distanceMatrix=None) → ChmSparseBitset

generate(self, distanceMatrix) → ChmSparseBitset

generateMap(self, mol, distanceMatrix=None) → ChmFPMap32

generateMap(self, distanceMatrix) → ChmFPMap32

set3D(self, on)

setBinWidth(self, width)

setFuzzyDistance(self, fuzzy)

setMaxDistance(self, max)

setMinDistance(self, min)

class schrodinger.infra.canvas.ChmQuartetOut64

::ChmQuartetOut64

__init__(*args, **kwargs)

generate(self, mol, distanceMatrix=None) → ChmSparseBitset64

generate(self, distanceMatrix) → ChmSparseBitset64

generateMap(self, mol, distanceMatrix=None) → ChmFPMap64

generateMap(self, distanceMatrix) → ChmFPMap64

set3D(self, on)

setBinWidth(self, width)

setFuzzyDistance(self, fuzzy)

setMaxDistance(self, max)

setMinDistance(self, min)

class schrodinger.infra.canvas.ChmQuery

::ChmQuery

MDL = 3

SMARTS = 2

SMILES = 1

UNKNOWN = 0

__init__(*args, **kwargs)

clear(self)

clone(self) → ChmQuery

debug(self, os=std::cout, indent="")

static fromMDL(molData, v3, wantX) → ChmQuery

static fromMDLFile(source, v3, wantX) → ChmQuery

static fromMDLFile(fileName, v3, wantX) → ChmQuery

static fromSMARTS(smarts) → ChmQuery

static fromStream(inputstream) → ChmQuery

getABInfo(self, arg2, arg3, hydrogenOk) → ChmMol

getAtomCount(self) → int

getBondCount(self) → int

getFragmentCount(self) → int

getSearchKey(self) → ChmSearchKey

getSource(self) → std::string const &

getSourceType(self) → ChmQuery::sourceType

involvesAromaticity(self) → bool

involvesCisTrans(self) → bool

involvesHybridization(self) → bool

isIndexable(self) → bool

mapToSource(self, pos) → int

store(self, os)

toSMARTS(self) → std::string

static validateSMARTS(smarts) → std::pair< bool,std::string >

class schrodinger.infra.canvas.ChmQueryMatcher

::ChmQueryMatcher

__init__(*args, **kwargs)

clear(self)

clone(self) → ChmQueryMatcher

getAllowRelativeStereoMatches(self) → bool

getHydrogensInterchangeable(self) → bool

getImplicitHydrogensIgnored(self) → bool

getMatchCountLimit(self) → int

getUniqueFilter(self) → bool

hasExactMatch(self, query, mol) → bool

hasMatch(self, query, mol) → bool

hasMatchStartingWith(self, query, mol, startingAtom) → bool

hideMatched(self, query, mol)

hideNonMatched(self, query, mol)

match(self, query, mol) → ChmMatches

matchCount(self, query, mol) → int

matchEx(self, query, mol) → ChmMatchesEx

matchMask(self, query, mol) → ChmBitsetIterator

matchMaskSubset(self, query, mol, subset) → ChmBitsetIterator

matchMasks(self, query, mol) → ChmAtomAndBondMasks

matchSubset(self, query, mol, subset) → ChmMatches

matchTo(self, query, mol, startingAtom) → ChmMatches

matchToEx(self, query, mol, startingAtom) → ChmMatchesEx

matchToMask(self, query, mol, startingAtom) → ChmBitsetIterator

setAllowRelativeStereoMatches(self, on)

setHydrogensInterchangeable(self, on)

setImplicitHydrogensIgnored(self, on)

setMatchCountLimit(self, limit)

setUniqueFilter(self, on)

schrodinger.infra.canvas.ChmQuery_fromMDL(molData, v3, wantX) → ChmQuery

schrodinger.infra.canvas.ChmQuery_fromMDLFile(source, v3, wantX) → ChmQuery

schrodinger.infra.canvas.ChmQuery_fromMDLFile(fileName, v3, wantX) → ChmQuery

schrodinger.infra.canvas.ChmQuery_fromSMARTS(smarts) → ChmQuery

schrodinger.infra.canvas.ChmQuery_fromStream(inputstream) → ChmQuery

schrodinger.infra.canvas.ChmQuery_validateSMARTS(smarts) → std::pair< bool,std::string >

class schrodinger.infra.canvas.ChmRadialOut32

::ChmRadialOut32

__init__(*args, **kwargs)

generate(self, mol, distanceMatrix=None) → ChmSparseBitset

generateMap(self, mol, distanceMatrix=None) → ChmFPMap32

getConsiderHydrogens(self) → bool

getConsiderStereoEZ(self) → bool

getConsiderStereoRS(self) → bool

getIterations(self) → int

getMinSize(self) → uint

setConsiderHydrogens(self, on)

setConsiderStereoEZ(self, on)

setConsiderStereoRS(self, on)

setIterations(self, iterations_)

setMinSize(self, minSize_)

class schrodinger.infra.canvas.ChmRadialOut64

::ChmRadialOut64

__init__(*args, **kwargs)

generate(self, mol, distanceMatrix=None) → ChmSparseBitset64

generateMap(self, mol, distanceMatrix=None) → ChmFPMap64

getConsiderHydrogens(self) → bool

getConsiderStereoEZ(self) → bool

getConsiderStereoRS(self) → bool

getIterations(self) → int

getMinSize(self) → uint

setConsiderHydrogens(self, on)

setConsiderStereoEZ(self, on)

setConsiderStereoRS(self, on)

setIterations(self, iterations_)

setMinSize(self, minSize_)

class schrodinger.infra.canvas.ChmRandom

::ChmRandom

__init__(*args, **kwargs)

static fromSeed(seed) → ChmRandom

nextBitset(self, length, density) → ChmBitset

nextBitset(self, length, onBits) → ChmBitset

nextDouble(self) → double

nextGaussian(self, mean=0.0, stddev=1.0) → double

nextGaussianFast(self, mean=0.0, stddev=1.0) → double

nextInt(self) → uint

nextInt(self, n) → uint

nextInt64(self) → uint64

nextInt64(self, n) → uint64

nextPartition(self, length, numberOfBins, sortEachBin, memberships, binBase=0)

nextSelectWithReplacementSet(self, size, subset)

nextString(self, len) → std::string

nextSubset(self, length, density, subset)

nextSubset(self, length, numberToChoose, subset) → None

schrodinger.infra.canvas.ChmRandom_fromSeed(seed) → ChmRandom

class schrodinger.infra.canvas.ChmRangeFilter

::ChmRangeFilter

__init__(*args, **kwargs)

chmtostring(self) → std::string

count(self) → uint

excludeNext(self) → bool

static fromSubFormat(os) → ChmRangeFilter

getLast(self) → uint

getOpposite(self) → ChmRangeFilter

getOrder(self) → std::vector< uint,std::allocator< uint > > const &

includeNext(self) → bool

isDefault(self) → bool

isEOF(self) → bool

isEverything(self) → bool

isIndefinite(self) → bool

isSorted(self) → bool

static makeFilter(oneBasedLogicalItemsToInclude) → ChmRangeFilter

rewind(self)

store(self, os)

toBitset(self, logicalSize) → ChmBitset

toBitsetExclude(self, logicalSize) → ChmBitset

toSubFormat(self, inputstream)

toVector(self, itemList, toEnd)

schrodinger.infra.canvas.ChmRangeFilter_fromSubFormat(os) → ChmRangeFilter

schrodinger.infra.canvas.ChmRangeFilter_makeFilter(oneBasedLogicalItemsToInclude) → ChmRangeFilter

class schrodinger.infra.canvas.ChmRangeUIDFilter

::ChmRangeUIDFilter

__contains__(key, /)

Return key in self.

__init__(*args, **kwargs)

chmtostring(self) → std::string

contains(self, rhs) → bool

containsKey(self, key) → bool

count(self) → uint64

static fromBlob(raw) → ChmRangeUIDFilter

static fromFile(filename) → ChmRangeUIDFilter

getFirstItem(self) → uint64

getHash(self) → uint

getOrder(self) → std::vector< uint64,std::allocator< uint64 > > const *

hasNext(self) → bool

isEOF(self) → bool

isSorted(self) → bool

logicalSize(self) → uint64

next(self) → int64

rewind(self)

store(self, os)

toBlob(self) → std::string

toCSV(self, os)

toFile(self, filename)

toSQL(self, os)

toSet(self, uids)

toUIDS(self)

schrodinger.infra.canvas.ChmRangeUIDFilter_fromBlob(raw) → ChmRangeUIDFilter

schrodinger.infra.canvas.ChmRangeUIDFilter_fromFile(filename) → ChmRangeUIDFilter

class schrodinger.infra.canvas.ChmRowUIDFilter

::ChmRowUIDFilter

__init__(*args, **kwargs)

static fromFile(filename) → ChmRowUIDFilter

schrodinger.infra.canvas.ChmRowUIDFilter_fromFile(filename) → ChmRowUIDFilter

class schrodinger.infra.canvas.ChmSDReader

::ChmSDReader

__init__(*args, **kwargs)

static estimateRecordCount(filename, scanDepth=1000, isExact=None) → uint64

getError(self) → std::string

getLastRecordInfo(self)

getNameField(self) → std::string const &

getUnionOfDataFields(self, selectStr='1:', isUniform=False, removeNameField=False) → std::vector< std::string,std::allocator< std::string > >

hasError(self) → bool

hasNext(self) → bool

isV3000(self) → bool

next(self) → ChmMol

reset(self)

setNameField(self, nameField)

class schrodinger.infra.canvas.ChmSDReaderImpl

::ChmObj< ChmSDReaderImpl >

__init__(*args, **kwargs)

chmtostring(self) → std::string

debug(self) → std::string

getUID(self) → size_t

isValid(self) → bool

schrodinger.infra.canvas.ChmSDReader_estimateRecordCount(filename, scanDepth=1000, isExact=None) → uint64

class schrodinger.infra.canvas.ChmSMARTSOut32

::ChmSMARTSOut32

__init__(*args, **kwargs)

generate(self, mol, distanceMatrix=None) → ChmSparseBitset

generateMap(self, mol, distanceMatrix=None) → ChmFPMap32

class schrodinger.infra.canvas.ChmSMARTSOut64

::ChmSMARTSOut64

__init__(*args, **kwargs)

generate(self, mol, distanceMatrix=None) → ChmSparseBitset64

generateMap(self, mol, distanceMatrix=None) → ChmFPMap64

class schrodinger.infra.canvas.ChmScaffold

::ChmScaffold

__contains__(key, /)

Return key in self.

__init__(*args, **kwargs)

contains(self, scaffold, countExact=False, embed=False) → bool

contains(self, scaffold, subScaffolds, countExact=False, embed=False) → bool

containsFuzzy(self, scaffold, level=0, countExact=False, embed=False) → bool

containsFuzzy(self, scaffold, subScaffolds, level=0, countExact=False, embed=False) → bool

getAtomCount(self, wantHydrogens=False) → int

getFuzzyScaffold(self, level=0) → std::string

getLinkerAtoms(self, i) → std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >

getLinkerCount(self) → int

getLinkerCount(self, i) → int

getMW(self) → double

getRingPath(self, i, j) → std::vector< int,std::allocator< int > >

getRingSystemAtoms(self, i) → std::vector< int,std::allocator< int > >

getRingSystemCount(self) → int

getRingSystemSize(self, i) → int

getScaffoldMol(self) → ChmMol

getScaffoldSMARTS(self) → std::string

getScaffoldSMILES(self) → std::string

getSubScaffolds(self) → std::vector< ChmScaffold,std::allocator< ChmScaffold > >

class schrodinger.infra.canvas.ChmScaffoldFinder

::ChmScaffoldFinder

__init__(*args, **kwargs)

exportScaffolds(self, outFile, base=0)

exportScaffolds(self, outStream, base=0) → None

getExocyc(self) → std::vector< std::string,std::allocator< std::string > >

getExolink(self) → std::vector< std::string,std::allocator< std::string > >

getScaffold(self, i) → ChmScaffold

getScaffoldCount(self) → int

getScaffoldSources(self, i, embed=False) → std::vector< int,std::allocator< int > >

getScaffoldSourcesCount(self, i, embed=False) → int

getScaffolds(self) → std::vector< ChmScaffold,std::allocator< ChmScaffold > >

getSubScaffolds(self, i, embed=False) → std::vector< int,std::allocator< int > >

getSubScaffoldsCount(self, i, embed=False) → int

getSuperScaffolds(self, i, embed=False) → std::vector< int,std::allocator< int > >

getSuperScaffoldsCount(self, i, embed=False) → int

saveObject(self, outFile)

saveObject(self, outStream) → None

class schrodinger.infra.canvas.ChmScaffoldMatcher

::ChmScaffoldMatcher

__init__(*args, **kwargs)

getFuzzyMatches(self, mol, level=0, embed=False) → std::vector< int,std::allocator< int > >

getFuzzyMatches(self, smiles, level=0, embed=False) → std::vector< int,std::allocator< int > >

getMatches(self, mol, embed=False) → std::vector< int,std::allocator< int > >

getMatches(self, smiles, embed=False) → std::vector< int,std::allocator< int > >

class schrodinger.infra.canvas.ChmSearchKey

::ChmSearchKeyT< 8 >

__init__(*args, **kwargs)

__len__()

Return len(self).

bits(self) → uint

bytes(self) → uint

chmtostring(self) → std::string

clear(self)

count(self) → uint

dbTestIdentity(self, target) → int

dbTestSubstructure(self, target) → int

dbTestSuperstructure(self, target) → int

static fromBinary(arg1) → ChmSearchKey

static fromHex(data) → ChmSearchKey

hash(self) → uint

hash64(self) → uint64

isEmpty(self) → bool

isFull(self) → bool

set(self)

size(self) → uint

testIdentity(self, query) → int

testSubstructure(self, query) → int

testSuperstructure(self, query) → int

toBinary(self) → std::vector< uint64,std::allocator< uint64 > >

toBitset(self) → ChmBitset

toHex(self) → std::string

toSqlite(self) → std::string

toSqlite(self, os) → None

schrodinger.infra.canvas.ChmSearchKey_fromBinary(arg1) → ChmSearchKey

schrodinger.infra.canvas.ChmSearchKey_fromHex(data) → ChmSearchKey

class schrodinger.infra.canvas.ChmSmiles

::ChmSmiles

__init__(*args, **kwargs)

setSmiles(self, smiles)

class schrodinger.infra.canvas.ChmSmilesFileReader

::ChmSmilesFileReader

__init__(*args, **kwargs)

getError(self) → std::string

getFailureCount(self) → size_t

getLastName(self) → std::string

getLastRecordInfo(self, name, moldata)

getLastSMILES(self) → std::string

getSuccessCount(self) → size_t

hasError(self) → bool

hasNextMol(self) → bool

nextMol(self) → ChmMol

skip(self)

class schrodinger.infra.canvas.ChmSmilesGenerator

::ChmSmilesGenerator

__init__(*args, **kwargs)

clone(self) → ChmSmilesGenerator

getSmiles(self, mol, test=False, forceOrder=False, rigorousAromaticy=True) → std::string

getSmiles(self, mol, mapping, test=False, forceOrder=False, rigorousAromaticy=True) → std::string

getSmilesAndMap(self, mol, test=False, forceOrder=False, rigorousAromaticy=True) → std::string

wantAllBondOrders(self, on)

wantAllBondOrders(self) → bool

wantAllClosureBonds(self, on)

wantAllClosureBonds(self) → bool

wantAllHydrogens(self, newval)

wantAllHydrogens(self) → bool

wantAromaticity(self) → bool

wantAromaticity(self, newval) → None

wantAtomicNumber(self) → bool

wantAtomicNumber(self, newval) → None

wantBondOrder(self) → bool

wantBondOrder(self, newval) → None

wantCharge(self) → bool

wantCharge(self, newval) → None

wantKekulized(self) → bool

wantKekulized(self, newval) → None

wantMapping(self) → bool

wantMapping(self, newval) → None

wantStereo(self) → bool

wantStereo(self, newval) → None

class schrodinger.infra.canvas.ChmSparseBitset

::ChmSparseBitset

__contains__(key, /)

Return key in self.

__init__(*args, **kwargs)

__len__(self) → uint64

accumulate(self, total)

accumulate(self, total) → None

chmtostring(self) → std::string

contains(self, rhs) → bool

contains(self, key) → bool

contract(self)

countCommonOff(self, rhs) → uint64

countCommonOff(self, rhs) → uint64

countCommonOn(self, rhs) → uint64

countCommonOn(self, rhs) → uint64

countDifference(self, rhs) → uint64

countDifference(self, rhs) → uint64

static createModal(toCombine) → ChmSparseBitset

density(self) → double

digest(self, arg2)

empty(self) → bool

expand(self, forceBinary=False)

foldXOR(self, dest, scale=7)

foldXOR(self, scale=7) → ChmBitset

static fromBlob(raw) → ChmSparseBitset

static fromString(idstring, logicalSize=static_cast< uint64 >(4294967296ULL)) → ChmSparseBitset

getHash(self) → int

getHash64(self) → int64

getMaxXY(self, rhs) → double

getMaxXY(self, rhs) → double

getMinXY(self, rhs) → double

getMinXY(self, rhs) → double

getScaleType(self) → FingerprintScaleType

getSumX(self) → double

getValue(self, pos) → float

getValues(self) → std::vector< float,std::allocator< float > > const &

getX2(self) → double

getXY(self, rhs) → double

getXY(self, rhs) → double

hasDifference(self, rhs) → bool

hasValues(self, strict) → bool

hasValues(self) → bool

intersects(self, rhs) → bool

isSubsetOf(self, rhs) → bool

move(self, offset)

pack(self)

positionOf(self, key) → int

reduceToBitset(self, size) → ChmBitset

rescale(self, scale)

setCompressedSource(self, cs)

setScaleType(self, type)

setValues(self, values, swap=False)

store(self, sdata)

store(self, os) → None

swap(self, rhs)

toBitset(self) → ChmBitset

toBlob(self) → std::string

toVector(self) → std::vector< ChmSparseBitset::key_type,std::allocator< ChmSparseBitset::key_type > >

class schrodinger.infra.canvas.ChmSparseBitset64

::ChmSparseBitset64

__contains__(key, /)

Return key in self.

__init__(*args, **kwargs)

__len__(self) → uint64

chmtostring(self) → std::string

contains(self, rhs) → bool

contains(self, key) → bool

contract(self)

countCommonOff(self, rhs) → uint64

countCommonOff(self, rhs) → uint64

countCommonOn(self, rhs) → uint64

countCommonOn(self, rhs) → uint64

countDifference(self, rhs) → uint64

countDifference(self, rhs) → uint64

static createModal(toCombine) → ChmSparseBitset64

density(self) → double

digest(self, arg2)

empty(self) → bool

expand(self, forceBinary=False)

foldXOR(self, dest, scale=7)

foldXOR(self, scale=7) → ChmBitset

static fromBlob(raw) → ChmSparseBitset64

static fromString(idstring, logicalSize=static_cast< uint64 >(0ULL)) → ChmSparseBitset64

getHash(self) → int

getHash64(self) → int64

getMaxXY(self, rhs) → double

getMaxXY(self, rhs) → double

getMinXY(self, rhs) → double

getMinXY(self, rhs) → double

getScaleType(self) → FingerprintScaleType

getSumX(self) → double

getValue(self, pos) → float

getValues(self) → std::vector< float,std::allocator< float > > const &

getX2(self) → double

getXY(self, rhs) → double

getXY(self, rhs) → double

hasDifference(self, rhs) → bool

hasValues(self, strict) → bool

hasValues(self) → bool

intersects(self, rhs) → bool

isSubsetOf(self, rhs) → bool

move(self, offset)

pack(self)

positionOf(self, key) → int

reduceToBitset(self, size) → ChmBitset

reduceToBitset64(self, size) → ChmBitset64

rescale(self, scale)

setCompressedSource(self, cs)

setScaleType(self, type)

setValues(self, values, swap=False)

store(self, sdata)

store(self, os) → None

swap(self, rhs)

toBitset(self) → ChmBitset

toBitset64(self) → ChmBitset64

toBlob(self) → std::string

toVector(self) → std::vector< ChmSparseBitset64::key_type,std::allocator< ChmSparseBitset64::key_type > > const

schrodinger.infra.canvas.ChmSparseBitset64_createModal(toCombine) → ChmSparseBitset64

schrodinger.infra.canvas.ChmSparseBitset64_fromBlob(raw) → ChmSparseBitset64

schrodinger.infra.canvas.ChmSparseBitset64_fromString(idstring, logicalSize=static_cast< uint64 >(0ULL)) → ChmSparseBitset64

schrodinger.infra.canvas.ChmSparseBitset_createModal(toCombine) → ChmSparseBitset

schrodinger.infra.canvas.ChmSparseBitset_fromBlob(raw) → ChmSparseBitset

schrodinger.infra.canvas.ChmSparseBitset_fromString(idstring, logicalSize=static_cast< uint64 >(4294967296ULL)) → ChmSparseBitset

class schrodinger.infra.canvas.ChmSymmetricMatrixUnsignedInt

::ChmSymmetricMatrix< uint >

__init__(*args, **kwargs)

fastItem(self, i, j) → unsigned int &

fastReadItem(self, i, j) → unsigned int const &

getItem(self, i, j) → unsigned int

transpose(self) → ChmSymmetricMatrixUnsignedInt

class schrodinger.infra.canvas.ChmTautomericAtomTyper

::ChmTautomericAtomTyper

__init__(*args, **kwargs)

setup(self, considerCharge, considerIsotope)

type(self, mol, arg3=False) → ChmAssignments

class schrodinger.infra.canvas.ChmTopologicalTorsionOut32

::ChmTopologicalTorsionOut32

__init__(*args, **kwargs)

generate(self, mol, distanceMatrix=None) → ChmSparseBitset

generateMap(self, mol, distanceMatrix=None) → ChmFPMap32

class schrodinger.infra.canvas.ChmTopologicalTorsionOut64

::ChmTopologicalTorsionOut64

__init__(*args, **kwargs)

generate(self, mol, distanceMatrix=None) → ChmSparseBitset64

generateMap(self, mol, distanceMatrix=None) → ChmFPMap64

class schrodinger.infra.canvas.ChmTripletOut32

::ChmTripletOut32

__init__(*args, **kwargs)

generate(self, mol, distanceMatrix=None) → ChmSparseBitset

generate(self, distanceMatrix) → ChmSparseBitset

generateMap(self, mol, distanceMatrix=None) → ChmFPMap32

generateMap(self, distanceMatrix) → ChmFPMap32

set3D(self, on)

setBinWidth(self, width)

setFuzzyDistance(self, fuzzy)

setMaxDistance(self, max)

setMinDistance(self, min)

class schrodinger.infra.canvas.ChmTripletOut64

::ChmTripletOut64

__init__(*args, **kwargs)

generate(self, mol, distanceMatrix=None) → ChmSparseBitset64

generate(self, distanceMatrix) → ChmSparseBitset64

generateMap(self, mol, distanceMatrix=None) → ChmFPMap64

generateMap(self, distanceMatrix) → ChmFPMap64

set3D(self, on)

setBinWidth(self, width)

setFuzzyDistance(self, fuzzy)

setMaxDistance(self, max)

setMinDistance(self, min)

class schrodinger.infra.canvas.ChmUniqueSmilesGenerator

::ChmUniqueSmilesGenerator

__init__(*args, **kwargs)

clone(self) → ChmUniqueSmilesGenerator

getHash(self, mol) → uint

getHash(self, uniqueSmiles) → uint

getHash64(self, mol) → uint64

getHash64(self, uniqueSmiles) → uint64

getSmiles(self, mol, test=False) → std::string

getSmilesAndMap(self, mol, test=False) → std::string

wantAllBondOrders(self, on)

wantAllBondOrders(self) → bool

wantAllClosureBonds(self, on)

wantAllClosureBonds(self) → bool

wantAllHydrogens(self, newval)

wantAllHydrogens(self) → bool

wantCharge(self, on)

wantCharge(self) → bool

wantStereo(self) → bool

wantStereo(self, newval) → None

class schrodinger.infra.canvas.ChmValueAssignment

::ChmValueAssignment

__init__(*args, **kwargs)

chmtostring(self) → std::string

getKey(self) → int64

getName(self) → std::string const &

getValue(self) → double

class schrodinger.infra.canvas.ChmValueAssignmentIterator

::ChmIterator< ChmValueAssignment >

__init__(*args, **kwargs)

__len__()

Return len(self).

asVector(self) → std::vector< ChmValueAssignment,std::allocator< ChmValueAssignment > > const &

asVector(self) → std::vector< ChmValueAssignment,std::allocator< ChmValueAssignment > >

at(self, index) → ChmValueAssignment

at(self, index) → ChmValueAssignment

chmtostring(self) → std::string

hasNext(self) → bool

hasPrev(self) → bool

isValid(self) → bool

next(self) → ChmValueAssignment

prev(self) → ChmValueAssignment

rewind(self)

size(self) → int

sort(self)

exception schrodinger.infra.canvas.CtAssertion

exception schrodinger.infra.canvas.CtException

exception schrodinger.infra.canvas.CtMsgException

exception schrodinger.infra.canvas.CtRdrException

schrodinger.infra.canvas.GetEigenVectorAndValues(matrix, eigenVector, eigenValues, dimensions, rank)

class schrodinger.infra.canvas.MCSsettings

::MCSsettings

MCSStop

__init__(*args, **kwargs)

allH

allowDisconnect

atomTyping

collectAfterBond

configuration_problem

deleteInput

elementsToken

exclusive

forceDetail

fromCanvasGUI

getElapsedTime(self) → double

static isFEPAtomtype(x) → bool

static isFEPAtomtype() → bool

isPW

maxCount

minCount

minPathLength

noDetail

nobreakaring

nobreakring

ordinal

outputDelim

outputRequiresCoords

pathLength

prochiral

ringPathLength

scaleXYZ

showAllMatches

shuffleAtomOrder

silent

sortName

throwIfDurationTooLong(self)

timeout

uniqueSMILES

v3SDF

wantH

wantRingCodes

wantX

class schrodinger.infra.canvas.SortChmMCSRecordByScore

::SortChmMCSRecordByScore

__init__(*args, **kwargs)

class schrodinger.infra.canvas.SortChmMCSRecordByScoreAndWeight

::SortChmMCSRecordByScoreAndWeight

__init__(*args, **kwargs)

class schrodinger.infra.canvas.SortChmMCSRecordByWeight

::SortChmMCSRecordByWeight

__init__(*args, **kwargs)

class schrodinger.infra.canvas.XYZ

::XYZ

__init__(*args, **kwargs)

isDefined(self) → bool

x

y

z

schrodinger.infra.canvas.bit_reverse(x) → uint

schrodinger.infra.canvas.checkCanvasElementsLicense(lic1, lic2, elemPass, driver, host, want_exit=True)

schrodinger.infra.canvas.checkLicense(licenseMask, className=None) → int

schrodinger.infra.canvas.chmacos(x) → double

schrodinger.infra.canvas.chmcos(radians) → double

schrodinger.infra.canvas.chmendl(os) → std::ostream &

schrodinger.infra.canvas.chmround(val) → double

schrodinger.infra.canvas.chmsin(radians) → double

schrodinger.infra.canvas.cleanup(molUI)

schrodinger.infra.canvas.cleanup(inner) → None

class schrodinger.infra.canvas.connectInfo

::connectInfo

__init__(*args, **kwargs)

getConnectionOrder(self) → int

m_centralAtom

m_firstAtom

m_restOfAtoms

toString(self) → std::string

schrodinger.infra.canvas.considersOffBits(value) → bool

schrodinger.infra.canvas.createElementsToken() → std::string

schrodinger.infra.canvas.doAnd(x, y, wantPopulationCount) → ChmCompressedBitset

schrodinger.infra.canvas.doAnd(x, y, wantPopulationCount) → ChmCompressedBitset64

schrodinger.infra.canvas.doOr(x, y, wantPopulationCount) → ChmCompressedBitset

schrodinger.infra.canvas.doOr(x, y, wantPopulationCount) → ChmCompressedBitset64

schrodinger.infra.canvas.doXor(x, y, wantPopulationCount) → ChmCompressedBitset

schrodinger.infra.canvas.doXor(x, y, wantPopulationCount) → ChmCompressedBitset64

schrodinger.infra.canvas.getAutoscaleFactor(variance, varianceCutoff) → double

schrodinger.infra.canvas.getFPInfo(filename) → ChmFPTypeInfo

schrodinger.infra.canvas.getFPPrecision(filename) → int

schrodinger.infra.canvas.getMapping(item, outputDelim, onebased) → std::string

schrodinger.infra.canvas.getMetricString(value) → std::string

schrodinger.infra.canvas.getMetricStyle(value) → ChmMetricStyle

schrodinger.infra.canvas.getNumberOfUniqueValues(filename) → uint64

schrodinger.infra.canvas.getSize(overrideSize, logicalSize) → CANVAS_MAXFPLEN_TYPE

schrodinger.infra.canvas.isMetricADistance(value) → bool

schrodinger.infra.canvas.isMetricASimilarity(value) → bool

schrodinger.infra.canvas.isValidSMARTS(smarts) → bool

schrodinger.infra.canvas.makeMask(index) → uint

schrodinger.infra.canvas.makeMaskLL(index) → uint64

schrodinger.infra.canvas.mol2grid(mol, atomProps, dest, sigma)

schrodinger.infra.canvas.nChooseK(bs) → uint64

schrodinger.infra.canvas.openPWM(filename, rowflag, colflag, checkSquare=False, checkDiag=False, checkSingular=False) → ChmPairwiseFPIn

class schrodinger.infra.canvas.optionMDL

::optionMDL

H_All = 3

H_AsWritten = 1

H_Chiral = 4

H_Default = 0

H_Never = 0

H_Polar = 2

H_Visible = 5

__init__(*args, **kwargs)

static translate(val) → ChmAtomOption::H

schrodinger.infra.canvas.optionMDL_translate(val) → ChmAtomOption::H

class schrodinger.infra.canvas.optionSMARTS

::optionSMARTS

H_Always = 1

H_Default = 0

H_Never = -1

H_SMILES_behavior = 0

X_Always = 2

X_AromaticNitrogensOnly = 1

X_Default = 1

X_No = 0

__init__(*args, **kwargs)

schrodinger.infra.canvas.printoutMCS(molecules, mcsItems, outputFile, toMae, toSD, toCSV, colorCode, useMolIndex, v3SDF, onebased, wantUniqueSMILES)

schrodinger.infra.canvas.printoutMCSFromCts(molecules, records, outputFile, colorCode, useMolIndex)

schrodinger.infra.canvas.printoutPWMCS(molecules, rec1, rec2, output, onebasedCSV, wantUniqueSMILES)

schrodinger.infra.canvas.runAllPairwiseMCS(molecules, settings) → std::vector< ChmPairwiseMCSRecord,std::allocator< ChmPairwiseMCSRecord > >

schrodinger.infra.canvas.runMCS(molecules, settings, allow_any_atom_type=False) → std::vector< ChmMCSRecord,std::allocator< ChmMCSRecord > >

schrodinger.infra.canvas.runPairwiseMCS(molecules, settings, whichPairs) → std::vector< ChmPairwiseMCSRecord,std::allocator< ChmPairwiseMCSRecord > >

schrodinger.infra.canvas.transpose(src, dest)

schrodinger.infra.canvas.transpose(src, dest) → None