Changeset 760


Ignore:
Timestamp:
Oct 27, 2010 9:42:29 AM (12 years ago)
Author:
srkline
Message:

rearranging variable declarations so that VC8 is happy.

Location:
sans/XOP_Dev/SANSAnalysis/lib
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • sans/XOP_Dev/SANSAnalysis/lib/2Y_OneYukawa.c

    r756 r760  
    5252double Y_hq( double q, double Z, double K, double v ) 
    5353{ 
     54        double t1, t2, t3, t4; 
     55 
    5456        if ( q == 0)  
    5557        { 
     
    5860        else  
    5961        { 
    60                 double t1, t2, t3, t4; 
    6162                 
    6263                t1 = ( 1 - v / ( 2 * K * Z * exp( Z ) ) ) * ( ( 1 - cos( q ) ) / ( q*q ) - 1 / ( Z*Z + q*q ) ); 
     
    7879        double b0 = -12 * phi *( pow( a + b,2 ) / 2 + a * c * exp( -Z ) ); 
    7980         
    80         double t1, t2, t3; 
     81        double t1, t2, t3, t4; 
    8182         
    8283        if ( q == 0 )  
     
    9293                t3 = a0 * phi * ( ( q*q - 6 ) * 4 * q * sin( q ) - ( pow( q, 4 ) - 12 * q*q + 24) * cos( q ) + 24 ) / ( 2 * pow( q, 6 ) ); 
    9394        } 
    94         double t4 = Y_hq( q, Z, K, v ); 
     95        t4 = Y_hq( q, Z, K, v ); 
    9596        return -24 * phi * ( t1 + t2 + t3 + t4 ); 
    9697} 
     
    185186        double zeta = 24*phi*pow(-6*phi*Z*cosh(Z/2.) + (12*phi + (-1 + phi)*pow(Z,2))*sinh(Z/2.),2);     
    186187        double A[5]; 
     188        int degree,i,j,n_roots; 
     189        double x,y; 
     190        int n,selected_root; 
     191        double qmax,q,dq,min,sum,dr; 
     192        double *sq,*gr; 
     193         
    187194         
    188195        A[0] = -(exp(3*Z)*pow(K,2)*pow(-1 + phi,2)*pow(Z,3) / zeta ); 
     
    193200                                                        6*(-1 + phi)*phi*pow(Z,2) + pow(-1 + phi,2)*pow(Z,3))/zeta; 
    194201        A[4] = -36*exp(-Z)*pow(-1 + phi,2)*pow(phi,2)*pow(Z,3)/zeta; 
    195          
     202/*       
    196203        if ( debug ) 
    197204        { 
     
    201208                XOPNotice(buf); 
    202209        } 
    203          
     210*/       
    204211        //integer degree of polynomial 
    205         int degree = 4; 
     212        degree = 4; 
    206213         
    207214        // vector of real and imaginary coefficients in order of decreasing powers 
    208         int i; 
    209215        for ( i = 0; i <= degree; i++ ) 
    210216        { 
     
    217223         
    218224        // show the result if in debug mode 
    219         double x, y; 
     225/* 
    220226        if ( debug ) 
    221227        { 
     
    230236                XOPNotice(buf); 
    231237        } 
     238 */ 
    232239        // determine the set of solutions for a,b,c,d, 
    233         int j = 0; 
     240        j = 0; 
    234241        for ( i = 0; i < degree; i++ )  
    235242        { 
     
    249256 
    250257        // number  remaining roots  
    251         int n_roots = j; 
     258        n_roots = j; 
    252259         
    253260//      sprintf(buf, "inside Y_solveEquations OK, before malloc: n_roots = %d\r",n_roots); 
     
    256263        // if there is still more than one root left, than choose the one with the minimum 
    257264        // average value inside the hardcore 
     265         
     266         
     267         
    258268        if ( n_roots > 1 ) 
    259269        { 
    260270                // the number of q values should be a power of 2 
    261271                // in order to speed up the FFT 
    262                 int n = 1 << 14;                //= 16384 
     272                n = 1 << 14;            //= 16384 
    263273                 
    264274                // the maximum q value should be large enough  
    265275                // to enable a reasoble approximation of g(r) 
    266                 double qmax = 1000.; 
    267                 double q, dq = qmax / ( n - 1 ); 
    268                  
    269                 // step size for g(r) 
    270                 double dr; 
     276                qmax = 1000.; 
     277                dq = qmax / ( n - 1 ); 
     278                 
     279                // step size for g(r) = dr 
    271280                 
    272281                // allocate memory for pair correlation function g(r) 
    273282                // and structure factor S(q) 
    274                 double* sq = malloc( sizeof( double ) * n ); 
    275                 double* gr = malloc( sizeof( double ) * n ); 
     283                // (note that sq and gr are pointers) 
     284                sq = malloc( sizeof( double ) * n ); 
     285                gr = malloc( sizeof( double ) * n ); 
    276286                 
    277287                // loop over all remaining roots 
    278                 double min = INFINITY; 
    279                 int selected_root=0;     
     288                min = INFINITY; 
     289                selected_root=0;         
    280290                 
    281291//              sprintf(buf, "after malloc: n,dq = %d  %g\r",n,dq); 
     
    289299                                q = dq * i; 
    290300                                sq[i] = SqOneYukawa( q, Z, K, phi, sol_a[j], sol_b[j], sol_c[j], sol_d[j] ); 
    291                                  
     301/*                               
    292302                                if(i<20 && debug) { 
    293303                                        sprintf(buf, "after SqOneYukawa: s(q) = %g\r",sq[i] ); 
    294304                                        XOPNotice(buf);  
    295305                                } 
     306 */ 
    296307                        } 
    297308                                                 
     
    306317                        // determine sum inside the hardcore  
    307318                        // 0 =< r < 1 of the pair-correlation function 
    308                         double sum = 0; 
     319                        sum = 0; 
    309320                        for (i = 0; i < floor( 1. / dr ); i++ )  
    310321                        { 
    311322                                sum += fabs( gr[i] ); 
    312                                  
     323/*                               
    313324                                if(i<20 && debug) { 
    314325                                        sprintf(buf, "g(r) in core = %g\r",fabs(gr[i])); 
    315326                                        XOPNotice(buf); 
    316327                                } 
     328 */ 
    317329                        } 
    318330                         
  • sans/XOP_Dev/SANSAnalysis/lib/2Y_PairCorrelation.c

    r756 r760  
    112112{ 
    113113        double* data = malloc( sizeof(double) * N * 2); 
    114         int n; 
     114        int n,error,k; 
     115        double alpha,real,imag; 
     116         
    115117        for ( n = 0; n < N; n++ ) { 
    116118                data[2*n] = n * ( Sq[n] - 1 ); 
     
    121123        // data[k] -> sum( data[n] * exp(-2*pi*i*n*k/N), {n, 0, N-1 }) 
    122124        //      int error  = gsl_fft_real_radix2_transform( data, stride, N ); 
    123         int error  = 1; 
     125        error  = 1; 
    124126        dfour1( data-1, N, 1 );         //N is the number of complex points 
    125127         
     
    129131        if ( error == 1 )  
    130132        { 
    131                 double alpha = N * pow( dq, 3 ) / ( 24 * M_PI * M_PI * phi ); 
     133                alpha = N * pow( dq, 3 ) / ( 24 * M_PI * M_PI * phi ); 
    132134                 
    133135                *dr = 2 * M_PI / ( N * dq );   
    134                 int k; 
    135                 double real, imag; 
    136136                for ( k = 0; k < N; k++ ) 
    137137                { 
  • sans/XOP_Dev/SANSAnalysis/lib/2Y_TwoYukawa.c

    r756 r760  
    8484double TY_hq( double q, double Z, double K, double v ) 
    8585{ 
     86        double t1, t2, t3, t4; 
     87 
    8688        if ( q == 0)  
    8789        { 
     
    9092        else  
    9193        { 
    92                 double t1, t2, t3, t4; 
    9394                 
    9495                t1 = ( 1 - v / ( 2 * K * Z * exp( Z ) ) ) * ( ( 1 - cos( q ) ) / ( q*q ) - 1 / ( Z*Z + q*q ) ); 
     
    111112        double b0 = -12 * phi *( pow( a + b,2 ) / 2 + a * ( c1 * exp( -Z1 ) + c2 * exp( -Z2 ) ) ); 
    112113         
    113         double t1, t2, t3; 
     114        double t1, t2, t3,t4; 
    114115         
    115116        if ( q == 0 )  
     
    125126                t3 = a0 * phi * ( ( q*q - 6 ) * 4 * q * sin( q ) - ( pow( q, 4 ) - 12 * q*q + 24) * cos( q ) + 24 ) / ( 2 * pow( q, 6 ) ); 
    126127        } 
    127         double t4 = TY_hq( q, Z1, K1, v1 ) + TY_hq( q, Z2, K2, v2 ); 
     128        t4 = TY_hq( q, Z1, K1, v1 ) + TY_hq( q, Z2, K2, v2 ); 
    128129        return -24 * phi * ( t1 + t2 + t3 + t4 ); 
    129130} 
     
    237238                  (m33*(3*m41 + 4*m11*m41 - 3*m11*m42) + (-3*m31 - 4*m11*m31 + 3*m11*m32)*m43) + 3*m23*(-3*m34*m41 - 4*m11*m34*m41 +  
    238239                  3*m11*m34*m42 + 3*m31*m44 + 4*m11*m31*m44 - 3*m11*m32*m44) - (m34*m43 - m33*m44)*pow(3 - 2*m11,2))/9.; 
    239          
     240/*       
    240241        if( debug )  
    241242        { 
     
    245246                XOPNotice(buf); 
    246247        } 
     248*/ 
    247249         
    248250        /* Matrix representation of the determinant of the of the system where row refering to  
     
    272274                   2*m11*(-3*(m14*m43 - m13*m44)*(Z1 + Z2)*pow(Z1,2) + 2*m34*(m43*(-3 + Z1)*(Z1 + Z2) - 3*m13*Z2*pow(Z1,2)) +  
    273275                  m33*(-2*m44*(-3 + Z1)*(Z1 + Z2) + 6*m14*Z2*pow(Z1,2)))))*pow(Z1 + Z2,-1); 
    274                  
     276/*               
    275277        if( debug )  
    276278        { 
     
    283285                XOPNotice(buf); 
    284286        } 
     287*/ 
    285288         
    286289        /* Matrix representation of the determinant of the of the system where row refering to  
     
    309312                   m11*Z1*(2*m34*m43*(8 - 3*Z1) + 2*m33*m44*(-8 + 3*Z1) + (8*m14*m43 - 3*m24*m43 - 8*m13*m44 + 3*m23*m44)*pow(Z1,2)))* 
    310313                   pow(Z1 + Z2,-1) + 6*(-(m14*(m23*m31 + m33)) + m13*(m24*m31 + m34))*pow(Z1,3)*pow(Z1 + Z2,-1)); 
    311                  
     314/*               
    312315        if( debug )  
    313316        { 
     
    320323                XOPNotice(buf); 
    321324        } 
     325*/ 
    322326         
    323327        /* Matrix representation of the determinant of the of the system where row refering to  
     
    348352                        Z2*(4*(3*m31 - 2*m32)*m44 + Z1*(-4*m31*m44 + 3*m32*m44 - 2*(m14*(-6*m31 + 4*m32 + 3*m41 - 2*m42) + m44)*Z1) +  
    349353                        m34*(m42*(8 - 3*Z1) + 4*m41*(-3 + Z1) + 4*pow(Z1,2)))))*pow(Z1 + Z2,-1))/3.; 
    350                  
     354/*               
    351355        if( debug )  
    352356        { 
     
    359363                XOPNotice(buf); 
    360364        } 
     365 */ 
    361366        /* Matrix representation of the determinant of the of the system where row refering to  
    362367         the variable c1 is replaced by solution vector */ 
     
    387392                        Z2*(4*(3*m31 - 2*m32)*m43 + Z1*(-4*m31*m43 + 3*m32*m43 - 2*(m13*(-6*m31 + 4*m32 + 3*m41 - 2*m42) + m43)*Z1) +  
    388393                        m33*(m42*(8 - 3*Z1) + 4*m41*(-3 + Z1) + 4*pow(Z1,2)))))*pow(Z1 + Z2,-1))/3.; 
    389                  
     394/*               
    390395        if( debug )  
    391396        { 
     
    398403                XOPNotice(buf); 
    399404        }        
     405*/ 
    400406         
    401407        /* coefficient matrices of nonlinear equation 1 */ 
     
    489495        TY_A43 /= norm_A; 
    490496        TY_A52 /= norm_A;*/ 
    491          
     497/*       
    492498        if( debug )  
    493499        { 
     
    505511                XOPNotice(buf); 
    506512        } 
     513 */ 
     514         
    507515        /* coefficient matrices of nonlinear equation 2 */ 
    508516         
     
    597605        TY_B32 /= norm_B; 
    598606        TY_B34 /= norm_B; */ 
    599          
     607/*       
    600608        if( debug )  
    601609        { 
     
    609617                XOPNotice(buf); 
    610618        } 
     619*/ 
    611620         
    612621        /* decrease order of nonlinear equation 1 by means of equation 2 */ 
     
    631640        TY_F39 = 2*TY_A52*TY_B24*TY_B25 - TY_A43*TY_B24*TY_B34 - TY_A42*TY_B25*TY_B34; 
    632641        TY_F310 = -(TY_A43*TY_B25*TY_B34) + TY_A52*pow(TY_B25,2); 
    633          
     642 
     643/* 
    634644        if( debug )  
    635645        { 
     
    643653                XOPNotice(buf); 
    644654        } 
    645          
     655*/ 
     656  
    646657        TY_G13  = -(TY_B12*TY_F32); 
    647658        TY_G14  = -(TY_B12*TY_F33); 
     
    668679        TY_G213 = -(TY_B24*TY_F310) - TY_B25*TY_F39; 
    669680        TY_G214 = -(TY_B25*TY_F310); 
    670          
     681/*       
    671682        if( debug )  
    672683        { 
     
    678689                XOPNotice(buf); 
    679690        } 
    680          
     691*/       
    681692        // coefficients for polynomial 
    682693        TY_w[0] = (-(TY_A21*TY_B12) + TY_A12*TY_B21)*(TY_A52*TY_B21 - TY_A41*TY_B32)*pow(TY_B21,2)*pow(TY_B32,3); 
     
    828839         
    829840        TY_w[22] = (-(TY_A23*TY_B14) + TY_A12*TY_B25)*(TY_A52*TY_B25 - TY_A43*TY_B34)*pow(TY_B25,2)*pow(TY_B34,3); 
    830          
     841/*       
    831842        if( debug )  
    832843        { 
     
    841852                XOPNotice(buf); 
    842853        } 
     854 */ 
    843855} 
    844856 
     
    890902                                       int debug ) 
    891903{ 
    892         // reduce system to a polynomial from which all solution are extracted 
    893         // by doing that a lot of global background variables are set 
    894         TY_ReduceNonlinearSystem( Z1, Z2, K1, K2, phi, debug ); 
    895904         
    896905        // the two coupled non-linear eqautions were reduced to a 
     
    907916        //integer degree of polynomial 
    908917        int degree = 22; 
     918        int i; 
     919        double x,y; 
     920        double var_a, var_b, var_c1, var_c2, var_d1, var_d2; 
     921        double sol_a[22], sol_b[22], sol_c1[22], sol_c2[22], sol_d1[22], sol_d2[22]; 
     922         
     923        int j = 0; 
     924         
     925        int n_roots,n,selected_root; 
     926        double dr,qmax,q,dq,min,sum; 
     927        double *sq,*gr; 
     928         
     929         
     930        // reduce system to a polynomial from which all solution are extracted 
     931        // by doing that a lot of global background variables are set 
     932        TY_ReduceNonlinearSystem( Z1, Z2, K1, K2, phi, debug ); 
    909933         
    910934        // vector of real and imaginary coefficients in order of decreasing powers 
    911         int i; 
    912935        for ( i = 0; i <= degree; i++ ) 
    913936        { 
     
    921944         
    922945        // show the result if in debug mode 
    923         double x, y; 
     946/*       
    924947        if ( debug ) 
    925948        { 
     
    937960                XOPNotice(buf); 
    938961        } 
     962 */ 
    939963         
    940964        // select real roots and those satisfying Q(x) != 0 and W(x) != 0 
     
    947971        //     and g(r) of the correct root should have the minimum average value  
    948972        //         inside the hardcore   
    949         double var_a, var_b, var_c1, var_c2, var_d1, var_d2; 
    950         double sol_a[22], sol_b[22], sol_c1[22], sol_c2[22], sol_d1[22], sol_d2[22]; 
    951          
    952         int j = 0; 
     973 
    953974        for ( i = 0; i < degree; i++ ) 
    954975        { 
     
    976997                                sol_d1[j] = var_d1; 
    977998                                sol_d2[j] = var_d2; 
    978                                  
     999/*                               
    9791000                                if ( debug ) 
    9801001                                { 
     
    9911012                                        XOPNotice(buf); 
    9921013                                } 
     1014 */ 
    9931015                                j++; 
    9941016                        } 
     
    9961018        } 
    9971019        // number  remaining roots  
    998         int n_roots = j; 
     1020        n_roots = j; 
     1021         
    9991022         
    10001023        // if there is still more than one root left, than choose the one with the minimum 
     
    10041027                // the number of q values should be a power of 2 
    10051028                // in order to speed up the FFT 
    1006                 int n = 1 << 14; 
     1029                n = 1 << 14; 
    10071030                 
    10081031                // the maximum q value should be large enough  
    10091032                // to enable a reasoble approximation of g(r) 
    1010                 double qmax = 16 * 10 * 2 * M_PI; 
    1011                 double q, dq = qmax / ( n - 1 ); 
     1033                qmax = 16 * 10 * 2 * M_PI; 
     1034                dq = qmax / ( n - 1 ); 
    10121035                 
    1013                 // step size for g(r) 
    1014                 double dr; 
     1036                // step size for g(r) = dr 
    10151037                 
    10161038                // allocate memory for pair correlation function g(r) 
    10171039                // and structure factor S(q) 
    1018                 double* sq = malloc( sizeof( double ) * n ); 
    1019                 double* gr = malloc( sizeof( double ) * n ); 
     1040                sq = malloc( sizeof( double ) * n ); 
     1041                gr = malloc( sizeof( double ) * n ); 
    10201042                 
    10211043                // loop over all remaining roots 
    1022                 double min = INFINITY; 
    1023                 int selected_root = 10;  
    1024                 double sum = 0; 
     1044                min = INFINITY; 
     1045                selected_root = 10;      
     1046                sum = 0; 
    10251047                for ( j = 0; j < n_roots; j++)  
    10261048                { 
     
    10301052                                q = dq * i; 
    10311053                                sq[i] = SqTwoYukawa( q, Z1, Z2, K1, K2, phi, sol_a[j], sol_b[j], sol_c1[j], sol_c2[j], sol_d1[j], sol_d2[j] ); 
    1032                                  
     1054/*                               
    10331055                                if(i<20 && debug) { 
    10341056                                        sprintf(buf, "after SqTwoYukawa: s(q) = %g\r",sq[i] ); 
    10351057                                        XOPNotice(buf);  
    10361058                                } 
     1059 */ 
    10371060                        } 
    10381061                         
     
    10461069                        for (i = 0; i < floor( 1. / dr ); i++ )  { 
    10471070                                sum += fabs( gr[i] ); 
    1048                                  
     1071/*                               
    10491072                                if(i<20 && debug) { 
    10501073                                        sprintf(buf, "g(r) in core = %g\r",fabs(gr[i])); 
    10511074                                        XOPNotice(buf); 
    10521075                                } 
    1053                                  
     1076*/                               
    10541077                        } 
    10551078 
Note: See TracChangeset for help on using the changeset viewer.