PDBResidue *PDBChain:: FindResidue(const char *residue_name, int residue_sequence, int residue_insertion_code) const { // Check all residues for (int i = 0; i < NResidues(); i++) { PDBResidue *residue = Residue(i); if ((residue_sequence == residue->Sequence()) && (residue_insertion_code == residue->InsertionCode()) && (!strcmp(residue_name, residue->Name()))) { return residue; } } return NULL; }
Residue get_residue(Atom d, bool nothrow) { Hierarchy mhd(d.get_particle()); do { mhd= mhd.get_parent(); if (mhd== Hierarchy()) { if (nothrow) return Residue(); else { IMP_THROW("Atom is not the child of a residue " << d, ValueException); } } } while (!Residue::particle_is_instance(mhd.get_particle())); Residue rd(mhd.get_particle()); return rd; }
fasta::Residue fasta::make_residue(const std::string& codon) { std::vector<std::string> features; if (codon.size() >= 5 && codon[4] != 'A') { features.push_back(ptm_code_map.at(codon[4])); } if (codon.size() > 1 && strct_code_map.find(codon[1]) != strct_code_map.end()) { features.push_back(strct_code_map.at(codon[1])); } if (codon.size() >= 7 && codon.substr(5, 2) != "AA") { features.push_back("m_" + codon.substr(5, 2)); } if (codon.size() >= 4 && codon.substr(2, 2) != "AA") { features.push_back("d_" + codon.substr(2, 2)); } return Residue(codon, features); }
CHARMMTopology *CHARMMParameters::create_topology(Hierarchy hierarchy) const { IMP_OBJECT_LOG; IMP_NEW(CHARMMTopology, topology, (this)); Hierarchies chains = get_by_type(hierarchy, CHAIN_TYPE); for (Hierarchies::iterator chainit = chains.begin(); chainit != chains.end(); ++chainit) { IMP_NEW(CHARMMSegmentTopology, segment, ()); Hierarchies residues = get_by_type(*chainit, RESIDUE_TYPE); for (Hierarchies::iterator resit = residues.begin(); resit != residues.end(); ++resit) { ResidueType restyp = Residue(*resit).get_residue_type(); try { IMP_NEW(CHARMMResidueTopology, residue, (get_residue_topology(restyp))); segment->add_residue(residue); } catch (base::ValueException) { // If residue type is unknown, add empty topology for this residue IMP_WARN_ONCE( restyp.get_string(), "Residue type " << restyp << " was not found in " "topology library; using empty topology for this residue", warn_context_); IMP_NEW(CHARMMResidueTopology, residue, (restyp)); segment->add_residue(residue); } } topology->add_segment(segment); } // keep clang happy bool dumped = false; IMP_IF_LOG(VERBOSE) { dumped = true; warn_context_.dump_warnings(); } if (!dumped) { warn_context_.clear_warnings(); } // Topology objects are not designed to be added into other containers topology->set_was_used(true); return topology.release(); }
// Analysis_Hist::Analyze() Analysis::RetType Analysis_Hist::Analyze() { // Set up dimensions // Size of histdata and dimensionArgs should be the same size_t total_bins = 0UL; for (unsigned int hd = 0; hd < N_dimensions_; hd++) { if ( setupDimension(dimensionArgs_[hd], *(histdata_[hd]), total_bins) ) return Analysis::ERR; } // dimensionArgs no longer needed dimensionArgs_.clear(); // Check that the number of data points in each dimension are equal std::vector<DataSet_1D*>::iterator ds = histdata_.begin(); size_t Ndata = (*ds)->Size(); ++ds; for (; ds != histdata_.end(); ++ds) { //mprintf("DEBUG: DS %s size %i\n",histdata[hd]->Name(),histdata[hd]->Xmax()+1); if (Ndata != (*ds)->Size()) { mprinterr("Error: Hist: Dataset %s has inconsistent # data points (%zu), expected %zu.\n", (*ds)->legend(), (*ds)->Size(), Ndata); return Analysis::ERR; } } mprintf("\tHist: %zu data points in each dimension.\n", Ndata); if (calcAMD_ && Ndata != amddata_->Size()) { mprinterr("Error: Hist: AMD data set size (%zu) does not match # expected data points (%zu).\n", amddata_->Size(), Ndata); return Analysis::ERR; } // Allocate bins mprintf("\tHist: Allocating histogram, total bins = %zu\n", total_bins); Bins_.resize( total_bins, 0.0 ); // Bin data for (size_t n = 0; n < Ndata; n++) { long int index = 0; HdimType::const_iterator dim = dimensions_.begin(); OffType::const_iterator bOff = binOffsets_.begin(); for (std::vector<DataSet_1D*>::iterator ds = histdata_.begin(); ds != histdata_.end(); ++ds, ++dim, ++bOff) { double dval = (*ds)->Dval( n ); // Check if data is out of bounds for this dimension. if (dval > dim->Max() || dval < dim->Min()) { index = -1L; break; } // Calculate index for this particular dimension (idx) long int idx = (long int)((dval - dim->Min()) / dim->Step()); if (debug_>1) mprintf(" [%s:%f (%li)],", dim->label(), dval, idx); // Calculate overall index in Bins, offset has already been calcd. index += (idx * (*bOff)); } // If index was successfully calculated, populate bin if (index > -1L && index < (long int)Bins_.size()) { if (debug_ > 1) mprintf(" |index=%li",index); if (calcAMD_) Bins_[index] += exp( amddata_->Dval(n) ); else Bins_[index]++; } else { mprintf("\tWarning: Frame %zu Coordinates out of bounds (%li)\n", n+1, index); } if (debug_>1) mprintf("}\n"); } // Calc free energy if requested if (calcFreeE_) CalcFreeE(); // Normalize if requested if (normalize_ != NO_NORM) Normalize(); if (nativeOut_) { // Use Histogram built-in output PrintBins(); } else { // Using DataFileList framework, set-up labels etc. if (N_dimensions_ == 1) { DataSet_double& dds = static_cast<DataSet_double&>( *hist_ ); // Since Allocate1D only reserves data, use assignment op. dds = Bins_; hist_->SetDim(Dimension::X, dimensions_[0]); } else if (N_dimensions_ == 2) { DataSet_MatrixDbl& mds = static_cast<DataSet_MatrixDbl&>( *hist_ ); mds.Allocate2D( dimensions_[0].Bins(), dimensions_[1].Bins() ); std::copy( Bins_.begin(), Bins_.end(), mds.begin() ); hist_->SetDim(Dimension::X, dimensions_[0]); hist_->SetDim(Dimension::Y, dimensions_[1]); outfile_->ProcessArgs("noxcol usemap nolabels"); } else if (N_dimensions_ == 3) { DataSet_GridFlt& gds = static_cast<DataSet_GridFlt&>( *hist_ ); //gds.Allocate3D( dimensions_[0].Bins(), dimensions_[1].Bins(), dimensions_[2].Bins() ); gds.Allocate_N_O_D( dimensions_[0].Bins(), dimensions_[1].Bins(), dimensions_[2].Bins(), Vec3(dimensions_[0].Min(), dimensions_[1].Min(), dimensions_[2].Min()), Vec3(dimensions_[0].Step(), dimensions_[1].Step(), dimensions_[2].Step()) ); //std::copy( Bins_.begin(), Bins_.end(), gds.begin() ); // FIXME: Copy will not work since in grids data is ordered with Z // changing fastest. Should the ordering in grid be changed? size_t idx = 0; for (size_t z = 0; z < gds.NZ(); z++) for (size_t y = 0; y < gds.NY(); y++) for (size_t x = 0; x < gds.NX(); x++) gds.SetElement( x, y, z, (float)Bins_[idx++] ); hist_->SetDim(Dimension::X, dimensions_[0]); hist_->SetDim(Dimension::Y, dimensions_[1]); hist_->SetDim(Dimension::Z, dimensions_[2]); outfile_->ProcessArgs("noxcol usemap nolabels"); // Create pseudo-topology/trajectory if (!traj3dName_.empty()) { Topology pseudo; pseudo.AddTopAtom(Atom("H3D", 0), Residue("H3D", 1, ' ', ' ')); pseudo.CommonSetup(); if (!parmoutName_.empty()) { ParmFile pfile; if (pfile.WriteTopology( pseudo, parmoutName_, ParmFile::UNKNOWN_PARM, 0 )) mprinterr("Error: Could not write pseudo topology to '%s'\n", parmoutName_.c_str()); } Trajout_Single out; if (out.PrepareTrajWrite(traj3dName_, ArgList(), &pseudo, CoordinateInfo(), Ndata, traj3dFmt_) == 0) { Frame outFrame(1); for (size_t i = 0; i < Ndata; ++i) { outFrame.ClearAtoms(); outFrame.AddVec3( Vec3(histdata_[0]->Dval(i), histdata_[1]->Dval(i), histdata_[2]->Dval(i)) ); out.WriteSingle(i, outFrame); } out.EndTraj(); } else mprinterr("Error: Could not set up '%s' for write.\n", traj3dName_.c_str()); } } } return Analysis::OK; }
void Coder_ld8h( Word16 ana[], /* (o) : analysis parameters */ Word16 rate /* input : rate selector/frame =0 6.4kbps , =1 8kbps,= 2 11.8 kbps*/ ) { /* LPC analysis */ Word16 r_l_fwd[MP1], r_h_fwd[MP1]; /* Autocorrelations low and hi (forward) */ Word32 r_bwd[M_BWDP1]; /* Autocorrelations (backward) */ Word16 r_l_bwd[M_BWDP1]; /* Autocorrelations low (backward) */ Word16 r_h_bwd[M_BWDP1]; /* Autocorrelations high (backward) */ Word16 rc_fwd[M]; /* Reflection coefficients : forward analysis */ Word16 rc_bwd[M_BWD]; /* Reflection coefficients : backward analysis */ Word16 A_t_fwd[MP1*2]; /* A(z) forward unquantized for the 2 subframes */ Word16 A_t_fwd_q[MP1*2]; /* A(z) forward quantized for the 2 subframes */ Word16 A_t_bwd[2*M_BWDP1]; /* A(z) backward for the 2 subframes */ Word16 *Aq; /* A(z) "quantized" for the 2 subframes */ Word16 *Ap; /* A(z) "unquantized" for the 2 subframes */ Word16 *pAp, *pAq; Word16 Ap1[M_BWDP1]; /* A(z) with spectral expansion */ Word16 Ap2[M_BWDP1]; /* A(z) with spectral expansion */ Word16 lsp_new[M], lsp_new_q[M]; /* LSPs at 2th subframe */ Word16 lsf_int[M]; /* Interpolated LSF 1st subframe. */ Word16 lsf_new[M]; Word16 lp_mode; /* Backward / Forward Indication mode */ Word16 m_ap, m_aq, i_gamma; Word16 code_lsp[2]; /* Other vectors */ Word16 h1[L_SUBFR]; /* Impulse response h1[] */ Word16 xn[L_SUBFR]; /* Target vector for pitch search */ Word16 xn2[L_SUBFR]; /* Target vector for codebook search */ Word16 code[L_SUBFR]; /* Fixed codebook excitation */ Word16 y1[L_SUBFR]; /* Filtered adaptive excitation */ Word16 y2[L_SUBFR]; /* Filtered fixed codebook excitation */ Word16 g_coeff[4]; /* Correlations between xn & y1 */ Word16 res2[L_SUBFR]; /* residual after long term prediction*/ Word16 g_coeff_cs[5]; Word16 exp_g_coeff_cs[5]; /* Correlations between xn, y1, & y2 <y1,y1>, -2<xn,y1>, <y2,y2>, -2<xn,y2>, 2<y1,y2> */ /* Scalars */ Word16 i, j, k, i_subfr; Word16 T_op, T0, T0_min, T0_max, T0_frac; Word16 gain_pit, gain_code, index; Word16 taming, pit_sharp; Word16 sat_filter; Word32 L_temp; Word16 freq_cur[M]; Word16 temp; /*------------------------------------------------------------------------* * - Perform LPC analysis: * * * autocorrelation + lag windowing * * * Levinson-durbin algorithm to find a[] * * * convert a[] to lsp[] * * * quantize and code the LSPs * * * find the interpolated LSPs and convert to a[] for the 2 * * subframes (both quantized and unquantized) * *------------------------------------------------------------------------*/ /* ------------------- */ /* LP Forward analysis */ /* ------------------- */ Autocorr(p_window, M, r_h_fwd, r_l_fwd); /* Autocorrelations */ Lag_window(M, r_h_fwd, r_l_fwd); /* Lag windowing */ Levinsone(M, r_h_fwd, r_l_fwd, &A_t_fwd[MP1], rc_fwd, old_A_fwd, old_rc_fwd); /* Levinson Durbin */ Az_lsp(&A_t_fwd[MP1], lsp_new, lsp_old); /* From A(z) to lsp */ /* -------------------- */ /* LP Backward analysis */ /* -------------------- */ /* -------------------- */ /* LP Backward analysis */ /* -------------------- */ if ( rate== G729E) { /* LPC recursive Window as in G728 */ autocorr_hyb_window(synth, r_bwd, rexp); /* Autocorrelations */ Lag_window_bwd(r_bwd, r_h_bwd, r_l_bwd); /* Lag windowing */ /* Fixed Point Levinson (as in G729) */ Levinsone(M_BWD, r_h_bwd, r_l_bwd, &A_t_bwd[M_BWDP1], rc_bwd, old_A_bwd, old_rc_bwd); /* Tests saturation of A_t_bwd */ sat_filter = 0; for (i=M_BWDP1; i<2*M_BWDP1; i++) if (A_t_bwd[i] >= 32767) sat_filter = 1; if (sat_filter == 1) Copy(A_t_bwd_mem, &A_t_bwd[M_BWDP1], M_BWDP1); else Copy(&A_t_bwd[M_BWDP1], A_t_bwd_mem, M_BWDP1); /* Additional bandwidth expansion on backward filter */ Weight_Az(&A_t_bwd[M_BWDP1], GAMMA_BWD, M_BWD, &A_t_bwd[M_BWDP1]); } /*--------------------------------------------------* * Update synthesis signal for next frame. * *--------------------------------------------------*/ Copy(&synth[L_FRAME], &synth[0], MEM_SYN_BWD); /*--------------------------------------------------------------------* * Find interpolated LPC parameters in all subframes (unquantized). * * The interpolated parameters are in array A_t[] of size (M+1)*4 * *--------------------------------------------------------------------*/ if( prev_lp_mode == 0) { Int_lpc(lsp_old, lsp_new, lsf_int, lsf_new, A_t_fwd); } else { /* no interpolation */ /* unquantized */ Lsp_Az(lsp_new, A_t_fwd); /* Subframe 1 */ Lsp_lsf(lsp_new, lsf_new, M); /* transformation from LSP to LSF (freq.domain) */ Copy(lsf_new, lsf_int, M); /* Subframe 1 */ } /* ---------------- */ /* LSP quantization */ /* ---------------- */ Qua_lspe(lsp_new, lsp_new_q, code_lsp, freq_prev, freq_cur); /*--------------------------------------------------------------------* * Find interpolated LPC parameters in all subframes (quantized) * * the quantized interpolated parameters are in array Aq_t[] * *--------------------------------------------------------------------*/ if( prev_lp_mode == 0) { Int_qlpc(lsp_old_q, lsp_new_q, A_t_fwd_q); } else { /* no interpolation */ Lsp_Az(lsp_new_q, &A_t_fwd_q[MP1]); /* Subframe 2 */ Copy(&A_t_fwd_q[MP1], A_t_fwd_q, MP1); /* Subframe 1 */ } /*---------------------------------------------------------------------* * - Decision for the switch Forward / Backward * *---------------------------------------------------------------------*/ if(rate == G729E) { set_lpc_modeg(speech, A_t_fwd_q, A_t_bwd, &lp_mode, lsp_new, lsp_old, &bwd_dominant, prev_lp_mode, prev_filter, &C_int, &glob_stat, &stat_bwd, &val_stat_bwd); } else { update_bwd( &lp_mode, &bwd_dominant, &C_int, &glob_stat); } /* ---------------------------------- */ /* update the LSPs for the next frame */ /* ---------------------------------- */ Copy(lsp_new, lsp_old, M); /*----------------------------------------------------------------------* * - Find the weighted input speech w_sp[] for the whole speech frame * *----------------------------------------------------------------------*/ if(lp_mode == 0) { m_ap = M; if (bwd_dominant == 0) Ap = A_t_fwd; else Ap = A_t_fwd_q; perc_var(gamma1, gamma2, lsf_int, lsf_new, rc_fwd); } else { if (bwd_dominant == 0) { m_ap = M; Ap = A_t_fwd; } else { m_ap = M_BWD; Ap = A_t_bwd; } perc_vare(gamma1, gamma2, bwd_dominant); } pAp = Ap; for (i=0; i<2; i++) { Weight_Az(pAp, gamma1[i], m_ap, Ap1); Weight_Az(pAp, gamma2[i], m_ap, Ap2); Residue(m_ap, Ap1, &speech[i*L_SUBFR], &wsp[i*L_SUBFR], L_SUBFR); Syn_filte(m_ap, Ap2, &wsp[i*L_SUBFR], &wsp[i*L_SUBFR], L_SUBFR, &mem_w[M_BWD-m_ap], 0); for(j=0; j<M_BWD; j++) mem_w[j] = wsp[i*L_SUBFR+L_SUBFR-M_BWD+j]; pAp += m_ap+1; } *ana++ = rate+ (Word16)2; /* bit rate mode */ if(lp_mode == 0) { m_aq = M; Aq = A_t_fwd_q; /* update previous filter for next frame */ Copy(&Aq[MP1], prev_filter, MP1); for(i=MP1; i <M_BWDP1; i++) prev_filter[i] = 0; for(j=MP1; j<M_BWDP1; j++) ai_zero[j] = 0; } else { m_aq = M_BWD; Aq = A_t_bwd; if (bwd_dominant == 0) { for(j=MP1; j<M_BWDP1; j++) ai_zero[j] = 0; } /* update previous filter for next frame */ Copy(&Aq[M_BWDP1], prev_filter, M_BWDP1); } if (rate == G729E) *ana++ = lp_mode; /*----------------------------------------------------------------------* * - Find the weighted input speech w_sp[] for the whole speech frame * * - Find the open-loop pitch delay * *----------------------------------------------------------------------*/ if( lp_mode == 0) { Copy(lsp_new_q, lsp_old_q, M); Lsp_prev_update(freq_cur, freq_prev); *ana++ = code_lsp[0]; *ana++ = code_lsp[1]; } /* Find open loop pitch lag */ T_op = Pitch_ol(wsp, PIT_MIN, PIT_MAX, L_FRAME); /* Range for closed loop pitch search in 1st subframe */ T0_min = sub(T_op, 3); if (sub(T0_min,PIT_MIN)<0) { T0_min = PIT_MIN; } T0_max = add(T0_min, 6); if (sub(T0_max ,PIT_MAX)>0) { T0_max = PIT_MAX; T0_min = sub(T0_max, 6); } /*------------------------------------------------------------------------* * Loop for every subframe in the analysis frame * *------------------------------------------------------------------------* * To find the pitch and innovation parameters. The subframe size is * * L_SUBFR and the loop is repeated 2 times. * * - find the weighted LPC coefficients * * - find the LPC residual signal res[] * * - compute the target signal for pitch search * * - compute impulse response of weighted synthesis filter (h1[]) * * - find the closed-loop pitch parameters * * - encode the pitch delay * * - update the impulse response h1[] by including fixed-gain pitch * * - find target vector for codebook search * * - codebook search * * - encode codebook address * * - VQ of pitch and codebook gains * * - find synthesis speech * * - update states of weighting filter * *------------------------------------------------------------------------*/ pAp = Ap; /* pointer to interpolated "unquantized"LPC parameters */ pAq = Aq; /* pointer to interpolated "quantized" LPC parameters */ i_gamma = 0; for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR) { /*---------------------------------------------------------------* * Find the weighted LPC coefficients for the weighting filter. * *---------------------------------------------------------------*/ Weight_Az(pAp, gamma1[i_gamma], m_ap, Ap1); Weight_Az(pAp, gamma2[i_gamma], m_ap, Ap2); /*---------------------------------------------------------------* * Compute impulse response, h1[], of weighted synthesis filter * *---------------------------------------------------------------*/ for (i = 0; i <=m_ap; i++) ai_zero[i] = Ap1[i]; Syn_filte(m_aq, pAq, ai_zero, h1, L_SUBFR, zero, 0); Syn_filte(m_ap, Ap2, h1, h1, L_SUBFR, zero, 0); /*------------------------------------------------------------------------* * * * Find the target vector for pitch search: * * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * * * * |------| res[n] * * speech[n]---| A(z) |-------- * * |------| | |--------| error[n] |------| * * zero -- (-)--| 1/A(z) |-----------| W(z) |-- target * * exc |--------| |------| * * * * Instead of subtracting the zero-input response of filters from * * the weighted input speech, the above configuration is used to * * compute the target vector. This configuration gives better performance * * with fixed-point implementation. The memory of 1/A(z) is updated by * * filtering (res[n]-exc[n]) through 1/A(z), or simply by subtracting * * the synthesis speech from the input speech: * * error[n] = speech[n] - syn[n]. * * The memory of W(z) is updated by filtering error[n] through W(z), * * or more simply by subtracting the filtered adaptive and fixed * * codebook excitations from the target: * * target[n] - gain_pit*y1[n] - gain_code*y2[n] * * as these signals are already available. * * * *------------------------------------------------------------------------*/ Residue(m_aq, pAq, &speech[i_subfr], &exc[i_subfr], L_SUBFR); /* LPC residual */ for (i=0; i<L_SUBFR; i++) res2[i] = exc[i_subfr+i]; Syn_filte(m_aq, pAq, &exc[i_subfr], error, L_SUBFR, &mem_err[M_BWD-m_aq], 0); Residue(m_ap, Ap1, error, xn, L_SUBFR); Syn_filte(m_ap, Ap2, xn, xn, L_SUBFR, &mem_w0[M_BWD-m_ap], 0); /* target signal xn[]*/ /*----------------------------------------------------------------------* * Closed-loop fractional pitch search * *----------------------------------------------------------------------*/ T0 = Pitch_fr3cp(&exc[i_subfr], xn, h1, L_SUBFR, T0_min, T0_max, i_subfr, &T0_frac, rate); index = Enc_lag3cp(T0, T0_frac, &T0_min, &T0_max,PIT_MIN,PIT_MAX, i_subfr, rate); *ana++ = index; if ( (i_subfr == 0) && (rate != G729D) ) { *ana = Parity_Pitch(index); if( rate == G729E) { *ana ^= (shr(index, 1) & 0x0001); } ana++; } /*-----------------------------------------------------------------* * - find unity gain pitch excitation (adaptive codebook entry) * * with fractional interpolation. * * - find filtered pitch exc. y1[]=exc[] convolve with h1[]) * * - compute pitch gain and limit between 0 and 1.2 * * - update target vector for codebook search * * - find LTP residual. * *-----------------------------------------------------------------*/ Pred_lt_3(&exc[i_subfr], T0, T0_frac, L_SUBFR); Convolve(&exc[i_subfr], h1, y1, L_SUBFR); gain_pit = G_pitch(xn, y1, g_coeff, L_SUBFR); /* clip pitch gain if taming is necessary */ taming = test_err(T0, T0_frac); if( taming == 1){ if (sub(gain_pit, GPCLIP) > 0) { gain_pit = GPCLIP; } } /* xn2[i] = xn[i] - y1[i] * gain_pit */ for (i = 0; i < L_SUBFR; i++) { L_temp = L_mult(y1[i], gain_pit); L_temp = L_shl(L_temp, 1); /* gain_pit in Q14 */ xn2[i] = sub(xn[i], extract_h(L_temp)); } /*-----------------------------------------------------* * - Innovative codebook search. * *-----------------------------------------------------*/ switch (rate) { case G729: /* 8 kbit/s */ { /* case 8 kbit/s */ index = ACELP_Codebook(xn2, h1, T0, sharp, i_subfr, code, y2, &i); *ana++ = index; /* Positions index */ *ana++ = i; /* Signs index */ break; } case G729D: /* 6.4 kbit/s */ { index = ACELP_CodebookD(xn2, h1, T0, sharp, code, y2, &i); *ana++ = index; /* Positions index */ *ana++ = i; /* Signs index */ break; } case G729E: /* 11.8 kbit/s */ { /*-----------------------------------------------------------------* * Include fixed-gain pitch contribution into impulse resp. h[] * *-----------------------------------------------------------------*/ pit_sharp = shl(sharp, 1); /* From Q14 to Q15 */ if(T0 < L_SUBFR) { for (i = T0; i < L_SUBFR; i++){ /* h[i] += pitch_sharp*h[i-T0] */ h1[i] = add(h1[i], mult(h1[i-T0], pit_sharp)); } } /* calculate residual after long term prediction */ /* res2[i] -= exc[i+i_subfr] * gain_pit */ for (i = 0; i < L_SUBFR; i++) { L_temp = L_mult(exc[i+i_subfr], gain_pit); L_temp = L_shl(L_temp, 1); /* gain_pit in Q14 */ res2[i] = sub(res2[i], extract_h(L_temp)); } if (lp_mode == 0) ACELP_10i40_35bits(xn2, res2, h1, code, y2, ana); /* Forward */ else ACELP_12i40_44bits(xn2, res2, h1, code, y2, ana); /* Backward */ ana += 5; /*-----------------------------------------------------------------* * Include fixed-gain pitch contribution into code[]. * *-----------------------------------------------------------------*/ if(T0 < L_SUBFR) { for (i = T0; i < L_SUBFR; i++) { /* code[i] += pitch_sharp*code[i-T0] */ code[i] = add(code[i], mult(code[i-T0], pit_sharp)); } } break; } default : { printf("Unrecognized bit rate\n"); exit(-1); } } /* end of switch */ /*-----------------------------------------------------* * - Quantization of gains. * *-----------------------------------------------------*/ g_coeff_cs[0] = g_coeff[0]; /* <y1,y1> */ exp_g_coeff_cs[0] = negate(g_coeff[1]); /* Q-Format:XXX -> JPN */ g_coeff_cs[1] = negate(g_coeff[2]); /* (xn,y1) -> -2<xn,y1> */ exp_g_coeff_cs[1] = negate(add(g_coeff[3], 1)); /* Q-Format:XXX -> JPN */ Corr_xy2( xn, y1, y2, g_coeff_cs, exp_g_coeff_cs ); /* Q0 Q0 Q12 ^Qx ^Q0 */ /* g_coeff_cs[3]:exp_g_coeff_cs[3] = <y2,y2> */ /* g_coeff_cs[4]:exp_g_coeff_cs[4] = -2<xn,y2> */ /* g_coeff_cs[5]:exp_g_coeff_cs[5] = 2<y1,y2> */ if (rate == G729D) index = Qua_gain_6k(code, g_coeff_cs, exp_g_coeff_cs, L_SUBFR, &gain_pit, &gain_code, taming, past_qua_en); else index = Qua_gain_8k(code, g_coeff_cs, exp_g_coeff_cs, L_SUBFR, &gain_pit, &gain_code, taming, past_qua_en); *ana++ = index; /*------------------------------------------------------------* * - Update pitch sharpening "sharp" with quantized gain_pit * *------------------------------------------------------------*/ sharp = gain_pit; if (sub(sharp, SHARPMAX) > 0) sharp = SHARPMAX; else { if (sub(sharp, SHARPMIN) < 0) sharp = SHARPMIN; } /*------------------------------------------------------* * - Find the total excitation * * - find synthesis speech corresponding to exc[] * * - update filters memories for finding the target * * vector in the next subframe * * (update error[-m..-1] and mem_w_err[]) * * update error function for taming process * *------------------------------------------------------*/ for (i = 0; i < L_SUBFR; i++) { /* exc[i] = gain_pit*exc[i] + gain_code*code[i]; */ /* exc[i] in Q0 gain_pit in Q14 */ /* code[i] in Q13 gain_cod in Q1 */ L_temp = L_mult(exc[i+i_subfr], gain_pit); L_temp = L_mac(L_temp, code[i], gain_code); L_temp = L_shl(L_temp, 1); exc[i+i_subfr] = round(L_temp); } update_exc_err(gain_pit, T0); Syn_filte(m_aq, pAq, &exc[i_subfr], &synth_ptr[i_subfr], L_SUBFR, &mem_syn[M_BWD-m_aq], 0); for(j=0; j<M_BWD; j++) mem_syn[j] = synth_ptr[i_subfr+L_SUBFR-M_BWD+j]; for (i = L_SUBFR-M_BWD, j = 0; i < L_SUBFR; i++, j++) { mem_err[j] = sub(speech[i_subfr+i], synth_ptr[i_subfr+i]); temp = extract_h(L_shl( L_mult(y1[i], gain_pit), 1) ); k = extract_h(L_shl( L_mult(y2[i], gain_code), 2) ); mem_w0[j] = sub(xn[i], add(temp, k)); } pAp += m_ap+1; pAq += m_aq+1; i_gamma = add(i_gamma,1); } /*--------------------------------------------------* * Update signal for next frame. * * -> shift to the left by L_FRAME: * * speech[], wsp[] and exc[] * *--------------------------------------------------*/ Copy(&old_speech[L_FRAME], &old_speech[0], L_TOTAL-L_FRAME); Copy(&old_wsp[L_FRAME], &old_wsp[0], PIT_MAX); Copy(&old_exc[L_FRAME], &old_exc[0], PIT_MAX+L_INTERPOL); prev_lp_mode = lp_mode; return; }
// Parm_CIF::ReadParm() int Parm_CIF::ReadParm(FileName const& fname, Topology &TopIn) { CIFfile infile; CIFfile::DataBlock::data_it line; if (infile.Read( fname, debug_ )) return 1; CIFfile::DataBlock const& block = infile.GetDataBlock("_atom_site"); if (block.empty()) { mprinterr("Error: CIF data block '_atom_site' not found.\n"); return 1; } // Does this CIF contain multiple models? int Nmodels = 0; int model_col = block.ColumnIndex("pdbx_PDB_model_num"); if (model_col != -1) { line = block.end(); --line; Nmodels = convertToInteger( (*line)[model_col] ); if (Nmodels > 1) mprintf("Warning: CIF '%s' contains %i models. Using first model for topology.\n", fname.full(), Nmodels); } // Get essential columns int COL[NENTRY]; for (int i = 0; i < (int)NENTRY; i++) { COL[i] = block.ColumnIndex(Entries[i]); if (COL[i] == -1) { mprinterr("Error: In CIF file '%s' could not find entry '%s' in block '%s'\n", fname.full(), Entries[i], block.Header().c_str()); return 1; } if (debug_>0) mprintf("DEBUG: '%s' column = %i\n", Entries[i], COL[i]); } // Get optional columns int occ_col = block.ColumnIndex("occupancy"); int bfac_col = block.ColumnIndex("B_iso_or_equiv"); int icode_col = block.ColumnIndex("pdbx_PDB_ins_code"); int altloc_col = block.ColumnIndex("label_alt_id"); std::vector<AtomExtra> extra; // Loop over all atom sites int current_res = 0; double XYZ[3]; double occupancy = 1.0; double bfactor = 0.0; char altloc = ' '; char icode; icode = ' '; Frame Coords; for (line = block.begin(); line != block.end(); ++line) { // If more than 1 model check if we are done. if (Nmodels > 1) { if ( convertToInteger( (*line)[model_col] ) > 1 ) break; } if (occ_col != -1) occupancy = convertToDouble( (*line)[ occ_col ] ); if (bfac_col != -1) bfactor = convertToDouble( (*line)[ bfac_col ] ); if (altloc_col != -1) altloc = (*line)[ altloc_col ][0]; // '.' altloc means blank? if (altloc == '.') altloc = ' '; extra.push_back( AtomExtra(occupancy, bfactor, altloc) ); if (icode_col != -1) { icode = (*line)[ icode_col ][0]; // '?' icode means blank if (icode == '?') icode = ' '; } XYZ[0] = convertToDouble( (*line)[ COL[X] ] ); XYZ[1] = convertToDouble( (*line)[ COL[Y] ] ); XYZ[2] = convertToDouble( (*line)[ COL[Z] ] ); NameType currentResName( (*line)[ COL[RNAME] ] ); // It seems that in some CIF files, there doesnt have to be a residue // number. Check if residue name has changed. if ( (*line)[ COL[RNUM] ][0] == '.' ) { Topology::res_iterator lastResidue = TopIn.ResEnd(); --lastResidue; if ( currentResName != (*lastResidue).Name() ) current_res = TopIn.Nres() + 1; } else current_res = convertToInteger( (*line)[ COL[RNUM] ] ); TopIn.AddTopAtom( Atom((*line)[ COL[ANAME] ], " "), Residue(currentResName, current_res, icode, (*line)[ COL[CHAINID] ][0]) ); Coords.AddXYZ( XYZ ); } if (TopIn.SetExtraAtomInfo( 0, extra )) return 1; // Search for bonds // FIXME nobondsearch? BondSearch( TopIn, Coords, Offset_, debug_ ); // Get title. CIFfile::DataBlock const& entryblock = infile.GetDataBlock("_entry"); std::string ciftitle; if (!entryblock.empty()) ciftitle = entryblock.Data("id"); TopIn.SetParmName( ciftitle, infile.CIFname() ); // Get unit cell parameters if present. CIFfile::DataBlock const& cellblock = infile.GetDataBlock("_cell"); if (!cellblock.empty()) { double cif_box[6]; cif_box[0] = convertToDouble( cellblock.Data("length_a") ); cif_box[1] = convertToDouble( cellblock.Data("length_b") ); cif_box[2] = convertToDouble( cellblock.Data("length_c") ); cif_box[3] = convertToDouble( cellblock.Data("angle_alpha") ); cif_box[4] = convertToDouble( cellblock.Data("angle_beta" ) ); cif_box[5] = convertToDouble( cellblock.Data("angle_gamma") ); mprintf("\tRead cell info from CIF: a=%g b=%g c=%g alpha=%g beta=%g gamma=%g\n", cif_box[0], cif_box[1], cif_box[2], cif_box[3], cif_box[4], cif_box[5]); TopIn.SetParmBox( Box(cif_box) ); } return 0; }
int SequenceAlign(CpptrajState& State, ArgList& argIn) { std::string blastfile = argIn.GetStringKey("blastfile"); if (blastfile.empty()) { mprinterr("Error: 'blastfile' must be specified.\n"); return 1; } ReferenceFrame qref = State.DSL()->GetReferenceFrame(argIn); if (qref.error() || qref.empty()) { mprinterr("Error: Must specify reference structure for query.\n"); return 1; } std::string outfilename = argIn.GetStringKey("out"); if (outfilename.empty()) { mprinterr("Error: Must specify output file.\n"); return 1; } TrajectoryFile::TrajFormatType fmt = TrajectoryFile::GetFormatFromArg(argIn); if (fmt != TrajectoryFile::PDBFILE && fmt != TrajectoryFile::MOL2FILE) fmt = TrajectoryFile::PDBFILE; // Default to PDB int smaskoffset = argIn.getKeyInt("smaskoffset", 0) + 1; int qmaskoffset = argIn.getKeyInt("qmaskoffset", 0) + 1; // Load blast file mprintf("\tReading BLAST alignment from '%s'\n", blastfile.c_str()); BufferedLine infile; if (infile.OpenFileRead( blastfile )) return 1; // Seek down to first Query line. const char* ptr = infile.Line(); bool atFirstQuery = false; while (ptr != 0) { if (*ptr == 'Q') { if ( strncmp(ptr, "Query", 5) == 0 ) { atFirstQuery = true; break; } } ptr = infile.Line(); } if (!atFirstQuery) { mprinterr("Error: 'Query' not found.\n"); return 1; } // Read alignment. Replacing query with subject. typedef std::vector<char> Carray; typedef std::vector<int> Iarray; Carray Query; // Query residues Carray Sbjct; // Sbjct residues Iarray Smap; // Smap[Sbjct index] = Query index while (ptr != 0) { const char* qline = ptr; // query line const char* aline = infile.Line(); // alignment line const char* sline = infile.Line(); // subject line if (aline == 0 || sline == 0) { mprinterr("Error: Missing alignment line or subject line after Query:\n"); mprinterr("Error: %s", qline); return 1; } for (int idx = 12; qline[idx] != ' '; idx++) { if (qline[idx] == '-') { // Sbjct does not have corresponding res in Query Smap.push_back(-1); Sbjct.push_back( sline[idx] ); } else if (sline[idx] == '-') { // Query does not have a corresponding res in Sbjct Query.push_back( qline[idx] ); } else { // Direct Query to Sbjct map Smap.push_back( Query.size() ); Sbjct.push_back( sline[idx] ); Query.push_back( qline[idx] ); } } // Scan to next Query ptr = infile.Line(); while (ptr != 0) { if (*ptr == 'Q') { if ( strncmp(ptr, "Query", 5) == 0 ) break; } ptr = infile.Line(); } } // DEBUG std::string SmaskExp, QmaskExp; if (State.Debug() > 0) mprintf(" Map of Sbjct to Query:\n"); for (int sres = 0; sres != (int)Sbjct.size(); sres++) { if (State.Debug() > 0) mprintf("%-i %3s %i", sres+smaskoffset, Residue::ConvertResName(Sbjct[sres]), Smap[sres]+qmaskoffset); const char* qres = ""; if (Smap[sres] != -1) { qres = Residue::ConvertResName(Query[Smap[sres]]); if (SmaskExp.empty()) SmaskExp.assign( integerToString(sres+smaskoffset) ); else SmaskExp.append( "," + integerToString(sres+smaskoffset) ); if (QmaskExp.empty()) QmaskExp.assign( integerToString(Smap[sres]+qmaskoffset) ); else QmaskExp.append( "," + integerToString(Smap[sres]+qmaskoffset) ); } if (State.Debug() > 0) mprintf(" %3s\n", qres); } mprintf("Smask: %s\n", SmaskExp.c_str()); mprintf("Qmask: %s\n", QmaskExp.c_str()); // Check that query residues match reference. for (unsigned int sres = 0; sres != Sbjct.size(); sres++) { int qres = Smap[sres]; if (qres != -1) { if (Query[qres] != qref.Parm().Res(qres).SingleCharName()) { mprintf("Warning: Potential residue mismatch: Query %s reference %s\n", Residue::ConvertResName(Query[qres]), qref.Parm().Res(qres).c_str()); } } } // Build subject using coordinate from reference. //AtomMask sMask; // Contain atoms that should be in sTop Topology sTop; Frame sFrame; Iarray placeHolder; // Atom indices of placeholder residues. for (unsigned int sres = 0; sres != Sbjct.size(); sres++) { int qres = Smap[sres]; NameType SresName( Residue::ConvertResName(Sbjct[sres]) ); if (qres != -1) { Residue const& QR = qref.Parm().Res(qres); Residue SR(SresName, sres+1, ' ', QR.ChainID()); if (Query[qres] == Sbjct[sres]) { // Exact match. All non-H atoms. for (int qat = QR.FirstAtom(); qat != QR.LastAtom(); qat++) { if (qref.Parm()[qat].Element() != Atom::HYDROGEN) sTop.AddTopAtom( qref.Parm()[qat], SR ); sFrame.AddXYZ( qref.Coord().XYZ(qat) ); //sMask.AddAtom(qat); } } else { // Partial match. Copy only backbone and CB. for (int qat = QR.FirstAtom(); qat != QR.LastAtom(); qat++) { if ( qref.Parm()[qat].Name().Match("N" ) || qref.Parm()[qat].Name().Match("CA") || qref.Parm()[qat].Name().Match("CB") || qref.Parm()[qat].Name().Match("C" ) || qref.Parm()[qat].Name().Match("O" ) ) { sTop.AddTopAtom( qref.Parm()[qat], SR ); sFrame.AddXYZ( qref.Coord().XYZ(qat) ); } } } } else { // Residue in query does not exist for subject. Just put placeholder CA for now. Vec3 Zero(0.0); placeHolder.push_back( sTop.Natom() ); sTop.AddTopAtom( Atom("CA", "C "), Residue(SresName, sres+1, ' ', ' ') ); sFrame.AddXYZ( Zero.Dptr() ); } } //sTop.PrintAtomInfo("*"); mprintf("\tPlaceholder residue indices:"); for (Iarray::const_iterator p = placeHolder.begin(); p != placeHolder.end(); ++p) mprintf(" %i", *p + 1); mprintf("\n"); // Try to give placeholders more reasonable coordinates. if (!placeHolder.empty()) { Iarray current_indices; unsigned int pidx = 0; while (pidx < placeHolder.size()) { if (current_indices.empty()) { current_indices.push_back( placeHolder[pidx++] ); // Search for the end of this segment for (; pidx != placeHolder.size(); pidx++) { if (placeHolder[pidx] - current_indices.back() > 1) break; current_indices.push_back( placeHolder[pidx] ); } // DEBUG mprintf("\tSegment:"); for (Iarray::const_iterator it = current_indices.begin(); it != current_indices.end(); ++it) mprintf(" %i", *it + 1); // Get coordinates of residues bordering segment. int prev_res = sTop[current_indices.front()].ResNum() - 1; int next_res = sTop[current_indices.back() ].ResNum() + 1; mprintf(" (prev_res=%i, next_res=%i)\n", prev_res+1, next_res+1); Vec3 prev_crd(sFrame.XYZ(current_indices.front() - 1)); Vec3 next_crd(sFrame.XYZ(current_indices.back() + 1)); prev_crd.Print("prev_crd"); next_crd.Print("next_crd"); Vec3 crd_step = (next_crd - prev_crd) / (double)(current_indices.size()+1); crd_step.Print("crd_step"); double* xyz = sFrame.xAddress() + (current_indices.front() * 3); for (unsigned int i = 0; i != current_indices.size(); i++, xyz += 3) { prev_crd += crd_step; xyz[0] = prev_crd[0]; xyz[1] = prev_crd[1]; xyz[2] = prev_crd[2]; } current_indices.clear(); } } } //Topology* sTop = qref.Parm().partialModifyStateByMask( sMask ); //if (sTop == 0) return 1; //Frame sFrame(qref.Coord(), sMask); // Write output traj Trajout_Single trajout; if (trajout.PrepareTrajWrite(outfilename, argIn, &sTop, CoordinateInfo(), 1, fmt)) return 1; if (trajout.WriteSingle(0, sFrame)) return 1; trajout.EndTraj(); return 0; }
Hierarchy create_simplified_along_backbone(Chain in, const IntRanges& residue_segments, bool keep_detailed) { IMP_USAGE_CHECK(in.get_is_valid(true), "Chain " << in << " is not valid."); if (in.get_number_of_children() ==0 || residue_segments.empty()) { IMP_LOG_TERSE( "Nothing to simplify in " << (in? in->get_name(): "nullptr") << " with " << residue_segments.size() << " segments.\n"); return Hierarchy(); } for (unsigned int i=0; i< residue_segments.size(); ++i) { IMP_USAGE_CHECK(residue_segments[i].first < residue_segments[i].second, "Residue intervals must be non-empty"); } IMP_IF_LOG(VERBOSE) { for (unsigned int i=0; i < residue_segments.size(); ++i) { IMP_LOG_VERBOSE( "[" << residue_segments[i].first << "..." << residue_segments[i].second << ") "); } IMP_LOG_VERBOSE( std::endl); } unsigned int cur_segment=0; Hierarchies cur; Hierarchy root=create_clone_one(in); for (unsigned int i=0; i< in.get_number_of_children(); ++i) { Hierarchy child=in.get_child(i); int index= Residue(child).get_index(); IMP_LOG_VERBOSE( "Processing residue " << index << " with range " << residue_segments[cur_segment].first << " " << residue_segments[cur_segment].second << std::endl); if (index >= residue_segments[cur_segment].first && index < residue_segments[cur_segment].second) { } else if (!cur.empty()) { IMP_LOG_VERBOSE( "Added particle for " << residue_segments[cur_segment].first << "..." << residue_segments[cur_segment].second << std::endl); Hierarchy cur_approx=create_approximation_of_residues(cur); root.add_child(cur_approx); if (keep_detailed) { for (unsigned int j=0; j< cur.size(); ++j) { cur[j].get_parent().remove_child(cur[j]); cur_approx.add_child(cur[j]); } } cur.clear(); ++cur_segment; } cur.push_back(child); } if (!cur.empty()) { root.add_child(create_approximation_of_residues(cur)); } /*#ifdef IMP_ATOM_USE_IMP_CGAL double ov= get_volume(in); double cv= get_volume(root); double scale=1; ParticlesTemp rt= get_by_type(root, XYZR_TYPE); Floats radii(rt.size()); for (unsigned int i=0; i< rt.size(); ++i) { core::XYZR d(rt[i]); radii[i]=d.get_radius(); } do { show(root); double f= ov/cv*scale; scale*=.95; IMP_LOG_TERSE( "Bumping radius by " << f << std::endl); for (unsigned int i=0; i< rt.size(); ++i) { core::XYZR d(rt[i]); d.set_radius(radii[i]*f); } double nv=get_volume(root); IMP_LOG_TERSE( "Got volume " << nv << " " << ov << std::endl); if (nv < ov) { break; } } while (true); #else #endif*/ IMP_INTERNAL_CHECK(root.get_is_valid(true), "Invalid hierarchy produced " << root); return root; }
void set_lpc_modeg ( Word16 *signal_ptr, /* I Input signal */ Word16 *a_fwd, /* I Forward LPC filter */ Word16 *a_bwd, /* I Backward LPC filter */ Word16 *mode, /* O Backward / forward Indication */ Word16 *lsp_new, /* I LSP vector current frame */ Word16 *lsp_old, /* I LSP vector previous frame */ Word16 *bwd_dominant,/* O Bwd dominant mode indication */ Word16 prev_mode, /* I previous frame Backward / forward Indication */ Word16 *prev_filter, /* I previous frame filter */ Word16 *C_int, /*I/O filter interpolation parameter */ Word16 *glob_stat, /* I/O Mre of global stationnarity Q8 */ Word16 *stat_bwd, /* I/O Number of consecutive backward frames */ Word16 *val_stat_bwd/* I/O Value associated with stat_bwd */ ) { Word16 i; Word16 res[L_FRAME]; Word16 *pa_bwd; Word16 gap; Word16 gpred_f, gpred_b, gpred_bint; Word16 tmp; Word32 thresh_lpc_L; Word32 tmp_L; Word32 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 */ tmp = shr(*glob_stat, 7); tmp_L = L_mult(tmp, 3); tmp_L = L_shr(tmp_L, 1); tmp = extract_l(tmp_L); gap = add(tmp, 205); if ( (gpred_bint > gpred_f - gap)&& (gpred_b > gpred_f - gap)&& (gpred_b > 0)&& (gpred_bint > 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 = sub(lsp_old[i],lsp_new[i]); dist_lsp = L_mac(dist_lsp, tmp, tmp); } /* Adaptation of the LSPs thresholds */ if (*glob_stat < 32000) { thresh_lpc_L = 0L; } else { thresh_lpc_L = 64424509L; } /* Switching backward -> forward forbidden in case of a LPC stationnary */ if ((dist_lsp < thresh_lpc_L)&&(*mode == 0)&&(prev_mode == 1)&&(gpred_b > 0)&&(gpred_bint > 0)) { *mode = 1; } /* Low energy frame => Forward mode chosen */ /* --------------------------------------- */ energy = ener_dB(signal_ptr, L_FRAME); if (energy < 8192) { *mode = 0; if (*glob_stat > 13000) *glob_stat = 13000; } else tst_bwd_dominant(bwd_dominant, *mode); /* Adaptation of the global stationnarity indicator */ /* ------------------------------------------------ */ if (energy >= 8192) calc_stat(gpred_b, gpred_f, *mode, prev_mode, glob_stat, stat_bwd, val_stat_bwd); if(*mode == 0) *C_int = 4506; return; }
/** Open the Charmm PSF file specified by filename and set up topology data. * Mask selection requires natom, nres, names, resnames, resnums. */ int Parm_CharmmPsf::ReadParm(FileName const& fname, Topology &parmOut) { const size_t TAGSIZE = 10; char tag[TAGSIZE]; tag[0]='\0'; CpptrajFile infile; if (infile.OpenRead(fname)) return 1; mprintf(" Reading Charmm PSF file %s as topology file.\n",infile.Filename().base()); // Read the first line, should contain PSF... const char* buffer = 0; if ( (buffer=infile.NextLine()) == 0 ) return 1; // Advance to <ntitle> !NTITLE int ntitle = FindTag(tag, "!NTITLE", 7, infile); // Only read in 1st title. Skip any asterisks. std::string psftitle; if (ntitle > 0) { buffer = infile.NextLine(); const char* ptr = buffer; while (*ptr != '\0' && (*ptr == ' ' || *ptr == '*')) ++ptr; psftitle.assign( ptr ); } parmOut.SetParmName( NoTrailingWhitespace(psftitle), infile.Filename() ); // Advance to <natom> !NATOM int natom = FindTag(tag, "!NATOM", 6, infile); if (debug_>0) mprintf("\tPSF: !NATOM tag found, natom=%i\n", natom); // If no atoms, probably issue with PSF file if (natom < 1) { mprinterr("Error: No atoms in PSF file.\n"); return 1; } // Read the next natom lines int psfresnum = 0; char psfresname[6]; char psfname[6]; char psftype[6]; double psfcharge; double psfmass; for (int atom=0; atom < natom; atom++) { if ( (buffer=infile.NextLine()) == 0 ) { mprinterr("Error: ReadParmPSF(): Reading atom %i\n",atom+1); return 1; } // Read line // ATOM# SEGID RES# RES ATNAME ATTYPE CHRG MASS (REST OF COLUMNS ARE LIKELY FOR CMAP AND CHEQ) sscanf(buffer,"%*i %*s %i %s %s %s %lf %lf",&psfresnum, psfresname, psfname, psftype, &psfcharge, &psfmass); parmOut.AddTopAtom( Atom( psfname, psfcharge, psfmass, psftype), Residue( psfresname, psfresnum, ' ', ' '), 0 ); } // END loop over atoms // Advance to <nbond> !NBOND int bondatoms[9]; int nbond = FindTag(tag, "!NBOND", 6, infile); if (nbond > 0) { if (debug_>0) mprintf("\tPSF: !NBOND tag found, nbond=%i\n", nbond); int nlines = nbond / 4; if ( (nbond % 4) != 0) nlines++; for (int bondline=0; bondline < nlines; bondline++) { if ( (buffer=infile.NextLine()) == 0 ) { mprinterr("Error: ReadParmPSF(): Reading bond line %i\n",bondline+1); return 1; } // Each line has 4 pairs of atom numbers int nbondsread = sscanf(buffer,"%i %i %i %i %i %i %i %i",bondatoms,bondatoms+1, bondatoms+2,bondatoms+3, bondatoms+4,bondatoms+5, bondatoms+6,bondatoms+7); // NOTE: Charmm atom nums start from 1 for (int bondidx=0; bondidx < nbondsread; bondidx+=2) parmOut.AddBond(bondatoms[bondidx]-1, bondatoms[bondidx+1]-1); } } else mprintf("Warning: PSF has no bonds.\n"); // Advance to <nangles> !NTHETA int nangle = FindTag(tag, "!NTHETA", 7, infile); if (nangle > 0) { if (debug_>0) mprintf("\tPSF: !NTHETA tag found, nangle=%i\n", nangle); int nlines = nangle / 3; if ( (nangle % 3) != 0) nlines++; for (int angleline=0; angleline < nlines; angleline++) { if ( (buffer=infile.NextLine()) == 0) { mprinterr("Error: Reading angle line %i\n", angleline+1); return 1; } // Each line has 3 groups of 3 atom numbers int nanglesread = sscanf(buffer,"%i %i %i %i %i %i %i %i %i",bondatoms,bondatoms+1, bondatoms+2,bondatoms+3, bondatoms+4,bondatoms+5, bondatoms+6,bondatoms+7, bondatoms+8); for (int angleidx=0; angleidx < nanglesread; angleidx += 3) parmOut.AddAngle( bondatoms[angleidx ]-1, bondatoms[angleidx+1]-1, bondatoms[angleidx+2]-1 ); } } else mprintf("Warning: PSF has no angles.\n"); // Advance to <ndihedrals> !NPHI int ndihedral = FindTag(tag, "!NPHI", 5, infile); if (ndihedral > 0) { if (debug_>0) mprintf("\tPSF: !NPHI tag found, ndihedral=%i\n", ndihedral); int nlines = ndihedral / 2; if ( (ndihedral % 2) != 0) nlines++; for (int dihline = 0; dihline < nlines; dihline++) { if ( (buffer=infile.NextLine()) == 0) { mprinterr("Error: Reading dihedral line %i\n", dihline+1); return 1; } // Each line has 2 groups of 4 atom numbers int ndihread = sscanf(buffer,"%i %i %i %i %i %i %i %i",bondatoms,bondatoms+1, bondatoms+2,bondatoms+3, bondatoms+4,bondatoms+5, bondatoms+6,bondatoms+7); for (int dihidx=0; dihidx < ndihread; dihidx += 4) parmOut.AddDihedral( bondatoms[dihidx ]-1, bondatoms[dihidx+1]-1, bondatoms[dihidx+2]-1, bondatoms[dihidx+3]-1 ); } } else mprintf("Warning: PSF has no dihedrals.\n"); mprintf("\tPSF contains %i atoms, %i residues.\n", parmOut.Natom(), parmOut.Nres()); infile.CloseFile(); return 0; }
/*---------------------------------------------------------------------------- * Post - adaptive postfilter main function *---------------------------------------------------------------------------- */ void Poste( Word16 t0, /* input : pitch delay given by coder */ Word16 *signal_ptr, /* input : input signal (pointer to current subframe */ Word16 *coeff, /* input : LPC coefficients for current subframe */ Word16 *sig_out, /* output: postfiltered output */ Word16 *vo, /* output: voicing decision 0 = uv, > 0 delay */ Word16 gamma1, /* input: short term postfilt. den. weighting factor*/ Word16 gamma2, /* input: short term postfilt. num. weighting factor*/ Word16 gamma_harm, /* input: long term postfilter weighting factor*/ Word16 long_h_st, /* input: impulse response length*/ Word16 m_pst, /* input: LPC order */ Word16 Vad ) { /* Local variables and arrays */ Word16 apond1[M_BWDP1]; /* s.t. denominator coeff. */ Word16 sig_ltp[L_SUBFRP1]; /* H0 output signal */ Word16 *sig_ltp_ptr; Word16 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], (Word16)(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 (sub(Vad,1) > 0) 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; }