// Descr: evident
TEST(GeometryTest, GetOppositeAtom)
{
    Bond testBond = Bond(1, 3, 5.5, true);
    Angle testAngle = Angle(2, 6, 30, false);
    Dihedral testDihed = Dihedral(3, 7, 180, true);

    //test with bonds
    EXPECT_EQ(3, getOppositeAtom(testBond, 1));
    EXPECT_EQ(1, getOppositeAtom(testBond, 3));
    EXPECT_EQ(-1, getOppositeAtom(testBond, 4));

    EXPECT_EQ(6, getOppositeAtom(testAngle, 2));
    EXPECT_EQ(2, getOppositeAtom(testAngle, 6));
    EXPECT_EQ(-1, getOppositeAtom(testAngle, 5));

    EXPECT_EQ(7, getOppositeAtom(testDihed, 3));
    EXPECT_EQ(3, getOppositeAtom(testDihed, 7));
    EXPECT_EQ(-1, getOppositeAtom(testDihed, 6));

    // Second suite
    testBond = Bond(11, 12, 3.5, true);
    testAngle = Angle(1, 22, 30, false);
    testDihed = Dihedral(5, 9, 180, true);


    EXPECT_EQ(12, getOppositeAtom(testBond, 11));
    EXPECT_EQ(11, getOppositeAtom(testBond, 12));
    EXPECT_EQ(-1, getOppositeAtom(testBond, 13));

    EXPECT_EQ(22, getOppositeAtom(testAngle, 1));
    EXPECT_EQ(1, getOppositeAtom(testAngle, 22));
    EXPECT_EQ(-1, getOppositeAtom(testAngle, 15));

    EXPECT_EQ(9, getOppositeAtom(testDihed, 5));
    EXPECT_EQ(5, getOppositeAtom(testDihed, 9));
    unsigned long inval = (unsigned long) -1;
    EXPECT_EQ(-1, getOppositeAtom(testDihed, inval));
}
Example #2
0
 Group Group::dihedral(int n)   {return Group(Dihedral(n)); }
Example #3
0
int LocalMove(struct s_polymer *p, struct s_polymer *oldp,struct s_polymer *fragment,struct s_potential *pot,int nmul,struct s_mc_parms *parms, double t)
{
    int ok=0,nang=0;
    int iw,ip,iapdbtocheck,i,m;
    double deltaE;
    double detL1,detL2,detA1,detA2,W1,W2,psisquared,e;


    ip=irand(parms->npol);

    iw=(nmul-1)+irand( (p+ip)->nback-nmul+1   );
    //iw=20;


    for(i=0; i<nmul; i++)
    {
        nang+=((((p+ip)->back)+iw-nmul+i)+1)->move;
    }

    deltaE = -GetEnergyMonomerRange(p,iw-nmul+1,iw+1,ip);


    if(iw==((p+ip)->nback-1)) //pivot forward OK
    {


        for(i=0; i<nang; i++)
            (fragment+ip)->d_ang[i]=parms->dw_mpivot*(0.05-frand());
        if (!parms->nodihpot)
            for(i=0; i<nmul+3; i++)
            {
                deltaE-=(((p+ip)->back)+iw-nmul+i+1)->e_dih;
            }
        m=0;
        for(i=0; i<nmul; i++)
        {
            if( (((p+ip)->back)+iw+i-nmul+2)->move==1)
            {
                ok*=PivotForward((p+ip),iw-nmul+i+1,(fragment+ip)->d_ang[m],nmul-i-2,parms);
                m++;
                if(m==nang) break;
            }

        }
        if(!parms->nosidechains)
        {
            ok*=AddSidechain(p,iw-nmul+1,iw+1,ip);
        }

        deltaE += EnergyMonomerRange(p,pot,iw-nmul+1,iw+1,ip,parms->npol,parms->shell,1,parms->nosidechains,parms->disentangle,parms->hb);
        if (!parms->nodihpot)
            for(i=0; i<nmul+3; i++)
            {

                deltaE+=EnergyDihedrals(p,pot,iw-nmul+i+1,ip,1);
            }

        ok*=Metropolis(deltaE,t,p->tables);

        if(ok==0)
        {
            UpdateMonomerRange(oldp,p,iw-nmul+1,iw+1,ip,parms->shell);
        }
        else
        {
            //move accepted

            UpdateMonomerRange(p,oldp,iw-nmul+1,iw+1,ip,parms->shell);
            p->etot+=deltaE;
            parms->acc++;
        }


    } //end of forward





    else if(iw==nmul-1) //pivot backward OK
    {

        for(i=0; i<nang; i++)
            (fragment+ip)->d_ang[i]=parms->dw_mpivot*(0.05-frand());
        if (!parms->nodihpot)
            for(i=0; i<nmul+3; i++)
            {
                deltaE-=(((p+ip)->back)+i)->e_dih;

            }
        m=0;

        for(i=0; i<nmul; i++)
        {
            if( (((p+ip)->back)+iw-i)->move==1)
            {
                ok*=PivotBackward((p+ip),iw-i,(fragment+ip)->d_ang[m],nmul-i-2,parms);
                m++;
                if(m==nang) break;
            }

        }
        if(!parms->nosidechains)
            ok*=AddSidechain(p,0,iw+1,ip);
        deltaE += EnergyMonomerRange(p,pot,0,iw+1,ip,parms->npol,parms->shell,1,parms->nosidechains,parms->disentangle,parms->hb);
        if (!parms->nodihpot)
            for(i=0; i<nmul+3; i++)
            {
                deltaE+=EnergyDihedrals(p,pot,i,ip,1);
            }
        ok*=Metropolis(deltaE,t,p->tables);

        if(ok==0)
        {

            UpdateMonomerRange(oldp,p,0,iw+1,ip,parms->shell);
        }
        else
        {
            UpdateMonomerRange(p,oldp,0,iw+1,ip,parms->shell);

            p->etot+=deltaE;
            parms->acc++;
        }


    } //end of backward



    else if(iw!=((p+ip)->nback-2))//pivot local
    {



        if((((p+ip)->back)+iw+1)->iapdb==0)
            iapdbtocheck=1;
        if((((p+ip)->back)+iw+1)->iapdb==1)
            iapdbtocheck=2;
        if((((p+ip)->back)+iw+1)->iapdb==2)
            iapdbtocheck=0;
        int out;

        Gaussian_Angles((fragment+ip)->g_ang,nang);
        Compute_G(fragment,p,ip,iw-nmul+1,nmul,nang,parms);


        MatA((fragment+ip)->A,(fragment+ip)->G,nang,parms->bgs_a,parms->bgs_b);
        Cholesky_2((fragment+ip)->L,(fragment+ip)->A,nang);
        psisquared=Squared_n_Norma((fragment+ip)->g_ang,nang);
        e=exp(-psisquared);
        detL1=DetTriang((fragment+ip)->L,nang);
        detA1=detL1*detL1;
        W1=e * sqrt(detA1);
        InvertTriang((fragment+ip)->Y,(fragment+ip)->L,nang);
        TransposedMatOnVect((fragment+ip)->Y,(fragment+ip)->g_ang,(fragment+ip)->d_ang,nang);

        if(!parms->nodihpot)
            for(i=0; i<nmul+3; i++)
            {
                deltaE -= (((p+ip)->back)+iw-nmul+i+1)->e_dih;
            }

        if(!parms->noangpot)
        {

            deltaE-=(((p+ip)->back)+iw)->e_ang;
            deltaE-=(((p+ip)->back)+iw+1)->e_ang;
        }


        m=0;


        for(i=0; i<nmul; i++)
        {
            if( (((p+ip)->back)+iw+i-nmul+2)->move==1)
            {
                ok*=PivotForward((p+ip),iw-nmul+i+1,(fragment+ip)->d_ang[m],nmul-i-2,parms);
                m++;
                if(m==nang)
                    break;
            }

        }




        double rc2=parms->r_cloose*parms->r_cloose;
        double dihedral=Dihedral( (((p+ip)->back)+iw-iapdbtocheck)->pos, (((p+ip)->back)+iw+1-iapdbtocheck)->pos, (((p+ip)->back)+iw+2-iapdbtocheck)->pos, (((p+ip)->back)+iw+3-iapdbtocheck)->pos, p->tables, &out );
//		fprintf(stderr,"Checking Dihedral: backbone atoms %d,%d,%d,%d\n",+iw-iapdbtocheck,+iw+1-iapdbtocheck,+iw+2-iapdbtocheck,+iw+3-iapdbtocheck);


        if( DAbs (Dist2( (((p+ip)->back)+iw)->pos,(((p+ip)->back)+iw+1)->pos ) -(((p+ip)->back)+iw)->d2_next < rc2 )  &&   DAbs( Angle( (((p+ip)->back)+iw-1)->pos, (((p+ip)->back)+iw)->pos, (((p+ip)->back)+iw+1)->pos, (p+ip)->tables, &out)  - (((p+ip)->back)+iw-1)->a_next) < 0.05 && DAbs(180-DAbs(dihedral)) < DELTAOMEGA)
        {

            if(!parms->nosidechains)
            {
                ok *= AddSidechain(p,iw-nmul+1,iw+1,ip);
            }

            deltaE += EnergyMonomerRange(p,pot,iw-nmul+1,iw+1,ip,parms->npol,parms->shell,1,parms->nosidechains,parms->disentangle,parms->hb);

            if (!parms->nodihpot)
                for(i=0; i<nmul+3; i++)
                {
                    deltaE+=EnergyDihedrals(p,pot,iw-nmul+i+1,ip,1);
                }

            if(!parms->noangpot)
            {
                //		fprintf(stderr,"\nCOMPUTING ANGLE ENERGY deltaE=%lf\t",deltaE);
                deltaE+=EnergyAngles(p,pot,iw,ip,1);
                deltaE+=EnergyAngles(p,pot,iw+1,ip,1);
                //		fprintf(stderr,"-> %lf\n",deltaE);
            }



            Compute_G(fragment,p,ip,iw-nmul+1,nmul,nang,parms);
            MatA((fragment+ip)->A,(fragment+ip)->G,nang,parms->bgs_a,parms->bgs_b);
            Cholesky_2((fragment+ip)->L,(fragment+ip)->A,nang);
            detL2=DetTriang((fragment+ip)->L,nang);
            detA2=detL2*detL2;
            TransposedMatOnVect((fragment+ip)->L,(fragment+ip)->d_ang,(fragment+ip)->g_ang,nang);
            psisquared=Squared_n_Norma((fragment+ip)->g_ang,nang);
            e=exp(-psisquared);
            W2=e*sqrt(detA2);
            ok*=B_Metropolis(deltaE,t,W2,W1,p->tables);

            if(ok==0) //move rejected
            {
                UpdateMonomerRange(oldp,p,iw-nmul+1,iw+1,ip,parms->shell);
            }
            else	//move accepted
            {

                UpdateMonomerRange(p,oldp,iw-nmul+1,iw+1,ip,parms->shell);

                p->etot+=deltaE;

                parms->acc++;
            }


        }//end of loose condition

        else //if not loose pivot
        {
            ok=0;
            UpdateMonomerRange(oldp,p,iw-nmul+1,iw+1,ip,parms->shell);
        }


    }//end of local pivot


    parms->mov++;

    return ok;

}