| The SDL Component Suite is an industry leading collection of components supporting scientific and engineering computing. Please visit the SDL Web site for more information.... |
|
Home  ChemPack CStruct Interface of SDL_CStruct |
|
  |
|
Interface of SDL_CStruct |
|
const
{$IFDEF PAIDVERS}
SDLVersionInfo = 'cstruct_r1210_full';
IsLightEd = false;
{$ELSE}
SDLVersionInfo = 'cstruct_r1210_lighted';
IsLightEd = true;
{$ENDIF}
Release = 1210;
MaxLengCTab = 63; { maximal number of Atoms in Ctab }
MaxConn = 10; { maximal number of connections allowed }
MaxConnOld = 8; { maximal number of connections allowed }
MaxRings = 100; { maximal number of rings in a molecule }
MaxRingSize = 64; { number of atoms of largest ring }
MaxDim = 3; { number of graphics dimensions }
AttribLin = $01; { attribute codes of atoms: linear chain }
Attrib347R = $02; { ring of 3 or 4 or more than 6 atoms }
Attrib5R = $04; { ring of 5 atoms }
Attrib6R = $08; { ring of 6 atoms }
AttribBranch = $10; { branching atom }
AttribAnyR = $20; { any ring }
AttribTerm = $40; { terminating atom }
AttribCondR = $80; { condensed ring atom }
AttribNone = $00; { no attribute }
btNoBond = 0; { bond types: no bond }
btSingle = 1; { single bond }
btDouble = 2; { double bond }
btTriple = 3; { triple bond }
btAromatic = 4; { aromatic bond }
{------------- these few lines are provisional and have been included ---------}
{--- to get a quick solution to the MDL-SD-file problem -----------------------}
const
MaxProps = 20; { PROVISIONAL !! (see below) }
type
TPropRec = record { physical properties as read from MDL SD file }
ID : string[15]; { PROVISIONAL ! clear up things
concerning MDL-SD later }
Par : double;
end;
TProps = array[1..MaxProps] of TPropRec;
{------------------------------------------------------------------------------}
type
SSSMode = (smSkeleton, smAtoms, smBonds, smAtomAndBonds);
{ sub structure search mode }
FrgType = (NSglBnd, { number of single bonds in molecule, aromat. not counted }
NCCSgl, { number of C-C single bonds, aromat. not counted }
NDblBnd, { number of double bonds in molecule, aromat. not counted }
NCCDbl, { number of C-C double bonds, aromat. not counted }
NTrplBnd,{ number of triple bonds in molecule }
NCCTrpl, { number of C-C triple bonds }
NAroBnd, { number of aromatic bonds }
NBranch, { number of branching atoms }
XCnt, { number of halogen atoms in molecule }
COOH, { carbonic acid }
COO, { any -CO-O- group, no matter where, but not a COOH }
NO2, { any nitro group }
AnyCO, { any carbonyl group }
AroCl, { aromatic chlorine atom }
AroBr, { aromatic bromine atom }
AnyOH, { any hydroxyl group }
PhOH, { phenolic OH }
NH2, { terminal amino group - primary amine }
NHR, { secondary amine }
NR2, { tertiary amine }
NCON, { urea derivative }
CN, { nitrile }
CONR2, { amide }
CHO, { aldehyde }
COX, { halogen acid }
AnySO, { any sulfoxide group }
OCH3, { methoxy group }
NO, { nitroso group }
NNH2); { -NH-NH2 or -N=NH }
AtListType = record
NrAtoms : integer;
AtList : array [1..MaxLengCTab] of integer;
end;
AtFlagType = array[1..MaxLengCTab] of byte;
BondListType = array[1..MaxConn] of byte;
RingType = record
RingSize : byte; { size of ring }
AtList : array[1..MaxRingSize] of byte;{ no.s of atoms in ring }
end;
RingListType = record
NrOfRings : integer; { number of valid rings in the ring list }
RList : array [1..MaxRings] of RingType; { list of rings }
end;
CoordUnitType = (cuUnknown, cuPixel, cuNanoM, cuPicoM, cuAngstrom);
CTElem = record
AtNum : byte; { atom number }
AtWeight : byte; { atomic weight of that atom }
AtFlag : byte; { arbitrary working byte }
Attrib : byte; { attributes of atom }
Charge : shortint; { number of charges }
ConnTo : BondListType; { connected atoms }
TypConn : BondListType; { type of connection }
Coords : array[1..MaxDim] of single; { 3D-graphics info }
AtDispAtb: longint; { display attributes used in TChemGraph }
end;
{ TypConn : 1 = single bond
2 = double bond
3 = triple bond
4 = aromatic bond }
{ Attrib : Bit 0 = linear
Bit 1 = 3- or 4-atom ring, or more than 6 atoms
Bit 2 = 5-atom ring
Bit 3 = 6-atom ring
Bit 4 = branch
Bit 5 = any ring atom
Bit 6 = terminating atom
Bit 7 = condensed ring system }
{ AtDispAtb : Bits 0..25 .... color of atom when displayed
Bits 26..27 .... reserved
Bit 28 .... atom has to be displayed in bold
Bit 29 .... atom has to be displayed by inverted colors
Bit 30 .... atom has to be displayed in italic letters
Bit 31 .... display atom with structure default color }
{$IFDEF GE_LEV29}
[ComponentPlatformsAttribute(pidWin32 or pidWin64 or pidWin64x)]
{$ENDIF}
TCTab = class (TComponent)
private
FOnChange : TNotifyEvent;
function GetNBonds (AtIx: integer): integer;
function GetAtNum (AtIx: integer): byte;
procedure SetAtNum (AtIx: integer; AtNum: byte);
function GetAtWeight (AtIx: integer): byte;
procedure SetAtWeight (AtIx: integer; AtWeight: byte);
function GetCharge (AtIx: integer): shortint;
procedure SetCharge (AtIx: integer; Charge: shortint);
function GetAtomEntries (AtIx: integer): CTElem;
procedure SetAtomEntries (AtIx: integer; AE: CTElem);
function GetAtFlag (AtIx: integer): byte;
procedure SetAtFlag (AtIx: integer; AtFlag: byte);
function GetAttrib (AtIx: integer): byte;
procedure SetAttrib (AtIx: integer; Attrib: byte);
function GetCoords (AtIx, DimIx: integer): single;
procedure SetCoords (AtIx, DimIx: integer; Coord: single);
function GetCoordsPresent: boolean;
procedure SetCoordsPresent (value: boolean);
function GetConnTo (AtIx: integer; ConnIx: integer): byte;
procedure SetConnTo (AtIx, ConnIx: integer; ConnTo: byte);
function GetTypConn (AtIx: integer; ConnIx: integer): byte;
procedure SetTypConn (AtIx: integer; ConnIx: integer; Typ: byte);
function GetCASNr: string;
procedure SetCASNr (InString: string);
function CheckCASNr (CASNum: longint): boolean;
protected
FNumValidAtoms: integer; { number of valid atoms }
FStrucName : string; { name of structure }
FCASNr : longint; { CAS registry number }
FCoordUnit : CoordUnitType; { units of coordinate values }
FAtomEntries : array[1..MaxLengCTab] of CTElem;
public
constructor Create (AOwner: TComponent); override;
destructor Destroy; override;
function AddAtom (AtomRec: CTElem): boolean;
function AtomCount (AtNum: byte): integer;
function CalcAttributes: integer;
function CalcMissingH: integer;
function CalcMolExtents (var MinX, MinY, MaxX, MAxY,
CentX, CentY: double): double;
procedure CalcMolCenter (var spx, spy, spz: double);
function CalcMolecularFormula (var BForm: TFormulaRec): boolean;
function CalcChemMolWeight: double;
procedure Changed;
function CheckConnect (At1,At2: integer): byte;
procedure ClearAttributes;
procedure Clear;
function CompareWith (CTabSource: TCTab): word;
procedure CopyFrom (CTabSource: TCTab);
procedure DeleteAtom (AtomNr: integer);
function FindAtomInBox (x, y, z, XRange, YRange,
ZRange: double): integer;
procedure FindClosestAtom (x,y,z: double; var ClosestAtom: integer;
var Dist: double);
function ContainsUnconnectedAtom: boolean;
procedure EnterConn (AtIx, Connto, TypConn: integer);
function FindNextEndAtom (AtIx: integer): integer;
function FindShortestRings (AtomIx: word;
var RingList: RingListType): integer;
function FindSSSR (var RingList: RingListType): integer;
function FragmentCount (FrgCode: FrgType): integer;
function FragmentCode (AtIx: integer;
var NOuterBonds: integer): longint;
procedure JoinFragment (CTabSource: TCTab);
procedure LinkFragment (CtabSource: TCTab);
function MakeConnection (At1,At2: integer; CType: byte): boolean;
procedure MakeSymmetricConnections;
function MaxNBonds (var AtIx: integer):integer;
procedure MatchAtomTemplate (An, Nb: shortint; TypB: BondListType;
var AtomsMatched: AtListType);
function NrHAtoms (AtIx: integer): integer;
function ReadFromClearTextFile (var AFile: textFile): boolean;
function ReadFromClearTextFileCTABG (var AFile:TextFile): boolean;
function ReadFromMDLCTabFile (var AFile:TextFile): boolean;
function ReadFromMDLCTabStream (InStream: TStream): boolean;
function ReadFromMDLMolStream (InStream: TStream): boolean;
function ReadFromMDLMolFile (var AFile:TextFile): boolean;
function ReadFromMDLSDFile (var AFile:TextFile;
var Props: TProps): boolean;
function ReadConnTabBody (var AFile:TextFile): boolean;
procedure RemoveHydrogen;
function RingsInMolecule: integer;
procedure RotateWithPCA;
function SearchSubStruc (CTabSmall: TCTab;
var MatchedAtoms: AtFlagType;
CompareBonds: boolean): boolean;
function StripfromChains: integer;
function SumForContained (CTabSmall: TCTab): boolean;
procedure WriteToClearTextFile (var AFile:TextFile);
procedure WriteToMDLCTabFile (var TFile:TextFile);
procedure WriteToMDLCTabStream (OutStream: TStream);
procedure WriteToMDLMolFile (var TFile:TextFile; User: ShortString;
ProgName: string; Regnum: longint;
comment: string);
procedure WriteToMDLMolStream (OutStream: TStream; User: ShortString;
ProgName: string; Regnum: longint;
comment: string);
procedure WriteToMolConnXFile (IdNum: integer; var AFile:TextFile);
property AtAttrib [AtIx: integer]: byte
read GetAttrib write SetAttrib;
property AtCharge [AtIx: integer]: shortint
read GetCharge write SetCharge;
property AtCoords [AtIx, DimIx: integer]: single
read GetCoords write SetCoords;
property AtConnTo [AtIx, ConnIx: integer]: byte
read GetConnTo write SetConnTo;
property AtTypConn [AtIx, ConnIx: integer]: byte
read GetTypConn write SetTypConn;
property AtFlag [AtIx: integer]: byte
read GetAtFlag write SetAtFlag;
property AtNum [AtIx: integer]: byte
read GetAtNum write SetAtNum;
property AtWeight [AtIx: integer]: byte
read GetAtWeight write SetAtWeight;
property AtomEntries [AtIx: integer]: CTElem
read GetAtomEntries write SetAtomEntries;
property BinCASNr: longint read FCASNr write FCASNr;
property CoordinatesPresent: boolean
read GetCoordsPresent write SetCoordsPresent;
property NAtoms: integer read FNumValidAtoms write FNumValidAtoms;
property NBonds [AtIx: integer]: integer read GetNBonds;
property CoordUnits: CoordUnitType read FCoordUnit write FCoordUnit;
published
property CASNr: string read GetCASNr write SetCASNr;
property StrucName: string read FStrucName write FStrucName;
property OnChange: TNotifyEvent read FOnChange write FOnChange;
end;
procedure ClearCTElem
(var AtomRec : CTElem);
function RingInRingList
(Ring : RingType;
RingList : RingListType)
: boolean;
function FragmentStr
(InCode : longint)
: string;
|
|
Last Update: 2023-Feb-06