double gradSolver(double *A, double *b, double *x, int n, double e,
int it, double *timeGrad, double *timeError){
int i = 0;
double prev_norm, norm;
double *r = (double *) malloc(n*sizeof(double));
memset(x, 0, n*sizeof(double));
*timeGrad = *timeError = 0.0;
*timeError -= timestamp();
residue(A, b, x, r, n);
*timeError += timestamp();
prev_norm = residualNorm(r, n);
double absErr = e + 1.0;
while ((fabs(absErr) > e) && (i++<it)){
*timeGrad -= timestamp();
calcGrad(A, x, r, n);
*timeGrad += timestamp();
*timeError -= timestamp();
residue(A, b, x, r, n);
*timeError += timestamp();
norm = residualNorm(r, n);
absErr = norm - prev_norm;
prev_norm = norm;
}
//*timeGrad /= i;
free(r);
return norm;
}
long int Molecule::addResidue(std::string name, int resnum)
{
Residue residue(name, resnum);
long int result = residues.size();
residues.push_back(residue);
return result;
}
bool bounded_max_flow(graph_matrix upper, graph_matrix lower,
int beg, int end, int& max_flow)
{//流网络有g_cnt个节点，下标从0到g_cnt-1，upper为上界容量，lower为下界容量
//返回有源汇容量有上下界的流网络中是否存在可行流，若存在返回最大流max_flow
max_flow = 0;
//n_upper和n_lower是有源汇网络对应的无源汇网络
graph_matrix n_upper(upper), n_lower(lower);
//构造无源汇网络n_upper和n_lower，添加一条从end到beg的无穷大的边
construct_n(n_upper, beg, end);
//s_beg为超级源点，s_end为超级汇点
int s_beg, s_end;
graph_matrix residue(n_upper);
residue.g_cnt += 2;
s_beg = residue.g_cnt - 2;
s_end = residue.g_cnt - 1;
//将residue构造为无源汇网络对应的普通流网络
construct_c(n_upper, n_lower, s_beg, s_end, residue);
int lower_max_flow = distance_label(residue, s_beg, s_end);
int s_beg_out = beg_out(residue, s_beg, n_upper.g_cnt);
//若不相等则不存在可行流，也不存在最大流
if(lower_max_flow != s_beg_out)
return(false);
//若存在可行流，则计算最大流
//将residue中的超级源点超级汇点和原汇点到源点的边删去
deconstruct_c(residue, s_beg, s_end, beg, end);
int free_max_flow = distance_label(residue, beg, end);
max_flow = lower_max_flow + free_max_flow;
return(true);
}
bool bounded_min_flow(graph_matrix upper, graph_matrix lower,
int beg, int end, int& min_flow)
{//流网络有g_cnt个节点，下标从0到g_cnt-1，upper为上界容量，lower为下界容量
//返回有源汇容量有上下界的流网络中是否存在可行流，若存在返回最小流min_flow
min_flow = 0;
graph_matrix n_upper(upper), n_lower(lower);
int s_beg, s_end;
graph_matrix residue(n_upper);
residue.g_cnt += 2;
s_beg = residue.g_cnt - 2;
s_end = residue.g_cnt - 1;
construct_c(n_upper, n_lower, s_beg, s_end, residue);
//第一次计算最大流
int lower_max_flow = distance_label(residue, s_beg, s_end);
int s_beg_out = beg_out(residue, s_beg, n_upper.g_cnt);
//若第一次最大流已经等于超级源点所有出弧边容量之和，即已经满负荷
if(lower_max_flow == s_beg_out)
return(false);
//若lower_max_flow < s_beg_out，即尚未满负荷
//添加从汇点end到源点beg容量无穷大的边
construct_n(residue, beg, end);
//再次计算最大流
//由于计算从汇点end到源点beg边上的流需要更改distance_label代码，不方便扩展
//所以本文略去具体的代码(读者只需要对distance_label代码稍作更改即可求出min_flow)
int lower_max_flow2 = distance_label(residue, s_beg, s_end);
int s_beg_out2 = beg_out(residue, s_beg, n_upper.g_cnt);
if(lower_max_flow2 == s_beg_out2)
return(true);
else
return(false);
}
MultiChannelResult Mmp2Decomposition::compute(const DecompositionSettings& settings, const WorkspaceBuilder& builder, const MultiSignal& signal) {
MultiSignal sum;
const int N = signal.getSampleCount();
const int channelCount = signal.channels.size();
sum.channels.push_back(signal.channels[0]);
for (int c=1; c<channelCount; ++c) {
for (int i=0; i<N; ++i) {
sum.channels[0].samples[i] += signal.channels[c].samples[i];
}
}
Atoms sumResult = Decomposition::compute(settings, builder, sum)[0];
MultiSignal residue(signal);
MultiChannelResult result(channelCount);
for (int c=0; c<channelCount; ++c) {
for (Atom atom : sumResult) {
Workspace::subtractAtomFromSignal(atom, residue.channels[c], true);
result[c].push_back(atom);
}
}
return result;
}
void PDBFormat::PDBParser::parseSequence(BioStruct3D& biostruct, U2OpStatus& ti)
{
Q_UNUSED(biostruct);
/*
Record Format
COLUMNS DEFINITION
1 - 6 Record name "SEQRES"
8 - 10 Integer serNum Serial number of the SEQRES record for the current chain.
Starts at 1 and increments by one each line. Reset to 1 for each chain.
12 Character chainID Chain identifier. This may be any single legal character,
including a blank which is is used if there is only one chain.
14 - 17 Integer numRes Number of residues in the chain.
This value is repeated on every record.
20 - ... Residues
*/
if (currentPDBLine.length() < 24 /* at least one residue */)
{
ti.setError(U2::PDBFormat::tr("Invalid SEQRES: less then 24 characters"));
return;
}
char chainIdentifier = currentPDBLine.at(11).toLatin1();
if (!seqResMap.contains(chainIdentifier)) {
seqResMap.insert(chainIdentifier, QByteArray());
}
QStringList residues = currentPDBLine.mid(19).split(QRegExp("\\s+"), QString::SkipEmptyParts);
QByteArray sequencePart;
foreach (QString name, residues) {
SharedResidue residue(new ResidueData);
char acronym = PDBFormat::getAcronymByName(name.toLatin1());
sequencePart.append(acronym);
}
Dispersive::Dispersive(const Id id,
const std::string& name,
const Math::Real rEps,
const Math::Real rMu,
const Math::Real elecCond,
const Math::Real magnCond,
const std::vector<PoleResidue>& poleResidue)
: Identifiable<Id>(id),
PhysicalModel(name) {
rEpsInfty_ = rEps;
rMuInfty_ = rMu;
// Adds conductivity as a permittivity pole.
if (elecCond != 0.0) {
std::complex<Math::Real> pole(0.0);
std::complex<Math::Real> residue(elecCond / Math::Real(2.0) /
Math::Constants::eps0, 0);
poleResidue_.push_back(PoleResidue(pole, residue));
}
//
if (magnCond != 0.0) {
throw std::logic_error("Dispersive magnetic materials not implemented");
}
poleResidue_ = poleResidue;
}
/*----------------------------------------------------------------------------
* Post - adaptive postfilter main function
*----------------------------------------------------------------------------
*/
void poste(
int t0, /* input : pitch delay given by coder */
FLOAT *signal_ptr, /* input : input signal (pointer to current subframe */
FLOAT *coeff, /* input : LPC coefficients for current subframe */
FLOAT *sig_out, /* output: postfiltered output */
int *vo, /* output: voicing decision 0 = uv, > 0 delay */
FLOAT gamma1, /* input: short term postfilt. den. weighting factor*/
FLOAT gamma2, /* input: short term postfilt. num. weighting factor*/
FLOAT gamma_harm, /* input: long term postfilter weighting factor*/
int long_h_st, /* input: impulse response length*/
int m_pst, /* input: LPC order */
int Vad /* input : VAD information (frame type) */
)
{
/* Local variables and arrays */
FLOAT apond1[M_BWDP1]; /* s.t. denominator coeff. */
FLOAT sig_ltp[L_SUBFRP1]; /* H0 output signal */
FLOAT *sig_ltp_ptr;
FLOAT parcor0;
/* Compute weighted LPC coefficients */
weight_az(coeff, gamma1, m_pst, apond1);
weight_az(coeff, gamma2, m_pst, apond2);
set_zero(&apond2[m_pst+1], (M_BWD-m_pst));
/* Compute A(gamma2) residual */
residue(m_pst, apond2, signal_ptr, res2_ptr, L_SUBFR);
/* Harmonic filtering */
sig_ltp_ptr = sig_ltp + 1;
if (Vad > 1)
pst_ltpe(t0, res2_ptr, sig_ltp_ptr, vo, gamma_harm);
else {
*vo = 0;
copy(res2_ptr, sig_ltp_ptr, L_SUBFR);
}
/* Save last output of 1/A(gamma1) */
/* (from preceding subframe) */
sig_ltp[0] = *ptr_mem_stp;
/* Controls short term pst filter gain and compute parcor0 */
calc_st_filte(apond2, apond1, &parcor0, sig_ltp_ptr, long_h_st, m_pst);
/* 1/A(gamma1) filtering, mem_stp is updated */
syn_filte(m_pst, apond1, sig_ltp_ptr, sig_ltp_ptr, L_SUBFR,
&mem_stp[M_BWD-m_pst], 0);
copy(&sig_ltp_ptr[L_SUBFR-M_BWD], mem_stp, M_BWD);
/* Tilt filtering */
filt_mu(sig_ltp, sig_out, parcor0);
/* Gain control */
scale_st(signal_ptr, sig_out, &gain_prec);
/**** Update for next subframe */
copy(&res2[L_SUBFR], &res2[0], MEM_RES2);
return;
}
void set_lpc_mode(float * signal_ptr, /* I Input signal */
float * a_fwd, /* I Forward LPC filter */
float * a_bwd, /* I Backward LPC filter */
int *mode, /* O Backward / forward Indication */
float * lsp_new, /* I LSP vector current frame */
float * lsp_old, /* I LSP vector previous frame */
int *bwd_dominant, /* O Bwd dominant mode indication */
int prev_mode, /* I previous frame Backward / forward Indication */
float * prev_filter, /* I previous frame filter */
float * C_int, /*I/O filter interpolation parameter */
int16_t * glob_stat, /* I/O Mre of global stationnarity */
int16_t * stat_bwd, /* I/O Number of consecutive backward frames */
int16_t * val_stat_bwd /* I/O Value associated with stat_bwd */
)
{
int i;
float res[L_FRAME];
float *pa_bwd;
float gap;
float gpred_f, gpred_b, gpred_bint;
float tmp;
float thresh_lpc;
float dist_lsp, energy;
pa_bwd = a_bwd + M_BWDP1;
/* Backward filter prediction gain (no interpolation ) */
/* --------------------------------------------------- */
residue(M_BWD, pa_bwd, signal_ptr, res, L_FRAME);
gpred_b = ener_dB(signal_ptr, L_FRAME) - ener_dB(res, L_FRAME);
/* Interpolated LPC filter for transition forward -> backward */
/* (used during 10 frames) ( for the second sub-frame ) */
/* Interpolated backward filter for the first sub-frame */
/* ---------------------------------------------------------- */
int_bwd(a_bwd, prev_filter, C_int);
/* Interpolated backward filter prediction gain */
/* -------------------------------------------- */
residue(M_BWD, a_bwd, signal_ptr, res, L_SUBFR);
residue(M_BWD, pa_bwd, &signal_ptr[L_SUBFR], &res[L_SUBFR], L_SUBFR);
gpred_bint = ener_dB(signal_ptr, L_FRAME) - ener_dB(res, L_FRAME);
/* Forward filter prediction gain */
/* ------------------------------ */
residue(M, a_fwd, signal_ptr, res, L_SUBFR);
residue(M, &a_fwd[MP1], &signal_ptr[L_SUBFR], &res[L_SUBFR], L_SUBFR);
gpred_f = ener_dB(signal_ptr, L_FRAME) - ener_dB(res, L_FRAME);
/* -------------------------------------------------------------- */
/* BACKWARD / FORWARD DECISION */
/* */
/* The Main criterion is based on the prediction gains : */
/* The global stationnarity index is used to adapt the threshold */
/* value " GAP ". */
/* This adaptation is used to favour one mode according to the */
/* stationnarity of the input signal (backward for music and */
/* forward for speech) which avoids too many switches. */
/* */
/* A second criterion based on the LSPs is used to avoid switches */
/* if the successive LPC forward filters are very stationnary */
/* (which is measured a Euclidean distance on LSPs). */
/* */
/* -------------------------------------------------------------- */
/* 1st criterion with prediction gains */
/* ----------------------------------- */
/* Threshold adaptation according to the global stationnarity indicator */
gap = (float) (*glob_stat) * GAP_FACT;
gap += (float) 1.;
if ((gpred_bint > gpred_f - gap) && (gpred_b > gpred_f - gap) &&
(gpred_b > (float) 0.) && (gpred_bint > (float) 0.))
*mode = 1;
else
*mode = 0;
if (*glob_stat < 13000)
*mode = 0; /* => Forward mode imposed */
/* 2nd criterion with a distance between 2 successive LSP vectors */
/* -------------------------------------------------------------- */
/* Computation of the LPC distance */
dist_lsp = 0;
for (i = 0; i < M; i++) {
tmp = lsp_old[i] - lsp_new[i];
dist_lsp += tmp * tmp;
}
/* Adaptation of the LSPs thresholds */
if (*glob_stat < 32000) {
thresh_lpc = (float) 0.;
} else {
thresh_lpc = (float) 0.03;
}
/* Switching backward -> forward forbidden in case of a LPC stationnary */
if ((dist_lsp < thresh_lpc) && (*mode == 0) && (prev_mode == 1)
&& (gpred_b > (float) 0.) && (gpred_bint > (float) 0.)) {
*mode = 1;
}
/* Low energy frame => Forward mode chosen */
/* --------------------------------------- */
energy = ener_dB(signal_ptr, L_FRAME);
if (energy < THRES_ENERGY) {
*mode = 0;
if (*glob_stat > 13000)
*glob_stat = 13000;
} else
tst_bwd_dominant(bwd_dominant, *mode);
/* Adaptation of the global stationnarity indicator */
/* ------------------------------------------------ */
if (energy >= THRES_ENERGY)
calc_stat(gpred_b, gpred_f, *mode,
prev_mode, glob_stat, stat_bwd, val_stat_bwd);
if (*mode == 0)
*C_int = (float) 1.1;
return;
}
void PDBFormat::PDBParser::parseAtom(BioStruct3D& biostruct, U2OpStatus&)
{
/*
Record Format
COLUMNS DEFINITION
1 - 6 Record name "ATOM "
7 - 11 Atom serial number.
13 - 16 Atom name.
17 Alternate location indicator.
18 - 20 Residue name.
22 Chain identifier.
23 - 26 Residue sequence number.
27 Code for insertion of residues.
31 - 38 Orthogonal coordinates for X in Angstroms.
39 - 46 Orthogonal coordinates for Y in Angstroms.
47 - 54 Orthogonal coordinates for Z in Angstroms.
55 - 60 Occupancy.
61 - 66 Temperature factor.
77 - 78 Element symbol, right-justified.
79 - 80 Charge on the atom.
*/
if (!flagAtomRecordPresent)
flagAtomRecordPresent = true;
bool isHetero = false;
if (currentPDBLine.startsWith("HETATM")) {
isHetero = true;
}
int id = currentPDBLine.mid(6,5).toInt();
QByteArray atomName = currentPDBLine.mid(12,4).toLatin1().trimmed();
QByteArray residueName = currentPDBLine.mid(17,3).toLatin1().trimmed();
int resId = currentPDBLine.mid(22,4).toLatin1().toInt();
char insCode = currentPDBLine.at(26).toLatin1();
char residueAcronym = PDBFormat::getAcronymByName(residueName);
char chainIdentifier = currentPDBLine.at(21).toLatin1();
ResidueIndex residueIndex(resId,insCode);
bool atomIsInChain = !isHetero || seqResContains(chainIdentifier, residueIndex.toInt(), residueAcronym);
QByteArray elementName = currentPDBLine.mid(76,2).toLatin1().trimmed();
QByteArray element = elementName.isEmpty() ? atomName.mid(0,1) : elementName;
int atomicNumber = PDBFormat::getElementNumberByName(element);
int chainIndex = chainIndexMap.contains(chainIdentifier) ? chainIndexMap.value(chainIdentifier) : currentChainIndex;
if (currentModelIndex == 0 && atomIsInChain) {
// Process residue
if (!biostruct.moleculeMap.contains(chainIndex)) {
createMolecule(chainIdentifier, biostruct, chainIndex);
}
SharedMolecule& mol = biostruct.moleculeMap[chainIndex];
if (currentResidueIndex != residueIndex) {
SharedResidue residue(new ResidueData);
residue->name = residueName;
residue->acronym = residueAcronym;
if (residue->acronym == 'X') {
ioLog.details(tr("PDB warning: unknown residue name: %1").arg(residue->name.constData()));
}
residue->chainIndex = chainIndex;
currentResidueIndex = residueIndex;
residueOrder++;
residueIndex.setOrder(residueOrder);
mol->residueMap.insert(residueIndex, residue);
}
}
// Process atom
double x,y,z;
x = currentPDBLine.mid(30,8).toDouble();
y = currentPDBLine.mid(38,8).toDouble();
z = currentPDBLine.mid(46,8).toDouble();
double occupancy = currentPDBLine.mid(54,6).toDouble();
double temperature = currentPDBLine.mid(60,6).toDouble();
SharedAtom a(new AtomData);
a->chainIndex = chainIndex;
a->residueIndex = residueIndex;
a->atomicNumber = atomicNumber;
a->name = atomName;
a->coord3d = Vector3D(x,y,z);
a->occupancy = occupancy;
a->temperature = temperature;
biostruct.modelMap[currentModelIndex + 1].insert(id, a);
if (atomIsInChain) {
SharedMolecule& mol = biostruct.moleculeMap[chainIndex];
Molecule3DModel& model3D = mol->models[currentModelIndex];
model3D.atoms.insert(id, a);
}
}
residue get_residue_with_insert_without_ss() {
return residue( make_residue_id( 'A', 43, 'A' ), vaa, coord::ORIGIN_COORD, coord::ORIGIN_COORD, 3, sec_struc_type::ALPHA_HELIX, rotation::IDENTITY_ROTATION(), residue::DEFAULT_PHI_PSI(), residue::DEFAULT_PHI_PSI(), 0 );
}
