示例#1
0
void
MooseEnumTest::withNamesFromTest()
{
  //
  // Construct MultiMooseEnum from MooseEnum
  //
  MooseEnum me1("one two three four");
  MultiMooseEnum mme1 = MultiMooseEnum::withNamesFrom(me1);

  // set in-range values
  mme1 = "one two";
  CPPUNIT_ASSERT( mme1.contains("one") == true );
  CPPUNIT_ASSERT( mme1.contains("two") == true );
  CPPUNIT_ASSERT( mme1.contains("three") == false );
  CPPUNIT_ASSERT( mme1.contains("four") == false );

  // set out-of-range values
  try
  {
    mme1 = "five";
  }
  catch(const std::exception & e)
  {
    std::string msg(e.what());
    CPPUNIT_ASSERT( msg.find("Invalid option") != std::string::npos );
  }

  // construct mme with out-of-range-allowed
  MooseEnum me2("one two three four", "", true);
  MultiMooseEnum mme2 = MultiMooseEnum::withNamesFrom(me2);
  mme2 = "six";
  CPPUNIT_ASSERT( mme2.contains("six") == true );

  //
  // Construct MooseEnum from MultiMooseEnum
  //
  MultiMooseEnum mme3("one two three four");
  MooseEnum me3 = MooseEnum::withNamesFrom(mme3);

  // set in-range values
  me3 = "one";
  CPPUNIT_ASSERT( me3 == "one" );

  // set out-of-range values
  try
  {
    me3 = "five";
  }
  catch(const std::exception & e)
  {
    std::string msg(e.what());
    CPPUNIT_ASSERT( msg.find("Invalid option") != std::string::npos );
  }

  // construct mme with out-of-range-allowed
  MultiMooseEnum mme4("one two three four", "", true);
  MooseEnum me4 = MooseEnum::withNamesFrom(mme4);
  me4 = "six";
  CPPUNIT_ASSERT( me4 == "six" );
}
示例#2
0
void
MooseEnumTest::testDeprecate()
{
  // Intentionally misspelling
  MooseEnum me1("one too three four", "too");

  try
  {
    me1.deprecate("too", "two");

    // Unreachable
    CPPUNIT_ASSERT( false );
  }
  catch(const std::exception & e)
  {
    std::string msg(e.what());

    CPPUNIT_ASSERT( msg.find("is deprecated, consider using") != std::string::npos );
  }

  me1 = "one";
  try
  {
    me1 = "too";

    // Unreachable
    CPPUNIT_ASSERT( false );
  }
  catch(const std::exception & e)
  {
    std::string msg(e.what());
    CPPUNIT_ASSERT( msg.find("is deprecated, consider using") != std::string::npos );
  }

  MultiMooseEnum mme1("one too three four");
  mme1.deprecate("too", "two");

  mme1.push_back("one");
  try
  {
    me1 = "too";

    // Unreachable
    CPPUNIT_ASSERT( false );
  }
  catch(const std::exception & e)
  {
    std::string msg(e.what());
    CPPUNIT_ASSERT( msg.find("is deprecated, consider using") != std::string::npos );
  }
}
示例#3
0
文件: AmpDS1.cpp 项目: silvest/HEPfit
gslpp::complex AmpDS1::AmpDS1pp0(orders order) 
{
    if (mySM.getFlavour().getHDS1().getCoeffDS1PP().getOrder() < order){
        std::stringstream out;
        out << order;
        throw std::runtime_error("AmpDK1::computeThValue(): requires cofficient of order" 
                                 + out.str() + "not computed");
    }

    gslpp::vector<gslpp::complex> ** allcoeff = mySM.getFlavour().ComputeCoeffDS1PP(
            mySM.getBKd1().getMu(),
            mySM.getBKd1().getScheme());

    gslpp::vector<double> me1(mySM.getBKd1().getBpars());
    
    double MK = mySM.getMesons(QCD::K_0).getMass();
    double MP = mySM.getMesons(QCD::P_0).getMass();
    double FK = mySM.getMesons(QCD::K_0).getDecayconst();
    double FP = mySM.getMesons(QCD::P_0).getDecayconst();
    double Ms = mySM.Mrun(mySM.getBKd1().getMu(),
                mySM.getQuarks(QCD::STRANGE).getMass_scale(),
                mySM.getQuarks(QCD::STRANGE).getMass(), FULLNNLO);
    double Md = mySM.Mrun(mySM.getBKd1().getMu(),
                mySM.getQuarks(QCD::DOWN).getMass_scale(),
                mySM.getQuarks(QCD::DOWN).getMass(), FULLNNLO);
    
    double X = sqrt(1.5)*FP*(MK*MK-MP*MP);
    double KK = FP/(FK-FP);
    double Q6b = -4.*sqrt(1.5)*(MK*MK/(Ms+Md))*(MK*MK/(Ms+Md))*FP/KK;
    
    me1(0) *= -1./9.*X;
    me1(1) *= 5./9.*X;
    me1(2) *= 1./3.*X;
    me1(3) = me1(2)+me1(1)-me1(0);
    me1(4) *= Q6b/3.;
    me1(5) *= Q6b;
    me1(6) *= -(1./6.*Q6b*(KK+1)-0.5*X);
    me1(7) *= -(0.5*Q6b*(KK+1)-1./6.*X);
    me1(8) = 1.5*me1(0)-0.5*me1(2);
    me1(9) = me1(1)+0.5*me1(0)-0.5*me1(2);
    me1(10) *= 0.;
    me1(11) *= 0.;

    switch(order) {
        case NLO:
           return((*(allcoeff[LO]) + *(allcoeff[NLO])) * me1);
        case LO:
            return((*(allcoeff[LO])) * me1);
        default:
            std::stringstream out;
            out << order;
            throw std::runtime_error("AmpDK1::AmpDK(): order " + out.str() + "not implemented");
    }
}