/// <summary>
///
/// </summary>
/// <param name="thisEntryCrystal"></param>
/// <param name="asymChain"></param>
/// <param name="threeLetterSeq"></param>
/// <returns></returns>
private AtomInfo[] ReadChainAtoms(EntryCrystal thisEntryCrystal, string asymChain, out string threeLetterSeq)
{
ChainAtoms chain = null;
threeLetterSeq = "";
for (int i = 0; i < thisEntryCrystal.atomCat.ChainAtomList.Length; i++)
{
if (thisEntryCrystal.atomCat.ChainAtomList[i].AsymChain == asymChain)
{
chain = thisEntryCrystal.atomCat.ChainAtomList[i];
break;
}
}
for (int i = 0; i < thisEntryCrystal.entityCat.EntityInfoList.Length; i++)
{
EntityInfo entityInfo = thisEntryCrystal.entityCat.EntityInfoList[i];
string[] asymChains = entityInfo.asymChains.Split(',');
if (asymChains.Contains(asymChain))
{
threeLetterSeq = entityInfo.threeLetterSeq;
}
}
if (chain == null)
{
return(null);
}
AtomInfo[] chainAtoms = chain.CartnAtoms;
return(chainAtoms);
}
/// <summary>
///
/// </summary>
/// <param name="pdbId"></param>
public void WriteDomainDnaRnaInterfaceFiles(string pdbId)
{
string queryString = string.Format("Select * From PfamDnaRnas Where PdbID = '{0}';", pdbId);
DataTable pfamDnaRnaTable = ProtCidSettings.protcidQuery.Query(queryString);
int[] chainDomainIds = GetEntryChainDomainIds(pfamDnaRnaTable);
queryString = string.Format("Select PdbID, AsymID, PolymerStatus, PolymerType From AsymUnit Where PdbID = '{0}';", pdbId);
DataTable entryAsuTable = ProtCidSettings.pdbfamQuery.Query(queryString);
Dictionary <string, List <string> > buDomainWithMaxHmmHash = new Dictionary <string, List <string> > ();
foreach (int chainDomainId in chainDomainIds)
{
SelectDomainDnaRnaInterfaces(chainDomainId, pfamDnaRnaTable, ref buDomainWithMaxHmmHash);
}
List <string> buIdList = new List <string> (buDomainWithMaxHmmHash.Keys);
string[] buIds = new string[buIdList.Count];
buIdList.CopyTo(buIds);
Dictionary <string, Dictionary <string, AtomInfo[]> > entryBuHash = buGenerator.BuildPdbBus(pdbId, buIds, true);
EntryCrystal thisEntryCrystal = buGenerator.ReadEntryCrystalFromXml(pdbId);
string domainFile = "";
string chainId = "";
string chainSymOp = "";
foreach (string buId in buDomainWithMaxHmmHash.Keys)
{
List <string> domainSymOpList = buDomainWithMaxHmmHash[buId];
string[][] nonProtChainSymOps = GetAllNonProtChainSymOps(pdbId, buId, entryAsuTable);
string[] dnaRnaChainSymOps = nonProtChainSymOps[0];
string[] ligandChainSymOps = nonProtChainSymOps[1];
if (dnaRnaChainSymOps.Length == 0)
{
continue;
}
foreach (string domainSymOp in domainSymOpList)
{
// string[] dnaRnaChains = GetInteractingDnaRnaChainSymOps(pdbId, buId, domainSymOp, pfamDnaRnaTable);
string[] domainSymOpFields = SeparateDomainFields(domainSymOp);
chainId = GetDomainChainId(pdbId, buId, Convert.ToInt32(domainSymOpFields[0]), domainSymOpFields[1], pfamDnaRnaTable);
chainSymOp = chainId + "_" + domainSymOpFields[1];
domainFile = Path.Combine(pfamDnaRnaDir, pdbId + domainSymOpFields[0] + ".pfam");
// WriteDomainDnaRnaInterfaceFiles(pdbId, buId, chainSymOp, dnaRnaChains, buHash, thisEntryCrystal, domainFile);
try
{
WriteDomainDnaRnaInterfaceFiles(pdbId, buId, chainSymOp, dnaRnaChainSymOps, ligandChainSymOps, entryBuHash[buId], thisEntryCrystal, domainFile);
}
catch (Exception ex)
{
ProtCidSettings.logWriter.WriteLine(pdbId + " " + domainSymOp + " domain-DNA/RNA interface error: " + ex.Message);
ProtCidSettings.logWriter.Flush();
}
}
}
}
/// <summary>
/// check the interactions between protein chain and DNA/RNA interactions
/// </summary>
/// <param name="pdbId"></param>
/// <param name="pfamLigandTable"></param>
private void RetrieveChainDnaRnaInteractionsInAsu(string pdbId, string[] protChainNames, string[] dnaRnaChainNames)
{
string gzCoordXmlFile = Path.Combine(ProtCidSettings.dirSettings.coordXmlPath, pdbId + ".xml.gz");
if (!File.Exists(gzCoordXmlFile))
{
ProtCidSettings.progressInfo.progStrQueue.Enqueue(pdbId + ".xml.gz file not exist");
return;
}
string coordXmlFile = ParseHelper.UnZipFile(gzCoordXmlFile, ProtCidSettings.tempDir);
// read data from crystal xml file
XmlSerializer xmlSerializer = new XmlSerializer(typeof(EntryCrystal));
FileStream xmlFileStream = new FileStream(coordXmlFile, FileMode.Open);
EntryCrystal thisEntryCrystal = (EntryCrystal)xmlSerializer.Deserialize(xmlFileStream);
xmlFileStream.Close();
File.Delete(coordXmlFile);
// no coordinates for waters
ChainAtoms[] chains = thisEntryCrystal.atomCat.ChainAtomList;
foreach (string dnaRnaChain in dnaRnaChainNames)
{
AtomInfo[] dnaRnaAtoms = GetChainAtoms(chains, dnaRnaChain);
foreach (string protChainName in protChainNames)
{
AtomInfo[] protChainAtoms = GetChainAtoms(chains, protChainName);
ChainContactInfo contactInfo = atomContact.GetAllChainContactInfo(dnaRnaAtoms, protChainAtoms);
if (contactInfo == null)
{
continue;
}
foreach (string seqPair in contactInfo.atomContactHash.Keys)
{
string[] seqIds = seqPair.Split('_');
AtomPair atomPair = (AtomPair)contactInfo.atomContactHash[seqPair];
double distance = atomPair.distance;
DataRow chainDnaRnaRow = chainDnaRnaTable.NewRow();
chainDnaRnaRow["PdbID"] = pdbId;
chainDnaRnaRow["BuID"] = "0";
chainDnaRnaRow["AsymID"] = dnaRnaChain;
chainDnaRnaRow["SymmetryString"] = "1_555";
chainDnaRnaRow["ChainAsymID"] = protChainName;
chainDnaRnaRow["ChainSymmetryString"] = "1_555";
chainDnaRnaRow["SeqID"] = seqIds[0];
chainDnaRnaRow["ChainSeqID"] = seqIds[1];
chainDnaRnaRow["Distance"] = distance;
chainDnaRnaRow["Atom"] = atomPair.firstAtom.atomName;
chainDnaRnaRow["ChainAtom"] = atomPair.secondAtom.atomName;
chainDnaRnaRow["Residue"] = atomPair.firstAtom.residue;
chainDnaRnaRow["ChainResidue"] = atomPair.secondAtom.residue;
chainDnaRnaTable.Rows.Add(chainDnaRnaRow);
}
}
}
dbInsert.InsertDataIntoDBtables(ProtCidSettings.buCompConnection, chainDnaRnaTable);
chainDnaRnaTable.Clear();
}
/// <summary>
/// Format any PDB xml file to my format
/// </summary>
/// <param name="pdbId"></param>
public string WritePdbXmlToMyCoordXmlFile(string pdbXmlFile)
{
FileInfo fileInfo = new FileInfo(pdbXmlFile);
string pdbCode = fileInfo.Name.Substring(0, 4);
if (!File.Exists(pdbXmlFile))
{
webClient.DownloadFile(pdbWebAddress + fileInfo.Name, pdbXmlFile);
}
if (pdbXmlFile.IndexOf(".gz") > -1)
{
ParseHelper.UnZipFile(pdbXmlFile);
pdbXmlFile = pdbXmlFile.Replace(".gz", "");
}
XmlAtomParser xmlParser = new XmlAtomParser();
EntryCrystal thisEntryCrystal = new EntryCrystal(pdbCode);
try
{
xmlParser.ParseXmlFile(pdbXmlFile, ref thisEntryCrystal, "ALL");
}
catch (Exception ex)
{
// record the error, continue to the next file
string errorMsg = string.Format("Processing {0} file errors: {1}. Skip it.",
pdbCode, ex.Message);
ProtCidSettings.progressInfo.progStrQueue.Enqueue(errorMsg);
}
string coordXmlFile = Path.Combine(fileInfo.DirectoryName, pdbCode + "_coord.xml");
// save entry crystal data into a XML file
try
{
if (thisEntryCrystal != null)
{
XmlSerializer xmlSerializer = new XmlSerializer(thisEntryCrystal.GetType());
TextWriter crystalWriter = new StreamWriter(coordXmlFile);
xmlSerializer.Serialize(crystalWriter, thisEntryCrystal);
crystalWriter.Close();
// ParseHelper.ZipPdbFile(coordXmlFile);
}
}
catch (Exception ex)
{
ProtCidSettings.progressInfo.progStrQueue.Enqueue(ex.Message);
}
return(coordXmlFile);
}
/// <summary>
///
/// </summary>
/// <param name="pdbId"></param>
/// <param name="thisEntryCrystal"></param>
/// <param name="selectedAsymChains"></param>
/// <returns></returns>
public string WriteChainAtomsToPdbFile(string pdbId, EntryCrystal thisEntryCrystal, string[] selectedAsymChains)
{
string[] nonpolymerAsymChains = GetNonpolymerAsymChains(thisEntryCrystal.entityCat.EntityInfoList);
ChainAtoms[] chains = thisEntryCrystal.atomCat.ChainAtomList;
Dictionary <string, AtomInfo[]> asuChainHash = new Dictionary <string, AtomInfo[]> ();
Dictionary <string, string> chainMatchHash = new Dictionary <string, string> ();
List <string> fileChainsInOrderList = new List <string> ();
string fileChain = "";
int chainIndex = 0;
List <string> asymChainsInOrderList = new List <string> ();
foreach (ChainAtoms chain in chains)
{
if (Array.IndexOf(selectedAsymChains, chain.asymChain) > -1)
{
continue;
}
if (chainIndex == ParseHelper.chainLetters.Length)
{
chainIndex = 0;
}
fileChain = ParseHelper.chainLetters[chainIndex].ToString();
asuChainHash.Add(chain.asymChain, chain.CartnAtoms);
chainMatchHash.Add(chain.asymChain, fileChain);
asymChainsInOrderList.Add(chain.asymChain);
fileChainsInOrderList.Add(fileChain);
chainIndex++;
}
string[] fileChains = new string[fileChainsInOrderList.Count];
fileChainsInOrderList.CopyTo(fileChains);
string[] asymChainsInFile = new string[asymChainsInOrderList.Count];
asymChainsInOrderList.CopyTo(asymChainsInFile);
string seqresRecords = GetSeqresRecords(thisEntryCrystal.entityCat, chainMatchHash, asymChainsInFile);
string tempAsuFileName = buWriter.WriteAsymUnitFile(pdbId, asuChainHash, asymChainsInFile, fileChains, nonpolymerAsymChains, ProtCidSettings.tempDir, seqresRecords);
string hashFolder = Path.Combine(pdbTextPath, GetHashFolder(pdbId));
if (!Directory.Exists(hashFolder))
{
Directory.CreateDirectory(hashFolder);
fileCopy.CreateDirectoryInLinux(pdbFilePathInLinux + "/" + pdbId.Substring(1, 2));
}
string asuFileName = Path.Combine(hashFolder, pdbId + ".ent");
File.Move(tempAsuFileName, asuFileName);
return(asuFileName);
}
/// <summary>
/// writer XML coordinates into a PDB text file in which residues are numbered by sequential numbers.
/// </summary>
/// <param name="xmlFile"></param>
public void WriteXmlFileToPdbFile(string pdbId, EntryCrystal thisEntryCrystal)
{
string[] nonpolymerAsymChains = GetNonpolymerAsymChains(thisEntryCrystal.entityCat.EntityInfoList);
ChainAtoms[] chains = thisEntryCrystal.atomCat.ChainAtomList;
Dictionary <string, AtomInfo[]> asuChainHash = new Dictionary <string, AtomInfo[]>();
Dictionary <string, string> chainMatchHash = new Dictionary <string, string> ();
string updateAsymChain = "";
int chainIndex = 26; // the capital letters are used for asymIds
List <string> chainsInOrderList = new List <string> ();
List <string> asymChainsInOrderList = new List <string> ();
foreach (ChainAtoms chain in chains)
{
updateAsymChain = chain.asymChain;
if (chain.AsymChain.Length > 1) // it is a problem in the pdb formatted file
{
if (chainIndex >= ParseHelper.chainLetters.Length)
{
chainIndex = 26;
ProtCidSettings.progressInfo.progStrQueue.Enqueue(pdbId + chain.AsymChain + ": the length of chain name >= 2 and out of chain letters index.");
}
updateAsymChain = ParseHelper.chainLetters[chainIndex].ToString();
chainIndex++;
ProtCidSettings.progressInfo.progStrQueue.Enqueue(pdbId + chain.AsymChain + ": the length of chain name >= 2.");
}
asuChainHash.Add(chain.asymChain, chain.CartnAtoms);
chainMatchHash.Add(chain.asymChain, updateAsymChain);
chainsInOrderList.Add(updateAsymChain);
asymChainsInOrderList.Add(chain.asymChain);
}
string[] fileChains = new string[chainsInOrderList.Count];
chainsInOrderList.CopyTo(fileChains);
string[] asymChainsInFile = new string[asymChainsInOrderList.Count];
asymChainsInOrderList.CopyTo(asymChainsInFile);
string seqresRecords = GetSeqresRecords(thisEntryCrystal.entityCat, chainMatchHash, asymChainsInFile);
string tempAsuFileName = buWriter.WriteAsymUnitFile(pdbId, asuChainHash, asymChainsInFile, fileChains, nonpolymerAsymChains, ProtCidSettings.tempDir, seqresRecords);
string hashFolder = Path.Combine(pdbTextPath, GetHashFolder(pdbId));
if (!Directory.Exists(hashFolder))
{
Directory.CreateDirectory(hashFolder);
fileCopy.CreateDirectoryInLinux(pdbFilePathInLinux + "/" + pdbId.Substring(1, 2));
}
string asuFileName = Path.Combine(hashFolder, pdbId + ".ent");
File.Move(tempAsuFileName, asuFileName);
ParseHelper.ZipPdbFile(asuFileName);
}
/// <summary>
///
/// </summary>
/// <param name="thisEntryCrystal"></param>
/// <param name="asymChain"></param>
/// <returns></returns>
private AtomInfo[] ReadChainAtoms(EntryCrystal thisEntryCrystal, string asymChain)
{
ChainAtoms chain = null;
for (int i = 0; i < thisEntryCrystal.atomCat.ChainAtomList.Length; i++)
{
if (thisEntryCrystal.atomCat.ChainAtomList[i].AsymChain == asymChain)
{
chain = thisEntryCrystal.atomCat.ChainAtomList[i];
break;
}
}
if (chain == null)
{
return(null);
}
AtomInfo[] chainAtoms = chain.CartnAtoms;
return(chainAtoms);
}
/// <summary>
/// update asymmetric unit db table
/// </summary>
/// <param name="thisEntryCrystal"></param>
private void UpdateAsymUnitDbTable(EntryCrystal thisEntryCrystal)
{
string queryString = string.Format("Select * From AsymUnit Where PdbID = '{0}' AND PolymerType = 'polypeptide';",
thisEntryCrystal.PdbId);
DataTable asuTable = ProtCidSettings.pdbfamQuery.Query(queryString);
asuTable.TableName = "AsymUnit";
foreach (ChainAtoms chain in thisEntryCrystal.atomCat.ChainAtomList)
{
DataRow[] existRows = asuTable.Select(string.Format("PdbID = '{0}' AND AsymID = '{1}'",
thisEntryCrystal.PdbId, chain.AsymChain));
if (existRows.Length > 0)
{
continue;
}
DataRow[] existEntityRows = asuTable.Select(string.Format("PdbID = '{0}' AND EntityID = '{1}'",
thisEntryCrystal.PdbId, chain.EntityID));
existEntityRows[0]["AsymID"] = chain.AsymChain;
dbInsert.InsertDataIntoDb(ProtCidSettings.pdbfamDbConnection, existEntityRows[0]);
}
}
/// <summary>
/// create crystal XML files
/// </summary>
public void CreateCrystalXmlFiles()
{
AsymUnitBuilder asuBuilder = new AsymUnitBuilder();
// bool asuChanged = false;
ProtCidSettings.LoadDirSettings();
AppSettings.LoadParameters();
ProtCidSettings.pdbfamDbConnection = new DbConnect("DRIVER=Firebird/InterBase(r) driver;UID=SYSDBA;PWD=fbmonkeyox;DATABASE=" +
ProtCidSettings.dirSettings.pdbfamDbPath);
ProtCidSettings.progressInfo.Reset();
SetFilePaths();
string atomType = "";
if (AppSettings.parameters.contactParams.atomType == "CA")
{
atomType = "CA";
}
else if (AppSettings.parameters.contactParams.atomType == "CB")
{
atomType = "CB";
}
else
{
atomType = "ALL";
}
// save the file list for those just created
List <string> parsedCoordXmlFiles = new List <string> ();
XmlAtomParser xmlParser = new XmlAtomParser();
if (!Directory.Exists(destFilePath.Trim('\\')))
{
Directory.CreateDirectory(destFilePath.Trim('\\'));
}
modifyType = "update";
// temporary directory
if (!Directory.Exists(ProtCidSettings.tempDir))
{
Directory.CreateDirectory(ProtCidSettings.tempDir);
}
// get the common list of XML files, ent files and BU symmetry matrix files
ProtCidSettings.progressInfo.progStrQueue.Enqueue("Retrieving file list. Please wait...");
string [] pdbCodes = GetFileNames();
/* string[] pdbCodes = { "4p6d"};
* string[] pdbCodes = GetMissingEntries();*/
ProtCidSettings.progressInfo.progStrQueue.Enqueue("Done!");
ProtCidSettings.progressInfo.currentOperationLabel = "PDB Processing";
ProtCidSettings.progressInfo.totalStepNum = pdbCodes.Length;
ProtCidSettings.progressInfo.totalOperationNum = pdbCodes.Length;
ProtCidSettings.progressInfo.progressInterval = 1;
ProtCidSettings.progressInfo.progStrQueue.Enqueue("Building Coordinate XML files. Please wait...");
string crystalXmlFile = "";
foreach (string pdbCode in pdbCodes)
{
/////////////////////////////////////////
// display progress information
// get just the fileName
ProtCidSettings.progressInfo.currentFileName = pdbCode;
ProtCidSettings.progressInfo.currentOperationNum++;
ProtCidSettings.progressInfo.currentStepNum++;
crystalXmlFile = destFilePath + pdbCode + ".xml";
FileInfo fileInfo = new FileInfo(crystalXmlFile + ".gz");
if (fileInfo.LastWriteTime.Day == DateTime.Today.Day)
{
continue;
}
string zippedXmlFile = xmlFilePath + pdbCode + xmlExtName;
if (!File.Exists(zippedXmlFile))
{
webClient.DownloadFile(pdbWebAddress + pdbCode + ".xml.gz", pdbCode + ".xml.gz");
File.Move(pdbCode + ".xml.gz", zippedXmlFile);
}
string xmlFile = ParseHelper.UnZipFile(zippedXmlFile, ProtCidSettings.tempDir);
EntryCrystal thisEntryCrystal = new EntryCrystal(pdbCode);
try
{
xmlParser.ParseXmlFile(xmlFile, ref thisEntryCrystal, atomType);
/*if (thisEntryCrystal != null)
* {
* if (thisEntryCrystal.ncsCat.NcsOperatorList.Length > 0)
* {
* asuBuilder.BuildAsymUnitFromNcs (ref thisEntryCrystal, out asuChanged);
* if (asuChanged)
* {
* UpdateAsymUnitDbTable (thisEntryCrystal);
* }
* }
* }*/
}
catch (Exception ex)
{
// record the error, continue to the next file
string errorMsg = string.Format("Processing {0} file errors: {1}. Skip it.",
pdbCode, ex.Message);
ProtCidSettings.progressInfo.progStrQueue.Enqueue(errorMsg);
}
finally
{
// delete this processed file
File.Delete(xmlFile);
}
// save entry crystal data into a XML file
try
{
if (thisEntryCrystal != null)
{
XmlSerializer xmlSerializer = new XmlSerializer(thisEntryCrystal.GetType());
TextWriter crystalWriter = new StreamWriter(crystalXmlFile);
xmlSerializer.Serialize(crystalWriter, thisEntryCrystal);
crystalWriter.Close();
ParseHelper.ZipPdbFile(crystalXmlFile);
parsedCoordXmlFiles.Add(pdbCode + ".xml.gz");
WriteXmlFileToPdbFile(pdbCode, thisEntryCrystal);
// CopyPdbFileToLinux(pdbCode);
}
}
catch (Exception ex)
{
ProtCidSettings.progressInfo.progStrQueue.Enqueue(ex.Message);
}
}
try
{
Directory.Delete(ProtCidSettings.tempDir, true);
}
catch {}
SaveFileList(parsedCoordXmlFiles);
/* progressInfo.progStrQueue.Enqueue("Copy PDB files to Linux server.");
* CopyPdbFilesToLinux(pdbCodes);
* progressInfo.progStrQueue.Enqueue ("Done!");
*/
ProtCidSettings.progressInfo.progStrQueue.Enqueue("Copy updated files to new directory");
string updateFilePath = pdbTextPath.Replace("regular", "updateRegular");
if (Directory.Exists(updateFilePath))
{
Directory.Delete(updateFilePath, true);
}
Directory.CreateDirectory(updateFilePath);
DateTime dtTime = DateTime.Today;
ParseHelper.CopyNewFiles(pdbTextPath, updateFilePath, dtTime);
ProtCidSettings.progressInfo.progStrQueue.Enqueue("Done!");
ProtCidSettings.progressInfo.threadFinished = true;
}
/// <summary>
///
/// </summary>
/// <param name="asymIdLigandAsymIdHash"></param>
/// <param name="thisEntryCrystal"></param>
/// <returns></returns>
private Dictionary <string, Dictionary <string, AtomInfo[]> > GetLigandAtomInfoHash(Dictionary <string, string[]> asymIdLigandAsymIdHash, EntryCrystal thisEntryCrystal)
{
Dictionary <string, Dictionary <string, AtomInfo[]> > asymIdLigandAtomInfoHash = new Dictionary <string, Dictionary <string, AtomInfo[]> >();
ChainAtoms[] chains = thisEntryCrystal.atomCat.ChainAtomList;
foreach (string asymId in asymIdLigandAsymIdHash.Keys)
{
string[] ligandAsymIds = asymIdLigandAsymIdHash[asymId];
Dictionary <string, AtomInfo[]> ligandAtomInfoHash = new Dictionary <string, AtomInfo[]> ();
foreach (string ligandAsymId in ligandAsymIds)
{
foreach (ChainAtoms chain in chains)
{
if (chain.asymChain == ligandAsymId)
{
ligandAtomInfoHash.Add(ligandAsymId, chain.CartnAtoms);
}
}
}
asymIdLigandAtomInfoHash.Add(asymId, ligandAtomInfoHash);
}
return(asymIdLigandAtomInfoHash);
}
/// <summary>
///
/// </summary>
/// <param name="pdbId"></param>
/// <param name="thisEntryCrystal"></param>
/// <returns>double hashtable. 1. key: protein asymid, value: hashtable; 2: key ligand asym id, value: atoms</returns>
private Dictionary <string, Dictionary <string, AtomInfo[]> > GetEntryLigandAtomInfoHash(DataTable asuTable, EntryCrystal thisEntryCrystal)
{
string[] asymIds = GetProteinAsymIDs(asuTable);
Dictionary <string, string[]> asymLigandsHash = GetAsymChainLigandsHash(asymIds, asuTable);
Dictionary <string, Dictionary <string, AtomInfo[]> > asymIdLigandAtomInfoHash = GetLigandAtomInfoHash(asymLigandsHash, thisEntryCrystal);
return(asymIdLigandAtomInfoHash);
}
/// <summary>
///
/// </summary>
/// <param name="pdbId"></param>
/// <param name="chainSymOps"></param>
/// <param name="buHash"></param>
/// <param name="domainFile"></param>
public void WriteDomainDnaRnaInterfaceFiles(string pdbId, string buId, string protChainSymOp, string[] dnaRnaChainSymOps, string[] ligandChainSymOps,
Dictionary <string, AtomInfo[]> buHash, EntryCrystal thisEntryCrystal, string domainFile)
{
Dictionary <string, AtomInfo[]> asuChainHash = new Dictionary <string, AtomInfo[]> ();
Dictionary <string, string> chainMatchHash = new Dictionary <string, string> ();
List <string> asymChainList = new List <string>();
List <string> chainSymOpList = new List <string>();
List <string> fileChainsInOrderList = new List <string> ();
string fileChain = "";
string asymChain = "";
int chainIndex = 0;
string[] chainSymOps = new string[dnaRnaChainSymOps.Length + 1 + ligandChainSymOps.Length];
chainSymOps[0] = protChainSymOp;
Array.Copy(dnaRnaChainSymOps, 0, chainSymOps, 1, dnaRnaChainSymOps.Length);
Array.Copy(ligandChainSymOps, 0, chainSymOps, dnaRnaChainSymOps.Length + 1, ligandChainSymOps.Length);
foreach (string chainSymOp in chainSymOps)
{
if (buHash.ContainsKey(chainSymOp))
{
AtomInfo[] chainDomains = (AtomInfo[])buHash[chainSymOp];
if (chainIndex == ParseHelper.chainLetters.Length)
{
chainIndex = 0;
}
fileChain = ParseHelper.chainLetters[chainIndex].ToString();
asuChainHash.Add(chainSymOp, chainDomains);
chainMatchHash.Add(chainSymOp, fileChain);
fileChainsInOrderList.Add(fileChain);
chainIndex++;
asymChain = GetAsymChain(chainSymOp);
asymChainList.Add(asymChain);
chainSymOpList.Add(chainSymOp);
}
}
string[] asymChains = asymChainList.ToArray();
string[] fileChains = fileChainsInOrderList.ToArray();
string resrecordLines = GetSeqResRecords(thisEntryCrystal, asymChains, fileChains);
string remark = "HEADER " + pdbId + " " + DateTime.Today.ToShortDateString() + "\r\n";
remark = remark + "REMARK 2 Biological Assembly " + buId + "\r\n";
remark = remark + "REMARK 2 Chains and Symmetry Operators in the file \r\n";
remark = remark + "REMARK 2 " + FormatChainString(chainSymOps) + "\r\n";
remark = remark + "REMARK 2 AsymChains FileChains \r\n";
remark = remark + "REMARK 2 " + FormatChainString(asymChains) + "\r\n";
remark = remark + "REMARK 2 " + FormatChainString(fileChains) + "\r\n";
remark = remark + resrecordLines + "\r\n";
buWriter.WriteAsymUnitFile(domainFile, asuChainHash, chainSymOpList.ToArray(), fileChains, ligandChainSymOps, remark);
}
/// <summary>
///
/// </summary>
/// <param name="pdbId"></param>
/// <param name="pfamLigandTable"></param>
private void RetrieveLigandChainInteractions(string pdbId, DataTable chainLigandTable)
{
string gzCoordXmlFile = Path.Combine(ProtCidSettings.dirSettings.coordXmlPath, pdbId + ".xml.gz");
if (!File.Exists(gzCoordXmlFile))
{
ProtCidSettings.progressInfo.progStrQueue.Enqueue(pdbId + ".xml.gz file not exist");
return;
}
string coordXmlFile = ParseHelper.UnZipFile(gzCoordXmlFile, ProtCidSettings.tempDir);
// read data from crystal xml file
XmlSerializer xmlSerializer = new XmlSerializer(typeof(EntryCrystal));
FileStream xmlFileStream = new FileStream(coordXmlFile, FileMode.Open);
EntryCrystal thisEntryCrystal = (EntryCrystal)xmlSerializer.Deserialize(xmlFileStream);
xmlFileStream.Close();
File.Delete(coordXmlFile);
// no coordinates for waters
ChainAtoms[] chains = thisEntryCrystal.atomCat.ChainAtomList;
string[][] chainLigandNames = GetChainLigandsNames(chains);
string[] protChainNames = chainLigandNames[0]; // the list of protein chains
string[] ligandChainNames = chainLigandNames[1]; // the list of ligands, no DNA/RNA
if (ligandChainNames.Length == 0)
{
return;
}
Dictionary <string, double> seqPairDistDict = new Dictionary <string, double>();
foreach (string ligandChainName in ligandChainNames)
{
AtomInfo[] ligandAtoms = GetChainAtoms(chains, ligandChainName);
foreach (string protChainName in protChainNames)
{
AtomInfo[] protChainAtoms = GetChainAtoms(chains, protChainName);
Dictionary <string, AtomInfo[]> seqPairContactHash = CalculateAtomDistances(ligandAtoms, protChainAtoms, out seqPairDistDict);
foreach (string seqPair in seqPairDistDict.Keys)
{
string[] seqIds = seqPair.Split('_');
double distance = seqPairDistDict[seqPair];
AtomInfo[] atomPair = seqPairContactHash[seqPair];
DataRow chainLigandRow = chainLigandTable.NewRow();
chainLigandRow["PdbID"] = pdbId;
chainLigandRow["AsymID"] = ligandChainName;
// chainLigandRow["Ligand"] = ligandChainName;
chainLigandRow["ChainAsymID"] = protChainName;
chainLigandRow["SeqID"] = seqIds[0];
chainLigandRow["ChainSeqID"] = seqIds[1];
chainLigandRow["Distance"] = distance;
chainLigandRow["Atom"] = atomPair[0].atomName;
chainLigandRow["ChainAtom"] = atomPair[1].atomName;
chainLigandRow["Residue"] = atomPair[0].residue;
chainLigandRow["ChainResidue"] = atomPair[1].residue;
chainLigandTable.Rows.Add(chainLigandRow);
}
}
}
dbInsert.InsertDataIntoDBtables(ProtCidSettings.buCompConnection, chainLigandTable);
chainLigandTable.Clear();
}
