int main(int argc, char ** argv) { MPI_Init(&argc, &argv); // Step 0 of 5: Set up environment QUESO::FullEnvironment env(MPI_COMM_WORLD, argv[1], "", NULL); // Step 1 of 5: Instantiate the parameter space QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpace(env, "param_", 1, NULL); // Step 2 of 5: Set up the prior QUESO::GslVector paramMins(paramSpace.zeroVector()); paramMins.cwSet(min_val); QUESO::GslVector paramMaxs(paramSpace.zeroVector()); paramMaxs.cwSet(max_val); QUESO::BoxSubset<QUESO::GslVector, QUESO::GslMatrix> paramDomain("param_", paramSpace, paramMins, paramMaxs); // Uniform prior here. Could be a different prior. QUESO::UniformVectorRV<QUESO::GslVector, QUESO::GslMatrix> priorRv("prior_", paramDomain); // Step 3 of 5: Set up the likelihood using the class above Likelihood<QUESO::GslVector, QUESO::GslMatrix> lhood("llhd_", paramDomain); // Step 4 of 5: Instantiate the inverse problem QUESO::GenericVectorRV<QUESO::GslVector, QUESO::GslMatrix> postRv("post_", paramSpace); QUESO::StatisticalInverseProblem<QUESO::GslVector, QUESO::GslMatrix> ip("", NULL, priorRv, lhood, postRv); // Step 5 of 5: Solve the inverse problem QUESO::GslVector paramInitials(paramSpace.zeroVector()); // Initial condition of the chain paramInitials[0] = 0.0; paramInitials[1] = 0.0; QUESO::GslMatrix proposalCovMatrix(paramSpace.zeroVector()); for (unsigned int i = 0; i < 2; i++) { // Might need to tweak this proposalCovMatrix(i, i) = 0.1; } ip.solveWithBayesMetropolisHastings(NULL, paramInitials, &proposalCovMatrix); MPI_Finalize(); return 0; }
int main(int argc, char ** argv) { MPI_Init(&argc, &argv); QUESO::FullEnvironment env(MPI_COMM_WORLD, argv[1], "", NULL); QUESO::VectorSpace<> paramSpace(env, "param_", 1, NULL); QUESO::GslVector paramMins(paramSpace.zeroVector()); QUESO::GslVector paramMaxs(paramSpace.zeroVector()); double min_val = 0.0; double max_val = 1.0; paramMins.cwSet(min_val); paramMaxs.cwSet(max_val); QUESO::BoxSubset<> paramDomain("param_", paramSpace, paramMins, paramMaxs); QUESO::UniformVectorRV<> priorRv("prior_", paramDomain); Likelihood<> lhood("llhd_", paramDomain); QUESO::GenericVectorRV<> postRv("post_", paramSpace); QUESO::StatisticalInverseProblem<> ip("", NULL, priorRv, lhood, postRv); QUESO::GslVector paramInitials(paramSpace.zeroVector()); paramInitials[0] = 0.0; QUESO::GslMatrix proposalCovMatrix(paramSpace.zeroVector()); proposalCovMatrix(0, 0) = 0.1; ip.solveWithBayesMetropolisHastings(NULL, paramInitials, &proposalCovMatrix); MPI_Finalize(); return 0; }
int main(int argc, char ** argv) { MPI_Init(&argc, &argv); QUESO::FullEnvironment env(MPI_COMM_WORLD, argv[1], "", NULL); QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpace(env, "param_", 2, NULL); double min_val = 0.0; double max_val = 1.0; QUESO::GslVector paramMins(paramSpace.zeroVector()); QUESO::GslVector paramMaxs(paramSpace.zeroVector()); // Model parameter between 0 and 1 paramMins[0] = 0.0; paramMaxs[0] = 1.0; // Hyperparameter (multiplicative coefficient of observational error // covariance matrix) between 0.0 and \infty paramMins[1] = 0.0; paramMaxs[1] = INFINITY; QUESO::BoxSubset<QUESO::GslVector, QUESO::GslMatrix> paramDomain("param_", paramSpace, paramMins, paramMaxs); QUESO::UniformVectorRV<QUESO::GslVector, QUESO::GslMatrix> priorRv("prior_", paramDomain); // Set up observation space QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> obsSpace(env, "obs_", 2, NULL); // Fill up observation vector QUESO::GslVector observations(obsSpace.zeroVector()); observations[0] = 1.0; observations[1] = 1.0; // Fill up covariance 'matrix' QUESO::GslMatrix covariance(obsSpace.zeroVector()); covariance(0, 0) = 1.0; covariance(0, 1) = 0.0; covariance(1, 0) = 0.0; covariance(1, 1) = 1.0; // Pass in observations to Gaussian likelihood object Likelihood<QUESO::GslVector, QUESO::GslMatrix> lhood("llhd_", paramDomain, observations, covariance); QUESO::GenericVectorRV<QUESO::GslVector, QUESO::GslMatrix> postRv("post_", paramSpace); QUESO::StatisticalInverseProblem<QUESO::GslVector, QUESO::GslMatrix> ip("", NULL, priorRv, lhood, postRv); QUESO::GslVector paramInitials(paramSpace.zeroVector()); paramInitials[0] = 0.0; QUESO::GslMatrix proposalCovMatrix(paramSpace.zeroVector()); for (unsigned int i = 0; i < 1; i++) { proposalCovMatrix(i, i) = 0.1; } ip.solveWithBayesMetropolisHastings(NULL, paramInitials, &proposalCovMatrix); MPI_Finalize(); return 0; }
int main(int argc, char ** argv) { #ifdef QUESO_HAS_MPI MPI_Init(&argc, &argv); #endif QUESO::EnvOptionsValues envOptions; envOptions.m_numSubEnvironments = 1; envOptions.m_subDisplayFileName = "test_outputNoInputFile/display"; envOptions.m_subDisplayAllowAll = 1; envOptions.m_displayVerbosity = 2; envOptions.m_syncVerbosity = 0; envOptions.m_seed = 0; #ifdef QUESO_HAS_MPI QUESO::FullEnvironment env(MPI_COMM_WORLD, "", "", &envOptions); #else QUESO::FullEnvironment env("", "", &envOptions); #endif unsigned int dim = 2; QUESO::VectorSpace<> paramSpace(env, "param_", dim, NULL); QUESO::GslVector paramMins(paramSpace.zeroVector()); QUESO::GslVector paramMaxs(paramSpace.zeroVector()); double min_val = -10.0; double max_val = 10.0; paramMins.cwSet(min_val); paramMaxs.cwSet(max_val); QUESO::BoxSubset<> paramDomain("param_", paramSpace, paramMins, paramMaxs); QUESO::UniformVectorRV<> priorRv("prior_", paramDomain); Likelihood<> lhood("llhd_", paramDomain); QUESO::GenericVectorRV<> postRv("post_", paramSpace); QUESO::SipOptionsValues sipOptions; sipOptions.m_computeSolution = 1; sipOptions.m_dataOutputFileName = "test_outputNoInputFile/sipOutput"; sipOptions.m_dataOutputAllowedSet.clear(); sipOptions.m_dataOutputAllowedSet.insert(0); QUESO::StatisticalInverseProblem<> ip("", &sipOptions, priorRv, lhood, postRv); QUESO::GslVector paramInitials(paramSpace.zeroVector()); paramInitials[0] = 0.0; paramInitials[1] = 0.0; QUESO::GslMatrix proposalCovMatrix(paramSpace.zeroVector()); proposalCovMatrix(0, 0) = 1.0; proposalCovMatrix(0, 1) = 0.0; proposalCovMatrix(1, 0) = 0.0; proposalCovMatrix(1, 1) = 1.0; QUESO::MhOptionsValues mhOptions; mhOptions.m_dataOutputFileName = "test_outputNoInputFile/sipOutput"; mhOptions.m_dataOutputAllowAll = 1; mhOptions.m_rawChainGenerateExtra = 0; mhOptions.m_rawChainDisplayPeriod = 50000; mhOptions.m_rawChainMeasureRunTimes = 1; mhOptions.m_rawChainDataOutputFileName = "test_outputNoInputFile/ip_raw_chain"; mhOptions.m_rawChainDataOutputAllowAll = 1; mhOptions.m_displayCandidates = 0; mhOptions.m_tkUseLocalHessian = 0; mhOptions.m_tkUseNewtonComponent = 1; mhOptions.m_filteredChainGenerate = 0; mhOptions.m_rawChainSize = 1000; mhOptions.m_putOutOfBoundsInChain = false; mhOptions.m_drMaxNumExtraStages = 1; mhOptions.m_drScalesForExtraStages.resize(1); mhOptions.m_drScalesForExtraStages[0] = 5.0; mhOptions.m_amInitialNonAdaptInterval = 100; mhOptions.m_amAdaptInterval = 100; mhOptions.m_amEta = (double) 2.4 * 2.4 / dim; // From Gelman 95 mhOptions.m_amEpsilon = 1.e-8; mhOptions.m_doLogitTransform = false; mhOptions.m_algorithm = "random_walk"; mhOptions.m_tk = "random_walk"; ip.solveWithBayesMetropolisHastings(&mhOptions, paramInitials, &proposalCovMatrix); #ifdef QUESO_HAS_MPI MPI_Finalize(); #endif return 0; }
int main(int argc, char ** argv) { MPI_Init(&argc, &argv); QUESO::FullEnvironment env(MPI_COMM_WORLD, "test_gaussian_likelihoods/queso_input.txt", "", NULL); QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpace(env, "param_", 1, NULL); double min_val = -INFINITY; double max_val = INFINITY; QUESO::GslVector paramMins(paramSpace.zeroVector()); paramMins.cwSet(min_val); QUESO::GslVector paramMaxs(paramSpace.zeroVector()); paramMaxs.cwSet(max_val); QUESO::BoxSubset<QUESO::GslVector, QUESO::GslMatrix> paramDomain("param_", paramSpace, paramMins, paramMaxs); // Set up observation space QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> obsSpace(env, "obs_", 2, NULL); // Fill up observation vector QUESO::GslVector observations(obsSpace.zeroVector()); observations[0] = 1.0; observations[1] = 1.0; // Fill up covariance 'matrix' QUESO::GslVector covariance(obsSpace.zeroVector()); covariance[0] = 1.0; covariance[1] = 2.0; // Pass in observations to Gaussian likelihood object Likelihood<QUESO::GslVector, QUESO::GslMatrix> lhood("llhd_", paramDomain, observations, covariance); double lhood_value; double truth_value; QUESO::GslVector point(paramSpace.zeroVector()); point[0] = 0.0; lhood_value = lhood.actualValue(point, NULL, NULL, NULL, NULL); truth_value = std::exp(-3.0); if (std::abs(lhood_value - truth_value) > TOL) { std::cerr << "Scalar Gaussian test case failure." << std::endl; std::cerr << "Computed likelihood value is: " << lhood_value << std::endl; std::cerr << "Likelihood value should be: " << truth_value << std::endl; queso_error(); } point[0] = -2.0; lhood_value = lhood.actualValue(point, NULL, NULL, NULL, NULL); truth_value = 1.0; if (std::abs(lhood_value - truth_value) > TOL) { std::cerr << "Scalar Gaussian test case failure." << std::endl; std::cerr << "Computed likelihood value is: " << lhood_value << std::endl; std::cerr << "Likelihood value should be: " << truth_value << std::endl; queso_error(); } MPI_Finalize(); return 0; }
int main(int argc, char ** argv) { #ifdef QUESO_HAS_MPI MPI_Init(&argc, &argv); QUESO::FullEnvironment env(MPI_COMM_WORLD, argv[1], "", NULL); #else QUESO::FullEnvironment env(argv[1], "", NULL); #endif QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpace(env, "param_", 1, NULL); double min_val = 0.0; double max_val = 1.0; QUESO::GslVector paramMins(paramSpace.zeroVector()); paramMins.cwSet(min_val); QUESO::GslVector paramMaxs(paramSpace.zeroVector()); paramMaxs.cwSet(max_val); QUESO::BoxSubset<QUESO::GslVector, QUESO::GslMatrix> paramDomain("param_", paramSpace, paramMins, paramMaxs); QUESO::UniformVectorRV<QUESO::GslVector, QUESO::GslMatrix> priorRv("prior_", paramDomain); // Set up observation space QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> obsSpace(env, "obs_", 2, NULL); // Fill up observation vector QUESO::GslVector observations(obsSpace.zeroVector()); observations[0] = 1.0; observations[1] = 1.0; // Pass in observations to Gaussian likelihood object Likelihood<QUESO::GslVector, QUESO::GslMatrix> lhood("llhd_", paramDomain, observations, 1.0); QUESO::GenericVectorRV<QUESO::GslVector, QUESO::GslMatrix> postRv("post_", paramSpace); QUESO::StatisticalInverseProblem<QUESO::GslVector, QUESO::GslMatrix> ip("", NULL, priorRv, lhood, postRv); QUESO::GslVector paramInitials(paramSpace.zeroVector()); paramInitials[0] = 0.0; QUESO::GslMatrix proposalCovMatrix(paramSpace.zeroVector()); for (unsigned int i = 0; i < 1; i++) { proposalCovMatrix(i, i) = 0.1; } ip.solveWithBayesMetropolisHastings(NULL, paramInitials, &proposalCovMatrix); #ifdef QUESO_HAS_MPI MPI_Finalize(); #endif return 0; }
int main(int argc, char ** argv) { std::string inputFileName = "test_gaussian_likelihoods/queso_input.txt"; const char * test_srcdir = std::getenv("srcdir"); if (test_srcdir) inputFileName = test_srcdir + ('/' + inputFileName); #ifdef QUESO_HAS_MPI MPI_Init(&argc, &argv); QUESO::FullEnvironment env(MPI_COMM_WORLD, inputFileName, "", NULL); #else QUESO::FullEnvironment env(inputFileName, "", NULL); #endif QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpace(env, "param_", 1, NULL); double min_val = -INFINITY; double max_val = INFINITY; QUESO::GslVector paramMins(paramSpace.zeroVector()); paramMins.cwSet(min_val); QUESO::GslVector paramMaxs(paramSpace.zeroVector()); paramMaxs.cwSet(max_val); QUESO::BoxSubset<QUESO::GslVector, QUESO::GslMatrix> paramDomain("param_", paramSpace, paramMins, paramMaxs); // Set up observation space QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> obsSpace(env, "obs_", 1, NULL); // Fill up observation vector QUESO::GslVector observations(obsSpace.zeroVector()); observations[0] = 1.0; // Pass in observations to Gaussian likelihood object Likelihood<QUESO::GslVector, QUESO::GslMatrix> lhood("llhd_", paramDomain, observations, 1.0); double lhood_value; double truth_value; QUESO::GslVector point(paramSpace.zeroVector()); point[0] = 0.0; lhood_value = lhood.actualValue(point, NULL, NULL, NULL, NULL); truth_value = std::exp(-2.0); if (std::abs(lhood_value - truth_value) > TOL) { std::cerr << "Scalar Gaussian test case failure." << std::endl; std::cerr << "Computed likelihood value is: " << lhood_value << std::endl; std::cerr << "Likelihood value should be: " << truth_value << std::endl; queso_error(); } point[0] = -2.0; lhood_value = lhood.actualValue(point, NULL, NULL, NULL, NULL); truth_value = 1.0; if (std::abs(lhood_value - truth_value) > TOL) { std::cerr << "Scalar Gaussian test case failure." << std::endl; std::cerr << "Computed likelihood value is: " << lhood_value << std::endl; std::cerr << "Likelihood value should be: " << truth_value << std::endl; queso_error(); } #ifdef QUESO_HAS_MPI MPI_Finalize(); #endif return 0; }
void infer_slope(const QUESO::FullEnvironment & env) { // Statistical Inverse Problem: Compute posterior pdf for slope 'm' and y-intercept c // Step 1: Instantiate the parameter space QUESO::VectorSpace<> paramSpace(env, "param_", 2, NULL); // 2 since we have a 2D problem // Step 2: Parameter domain QUESO::GslVector paramMinValues(paramSpace.zeroVector()); QUESO::GslVector paramMaxValues(paramSpace.zeroVector()); paramMinValues[0] = 2.; paramMaxValues[0] = 5.; paramMinValues[1] = 3.; paramMaxValues[1] = 7.; QUESO::BoxSubset<> paramDomain("param_", paramSpace, paramMinValues, paramMaxValues); // Step 3: Instantiate likelihood Likelihood<> lhood("like_", paramDomain); // Step 4: Define the prior RV QUESO::UniformVectorRV<> priorRv("prior_", paramDomain); // Step 5: Instantiate the inverse problem QUESO::GenericVectorRV<> postRv("post_", paramSpace); QUESO::StatisticalInverseProblem<> ip("", NULL, priorRv, lhood, postRv); // Step 6: Solve the inverse problem // Randomly sample for the initial state? QUESO::GslVector paramInitials(paramSpace.zeroVector()); priorRv.realizer().realization(paramInitials); // Initialize the Cov matrix: QUESO::GslMatrix proposalCovMatrix(paramSpace.zeroVector()); proposalCovMatrix(0,0) = std::pow(std::abs(paramInitials[0]) / 20.0, 2.0); proposalCovMatrix(1,1) = std::pow(std::abs(paramInitials[1]) / 20.0, 2.0); ip.solveWithBayesMetropolisHastings(NULL, paramInitials, &proposalCovMatrix); // Using the posterior pdfs for m and c, compute 'y' at a given 'x' // Step 1: Instantiate the qoi space QUESO::VectorSpace<> qoiSpace(env, "qoi_", 1, NULL); // Step 2: Instantiate the parameter domain // Not necessary here because the posterior from SIP is used as the RV for SFP // Step 3: Instantiate the qoi object to be used by QUESO Qoi<> qoi("qoi_", paramDomain, qoiSpace); // Step 4: Define the input RV // Not required because we use the posterior as RV // Step 5: Instantiate the forward problem QUESO::GenericVectorRV<> qoiRv("qoi_", qoiSpace); QUESO::StatisticalForwardProblem<> fp("", NULL, postRv, qoi, qoiRv); // Step 6: Solve the forward problem std::cout << "Solving the SFP with Monte Carlo" << std::endl << std::endl; fp.solveWithMonteCarlo(NULL); system("mv outputData/sfp_lineSlope_qoi_seq.txt outputData/sfp_lineSlope_qoi_seq_post.txt"); // SENSITIVITY ANALYSIS // For m Qoi_m<> qoi_m("qoi_", paramDomain, qoiSpace); // Step 4: Define the input RV // Not required because we use the prior as RV for sensitivity analysis // Step 5: Instantiate the forward problem QUESO::StatisticalForwardProblem<> fp_m("", NULL, priorRv, qoi_m, qoiRv); // Step 6: Solve the forward problem fp_m.solveWithMonteCarlo(NULL); system("mv outputData/sfp_lineSlope_qoi_seq.txt outputData/sense_m.txt"); // For c Qoi_c<> qoi_c("qoi_", paramDomain, qoiSpace); // Step 4: Define the input RV // Not required because we use the prior as RV for sensitivity analysis // Step 5: Instantiate the forward problem QUESO::StatisticalForwardProblem<> fp_c("", NULL, priorRv, qoi_c, qoiRv); // Step 6: Solve the forward problem fp_c.solveWithMonteCarlo(NULL); system("mv outputData/sfp_lineSlope_qoi_seq.txt outputData/sense_c.txt"); // For both, m and c Qoi_mc<> qoi_mc("qoi_", paramDomain, qoiSpace); // Step 4: Define the input RV // Not required because we use the prior as RV for sensitivity analysis // Step 5: Instantiate the forward problem QUESO::StatisticalForwardProblem<> fp_mc("", NULL, priorRv, qoi_mc, qoiRv); // Step 6: Solve the forward problem fp_mc.solveWithMonteCarlo(NULL); system("mv outputData/sfp_lineSlope_qoi_seq.txt outputData/sense_mc.txt"); }
int main(int argc, char* argv[]) { #ifndef QUESO_HAS_MPI // Skip this test if we're not in parallel return 77; #else MPI_Init(&argc, &argv); std::string inputFileName = argv[1]; const char * test_srcdir = std::getenv("srcdir"); if (test_srcdir) inputFileName = test_srcdir + ('/' + inputFileName); // Initialize QUESO environment QUESO::FullEnvironment env(MPI_COMM_WORLD, inputFileName, "", NULL); //================================================================ // Statistical inverse problem (SIP): find posterior PDF for 'g' //================================================================ //------------------------------------------------------ // SIP Step 1 of 6: Instantiate the parameter space //------------------------------------------------------ QUESO::VectorSpace<> paramSpace(env, "param_", 1, NULL); //------------------------------------------------------ // SIP Step 2 of 6: Instantiate the parameter domain //------------------------------------------------------ QUESO::GslVector paramMinValues(paramSpace.zeroVector()); QUESO::GslVector paramMaxValues(paramSpace.zeroVector()); paramMinValues[0] = 8.; paramMaxValues[0] = 11.; QUESO::BoxSubset<> paramDomain("param_", paramSpace, paramMinValues, paramMaxValues); //------------------------------------------------------ // SIP Step 3 of 6: Instantiate the likelihood function // object to be used by QUESO. //------------------------------------------------------ Likelihood<> lhood("like_", paramDomain); //------------------------------------------------------ // SIP Step 4 of 6: Define the prior RV //------------------------------------------------------ QUESO::UniformVectorRV<> priorRv("prior_", paramDomain); //------------------------------------------------------ // SIP Step 5 of 6: Instantiate the inverse problem //------------------------------------------------------ // Extra prefix before the default "rv_" prefix QUESO::GenericVectorRV<> postRv("post_", paramSpace); // No extra prefix before the default "ip_" prefix QUESO::StatisticalInverseProblem<> ip("", NULL, priorRv, lhood, postRv); //------------------------------------------------------ // SIP Step 6 of 6: Solve the inverse problem, that is, // set the 'pdf' and the 'realizer' of the posterior RV //------------------------------------------------------ QUESO::GslVector paramInitials(paramSpace.zeroVector()); priorRv.realizer().realization(paramInitials); QUESO::GslMatrix proposalCovMatrix(paramSpace.zeroVector()); proposalCovMatrix(0,0) = std::pow(std::abs(paramInitials[0]) / 20.0, 2.0); ip.solveWithBayesMetropolisHastings(NULL, paramInitials, &proposalCovMatrix); //================================================================ // Statistical forward problem (SFP): find the max distance // traveled by an object in projectile motion; input pdf for 'g' // is the solution of the SIP above. //================================================================ //------------------------------------------------------ // SFP Step 1 of 6: Instantiate the parameter *and* qoi spaces. // SFP input RV = FIP posterior RV, so SFP parameter space // has been already defined. //------------------------------------------------------ QUESO::VectorSpace<> qoiSpace(env, "qoi_", 1, NULL); //------------------------------------------------------ // SFP Step 2 of 6: Instantiate the parameter domain //------------------------------------------------------ // Not necessary because input RV of the SFP = output RV of SIP. // Thus, the parameter domain has been already defined. //------------------------------------------------------ // SFP Step 3 of 6: Instantiate the qoi object // to be used by QUESO. //------------------------------------------------------ Qoi<> qoi("qoi_", paramDomain, qoiSpace); //------------------------------------------------------ // SFP Step 4 of 6: Define the input RV //------------------------------------------------------ // Not necessary because input RV of SFP = output RV of SIP // (postRv). //------------------------------------------------------ // SFP Step 5 of 6: Instantiate the forward problem //------------------------------------------------------ QUESO::GenericVectorRV<> qoiRv("qoi_", qoiSpace); QUESO::StatisticalForwardProblem<> fp("", NULL, postRv, qoi, qoiRv); //------------------------------------------------------ // SFP Step 6 of 6: Solve the forward problem //------------------------------------------------------ fp.solveWithMonteCarlo(NULL); MPI_Finalize(); return 0; #endif // QUESO_HAS_MPI }
void somatic_snv_caller_strand_grid:: position_somatic_snv_call(const extended_pos_info& normal_epi, const extended_pos_info& tumor_epi, const extended_pos_info* normal_epi_t2_ptr, const extended_pos_info* tumor_epi_t2_ptr, somatic_snv_genotype_grid& sgt) const { static const bool is_always_test(false); { const snp_pos_info& normal_pi(normal_epi.pi); const snp_pos_info& tumor_pi(tumor_epi.pi); if(normal_pi.ref_base=='N') return; sgt.ref_gt=base_to_id(normal_pi.ref_base); // check that a non-reference call meeting quality criteria even // exists: if(not is_always_test) { if(is_spi_allref(normal_pi,sgt.ref_gt) and is_spi_allref(tumor_pi,sgt.ref_gt)) return; } } // strawman model treats normal and tumor as independent, so // calculate separate lhoods: blt_float_t normal_lhood[DIGT_SGRID::SIZE]; blt_float_t tumor_lhood[DIGT_SGRID::SIZE]; const bool is_tier2(NULL != normal_epi_t2_ptr); static const unsigned n_tier(2); result_set tier_rs[n_tier]; for(unsigned i(0); i<n_tier; ++i) { const bool is_include_tier2(i==1); if(is_include_tier2) { if(! is_tier2) continue; if(tier_rs[0].snv_qphred==0) { tier_rs[1].snv_qphred=0; continue; } } // get likelihood of each genotype // static const bool is_normal_het_bias(false); static const blt_float_t normal_het_bias(0.0); static const bool is_tumor_het_bias(false); static const blt_float_t tumor_het_bias(0.0); const extended_pos_info& nepi(is_include_tier2 ? *normal_epi_t2_ptr : normal_epi ); const extended_pos_info& tepi(is_include_tier2 ? *tumor_epi_t2_ptr : tumor_epi ); get_diploid_gt_lhood_spi(_opt,nepi.pi,is_normal_het_bias,normal_het_bias,normal_lhood); get_diploid_gt_lhood_spi(_opt,tepi.pi,is_tumor_het_bias,tumor_het_bias,tumor_lhood); get_diploid_het_grid_lhood_spi(nepi.pi,normal_lhood+DIGT::SIZE); get_diploid_het_grid_lhood_spi(tepi.pi,tumor_lhood+DIGT::SIZE); get_diploid_strand_grid_lhood_spi(nepi.pi,sgt.ref_gt,normal_lhood+DIGT_SGRID::PRESTRAND_SIZE); get_diploid_strand_grid_lhood_spi(tepi.pi,sgt.ref_gt,tumor_lhood+DIGT_SGRID::PRESTRAND_SIZE); // genomic site results: calculate_result_set_grid(normal_lhood, tumor_lhood, get_prior_set(sgt.ref_gt), _ln_som_match,_ln_som_mismatch, sgt.ref_gt, tier_rs[i]); #if 0 #ifdef ENABLE_POLY // polymorphic site results: assert(0); // still needs to be adapted for 2-tier system: calculate_result_set(normal_lhood,tumor_lhood, lnprior_polymorphic(sgt.ref_gt),sgt.ref_gt,sgt.poly); #else sgt.poly.snv_qphred = 0; #endif #endif #ifdef SOMATIC_DEBUG if((i==0) && (tier_rs[i].snv_qphred > 0)) { const somatic_snv_caller_strand_grid::prior_set& pset(get_prior_set(sgt.ref_gt)); const blt_float_t lnmatch(_ln_som_match); const blt_float_t lnmismatch(_ln_som_mismatch); log_os << "DUMP ON\n"; log_os << "tier1_qphred: " << tier_rs[0].snv_qphred << "\n"; // instead of dumping the entire distribution, we sort the lhood,prior,and prob to print out the N top values of each: std::vector<double> lhood(DDIGT_SGRID::SIZE); std::vector<double> prior(DDIGT_SGRID::SIZE); std::vector<double> post(DDIGT_SGRID::SIZE); // first get raw lhood: // for(unsigned ngt(0); ngt<DIGT_SGRID::PRESTRAND_SIZE; ++ngt) { for(unsigned tgt(0); tgt<DIGT_SGRID::PRESTRAND_SIZE; ++tgt) { const unsigned dgt(DDIGT_SGRID::get_state(ngt,tgt)); // unorm takes the role of the normal prior for the somatic case: // static const blt_float_t unorm(std::log(static_cast<blt_float_t>(DIGT_SGRID::PRESTRAND_SIZE))); //blt_float_t prior; //if(tgt==ngt) { prior=pset.normal[ngt]+lnmatch; } //else { prior=pset.somatic_marginal[ngt]+lnmismatch; } blt_float_t pr; if(tgt==ngt) { pr=pset.normal[ngt]+lnmatch; } else { pr=pset.somatic_marginal[ngt]+lnmismatch; } prior[dgt] = pr; lhood[dgt] = normal_lhood[ngt]+tumor_lhood[tgt]; post[dgt] = lhood[dgt] + prior[dgt]; } } for(unsigned gt(DIGT_SGRID::PRESTRAND_SIZE); gt<DIGT_SGRID::SIZE; ++gt) { const unsigned dgt(DDIGT_SGRID::get_state(gt,gt)); lhood[dgt] = normal_lhood[gt]+tumor_lhood[gt]; prior[dgt] = pset.normal[gt]+lnmatch; post[dgt] = lhood[dgt] + prior[dgt]; } std::vector<double> lhood2(lhood); sort_n_dump("lhood_prior",lhood,prior,sgt.ref_gt); sort_n_dump("post_lhood",post,lhood2,sgt.ref_gt); log_os << "DUMP OFF\n"; } #endif } if((tier_rs[0].snv_qphred==0) || (is_tier2 && (tier_rs[1].snv_qphred==0))) return; sgt.snv_tier=0; sgt.snv_from_ntype_tier=0; if(is_tier2) { if(tier_rs[0].snv_qphred > tier_rs[1].snv_qphred) { sgt.snv_tier=1; } if(tier_rs[0].snv_from_ntype_qphred > tier_rs[1].snv_from_ntype_qphred) { sgt.snv_from_ntype_tier=1; } } sgt.rs=tier_rs[sgt.snv_from_ntype_tier]; if(is_tier2 && (tier_rs[0].ntype != tier_rs[1].ntype)) { // catch NTYPE conflict states: sgt.rs.ntype = NTYPE::CONFLICT; sgt.rs.snv_from_ntype_qphred = 0; } else { // classify NTYPE: // // convert diploid genotype into more limited ntype set: // if (sgt.rs.ntype==sgt.ref_gt) { sgt.rs.ntype=NTYPE::REF; } else if(DIGT::is_het(sgt.rs.ntype)) { sgt.rs.ntype=NTYPE::HET; } else { sgt.rs.ntype=NTYPE::HOM; } } sgt.rs.snv_qphred = tier_rs[sgt.snv_tier].snv_qphred; sgt.is_snv=((sgt.rs.snv_qphred != 0)); }