Changeset 235


Ignore:
Timestamp:
Jan 11, 2008 5:05:14 PM (13 years ago)
Author:
srkline
Message:

Changes to XOP library functions to convert models to take individual SLD's rather than contrast.

Individual SLD's are easier to work with - since they are experimental values, contrast is not.

This, unfortunately, means that what Mathieu has done may need to be tweaked, since our library has been tweaked.

Location:
sans/Analysis/branches/ajj_23APR07/XOPs/SANSAnalysis
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • sans/Analysis/branches/ajj_23APR07/XOPs/SANSAnalysis/XOP/Func2D.c

    r231 r235  
    2727        double q, phi; 
    2828        double pars[11]; 
    29         int i; 
     29//      int i; 
    3030//      char buf[256]; 
    3131         
     
    5252                        dp= WaveData(p->waveHandle); 
    5353                         
    54                         for(i=0; i<11; i++) { 
    55                                 pars[i] = dp[i]; 
    56                         } 
     54//                      for(i=0; i<11; i++) { 
     55//                              pars[i] = dp[i]; 
     56//                      } 
     57                        pars[0] = dp[0]; 
     58                        pars[1] = dp[1]; 
     59                        pars[2] = dp[2]; 
     60                        pars[3] = dp[3] - dp[4]; 
     61                        pars[4] = dp[5]; 
     62                        pars[5] = dp[6]; 
     63                        pars[6] = dp[7]; 
     64                        pars[7] = dp[8]; 
     65                        pars[8] = dp[9]; 
     66                        pars[9] = dp[10]; 
     67                        pars[10] = dp[11]; 
    5768 
    5869                        p->result = disperse_cylinder_analytical_2D( pars, q, phi );  
     
    288299        double q, phi; 
    289300        double pars[12]; 
    290         int i; 
    291          
    292         if (p->waveHandle == NIL) { 
    293                 SetNaN64(&p->result); 
    294                 return NON_EXISTENT_WAVE; 
    295         } 
    296      
    297         qx = p->qx; 
    298         qy = p->qy; 
    299          
    300         q = hypot(qx,qy); 
    301         phi = atan2(qy,qx); 
    302          
    303         switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    304                 case NT_FP32: 
    305                         fp= WaveData(p->waveHandle); 
    306             SetNaN64(&p->result); 
    307                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
    308                 case NT_FP64: 
    309                         dp= WaveData(p->waveHandle); 
    310                          
    311                         for(i=0; i<12; i++) { 
    312                                 pars[i] = dp[i]; 
    313                         } 
     301//      int i; 
     302         
     303        if (p->waveHandle == NIL) { 
     304                SetNaN64(&p->result); 
     305                return NON_EXISTENT_WAVE; 
     306        } 
     307     
     308        qx = p->qx; 
     309        qy = p->qy; 
     310         
     311        q = hypot(qx,qy); 
     312        phi = atan2(qy,qx); 
     313         
     314        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
     315                case NT_FP32: 
     316                        fp= WaveData(p->waveHandle); 
     317            SetNaN64(&p->result); 
     318                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
     319                case NT_FP64: 
     320                        dp= WaveData(p->waveHandle); 
     321                         
     322//                      for(i=0; i<12; i++) { 
     323//                              pars[i] = dp[i]; 
     324//                      } 
     325                        pars[0] = dp[0]; 
     326                        pars[1] = dp[1]; 
     327                        pars[2] = dp[2]; 
     328                        pars[3] = dp[3] - dp[4]; 
     329                        pars[4] = dp[5]; 
     330                        pars[5] = dp[6]; 
     331                        pars[6] = dp[7]; 
     332                        pars[7] = dp[8]; 
     333                        pars[8] = dp[9]; 
     334                        pars[9] = dp[10]; 
     335                        pars[10] = dp[11]; 
     336                        pars[11] = dp[12]; 
     337 
    314338                        //p->result = 1.0; 
    315339                        p->result = disperse_ellipsoid_analytical_2D( pars, q, phi );  
     
    416440        double q, phi; 
    417441        double pars[14]; 
    418         int i; 
    419          
    420         if (p->waveHandle == NIL) { 
    421                 SetNaN64(&p->result); 
    422                 return NON_EXISTENT_WAVE; 
    423         } 
    424      
    425         qx = p->qx; 
    426         qy = p->qy; 
    427          
    428         q = hypot(qx,qy); 
    429         phi = atan2(qy,qx); 
    430          
    431         switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    432                 case NT_FP32: 
    433                         fp= WaveData(p->waveHandle); 
    434             SetNaN64(&p->result); 
    435                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
    436                 case NT_FP64: 
    437                         dp= WaveData(p->waveHandle); 
    438                          
    439                         for(i=0; i<14; i++) { 
    440                                 pars[i] = dp[i]; 
    441                         } 
     442//      int i; 
     443         
     444        if (p->waveHandle == NIL) { 
     445                SetNaN64(&p->result); 
     446                return NON_EXISTENT_WAVE; 
     447        } 
     448     
     449        qx = p->qx; 
     450        qy = p->qy; 
     451         
     452        q = hypot(qx,qy); 
     453        phi = atan2(qy,qx); 
     454         
     455        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
     456                case NT_FP32: 
     457                        fp= WaveData(p->waveHandle); 
     458            SetNaN64(&p->result); 
     459                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
     460                case NT_FP64: 
     461                        dp= WaveData(p->waveHandle); 
     462                         
     463//                      for(i=0; i<14; i++) { 
     464//                              pars[i] = dp[i]; 
     465//                      } 
     466                        pars[0] = dp[0]; 
     467                        pars[1] = dp[1]; 
     468                        pars[2] = dp[2]; 
     469                        pars[3] = dp[3]; 
     470                        pars[4] = dp[4] - dp[5]; 
     471                        pars[5] = dp[6]; 
     472                        pars[6] = dp[7]; 
     473                        pars[7] = dp[8]; 
     474                        pars[8] = dp[9]; 
     475                        pars[9] = dp[10]; 
     476                        pars[10] = dp[11]; 
     477                        pars[11] = dp[12]; 
     478                        pars[12] = dp[13]; 
     479                        pars[13] = dp[14]; 
     480 
     481                         
    442482                        p->result = disperse_elliptical_cylinder_analytical_2D( pars, q, phi );  
    443483                          
     
    545585        double qy; 
    546586//      double q, phi; 
    547         double pars[4]; 
     587        double pars[5]; 
    548588        int i; 
    549         char buf[256]; 
    550          
    551         if (p->waveHandle == NIL) { 
    552                 SetNaN64(&p->result); 
    553                 return NON_EXISTENT_WAVE; 
    554         } 
    555      
    556         qx = p->qx; 
    557         qy = p->qy; 
    558          
    559         sprintf(buf, "Qx = %g, Qy = %g\r",qx, qy); 
    560         XOPNotice(buf); 
     589//      char buf[256]; 
     590         
     591        if (p->waveHandle == NIL) { 
     592                SetNaN64(&p->result); 
     593                return NON_EXISTENT_WAVE; 
     594        } 
     595     
     596        qx = p->qx; 
     597        qy = p->qy; 
     598         
     599//      sprintf(buf, "Qx = %g, Qy = %g\r",qx, qy); 
     600//      XOPNotice(buf); 
    561601         
    562602 
     
    573613                        dp= WaveData(p->waveHandle); 
    574614                         
    575                         for(i=0; i<4; i++) { 
     615                        for(i=0; i<5; i++) { 
    576616                                pars[i] = dp[i]; 
    577617                        } 
  • sans/Analysis/branches/ajj_23APR07/XOPs/SANSAnalysis/lib/libCylinder.c

    r156 r235  
    2222        int i; 
    2323        double Pi; 
    24         double scale,radius,length,delrho,bkg,halfheight;               //local variables of coefficient wave 
     24        double scale,radius,length,delrho,bkg,halfheight,sldCyl,sldSolv;                //local variables of coefficient wave 
    2525        int nord=76;                    //order of integration 
    2626        double uplim,lolim;             //upper and lower integration limits 
     
    3636        radius = dp[1]; 
    3737        length = dp[2]; 
    38         delrho = dp[3]; 
    39         bkg = dp[4]; 
     38        sldCyl = dp[3]; 
     39        sldSolv = dp[4]; 
     40        bkg = dp[5]; 
     41         
     42        delrho = sldCyl-sldSolv; 
    4043        halfheight = length/2.0; 
    4144        for(i=0;i<nord;i++) { 
     
    7679{ 
    7780        int i,j; 
    78         double Pi; 
     81        double Pi,slde,sld; 
    7982        double scale,ra,nu,length,delrho,bkg;           //local variables of coefficient wave 
    8083        int nord=76;                    //order of integration 
     
    9598        nu = dp[2]; 
    9699        length = dp[3]; 
    97         delrho = dp[4]; 
    98         bkg = dp[5]; 
     100        slde = dp[4]; 
     101        sld = dp[5]; 
     102        delrho = slde - sld; 
     103        bkg = dp[6]; 
     104         
    99105        for(i=0;i<nord;i++) { 
    100106                //setup inner integral over the ellipsoidal cross-section 
     
    150156{ 
    151157        int i,j; 
    152         double Pi; 
     158        double Pi,slde,sld; 
    153159        double scale,ra,nu,length,delrho,bkg;           //local variables of coefficient wave 
    154160        int nordi=76;                   //order of integration 
     
    170176        nu = dp[2]; 
    171177        length = dp[3]; 
    172         delrho = dp[4]; 
    173         bkg = dp[5]; 
     178        slde = dp[4]; 
     179        sld = dp[5]; 
     180        delrho = slde - sld; 
     181        bkg = dp[6]; 
     182         
    174183        for(i=0;i<nordi;i++) { 
    175184                //setup inner integral over the ellipsoidal cross-section 
     
    231240        double va,vb;           //upper and lower integration limits 
    232241        double summ,zi,yyy,answer;                      //running tally of integration 
    233         double summj,vaj,vbj,zij;                       //for the inner integration 
     242        double summj,vaj,vbj,zij,slde,sld;                      //for the inner integration 
    234243         
    235244        Pi = 4.0*atan(1.0); 
     
    245254        bb = dp[2]; 
    246255        cc = dp[3]; 
    247         delrho = dp[4]; 
    248         bkg = dp[5]; 
     256        slde = dp[4]; 
     257        sld = dp[5]; 
     258        delrho = slde - sld; 
     259        bkg = dp[6]; 
    249260        for(i=0;i<nordi;i++) { 
    250261                //setup inner integral over the ellipsoidal cross-section 
     
    301312        double summ,yyy,answer;                 //running tally of integration 
    302313        double summj,vaj,vbj;                   //for the inner integration 
    303         double mu,mudum,arg,sigma,uu,vol; 
     314        double mu,mudum,arg,sigma,uu,vol,sldp,sld; 
    304315         
    305316         
     
    316327        bb = dp[2]; 
    317328        cc = dp[3]; 
    318         delrho = dp[4]; 
    319         bkg = dp[5]; 
     329        sldp = dp[4]; 
     330        sld = dp[5]; 
     331        delrho = sldp - sld; 
     332        bkg = dp[6]; 
    320333         
    321334        mu = q*bb; 
     
    385398        int nord=76;                    //order of integration 
    386399        double va,vb,zi;                //upper and lower integration limits 
    387         double summ,answer,pi;                  //running tally of integration 
     400        double summ,answer,pi,sldc,sld;                 //running tally of integration 
    388401         
    389402        pi = 4.0*atan(1.0); 
     
    397410        rshell = dp[2]; 
    398411        length = dp[3]; 
    399         delrho = dp[4]; 
    400         bkg = dp[5]; 
     412        sldc = dp[4]; 
     413        sld = dp[5]; 
     414        delrho = sldc - sld; 
     415        bkg = dp[6]; 
    401416         
    402417        for(i=0;i<nord;i++) { 
     
    438453        int nord=76;                    //order of integration 
    439454        double va,vb,zi;                //upper and lower integration limits 
    440         double summ,answer,pi;                  //running tally of integration 
     455        double summ,answer,pi,slde,sld;                 //running tally of integration 
    441456         
    442457        pi = 4.0*atan(1.0); 
     
    449464        nua = dp[1]; 
    450465        a = dp[2]; 
    451         delrho = dp[3]; 
    452         bkg = dp[4]; 
     466        slde = dp[3]; 
     467        sld = dp[4]; 
     468        delrho = slde - sld; 
     469        bkg = dp[5]; 
    453470         
    454471        for(i=0;i<nord;i++) { 
     
    485502        double uplim,lolim;             //upper and lower integration limits 
    486503        double summ,zi,yyy,answer,Vpoly;                        //running tally of integration 
    487         double range,zz,Pi; 
     504        double range,zz,Pi,sldc,sld; 
    488505         
    489506        Pi = 4.0*atan(1.0); 
     
    496513        length = dp[2]; 
    497514        pd = dp[3]; 
    498         delrho = dp[4]; 
    499         bkg = dp[5]; 
     515        sldc = dp[4]; 
     516        sld = dp[5]; 
     517        delrho = sldc - sld; 
     518        bkg = dp[6]; 
    500519         
    501520        zz = (1.0/pd)*(1.0/pd) - 1.0; 
     
    543562        double uplim,lolim;             //upper and lower integration limits 
    544563        double summ,zi,yyy,answer,Vpoly;                        //running tally of integration 
    545         double range,zz,Pi; 
     564        double range,zz,Pi,sldc,sld; 
    546565         
    547566         
     
    555574        length = dp[2]; 
    556575        pd = dp[3]; 
    557         delrho = dp[4]; 
    558         bkg = dp[5]; 
     576        sldc = dp[4]; 
     577        sld = dp[5]; 
     578        delrho = sldc - sld; 
     579        bkg = dp[6]; 
    559580         
    560581        zz = (1.0/pd)*(1.0/pd) - 1.0; 
     
    717738        double uplim,lolim;             //upper and lower integration limits 
    718739        double summ,zi,yyy,answer,oblatevol;                    //running tally of integration 
    719         double Pi; 
     740        double Pi,sldc,slds,sld; 
    720741         
    721742        Pi = 4.0*atan(1.0); 
     
    732753        trmaj = dp[3]; 
    733754        trmin = dp[4]; 
    734         delpc = dp[5]; 
    735         delps = dp[6]; 
    736         bkg = dp[7];                         
     755        sldc = dp[5]; 
     756        slds = dp[6]; 
     757        sld = dp[7]; 
     758        delpc = sldc - slds;    //core - shell 
     759        delps = slds - sld;             //shell - solvent 
     760        bkg = dp[8];                         
    737761         
    738762        for(i=0;i<nord;i++) { 
     
    769793        double uplim,lolim;             //upper and lower integration limits 
    770794        double summ,zi,yyy,answer,prolatevol;                   //running tally of integration 
    771         double Pi; 
     795        double Pi,sldc,slds,sld; 
    772796         
    773797        Pi = 4.0*atan(1.0); 
     
    783807        trmaj = dp[3]; 
    784808        trmin = dp[4]; 
    785         delpc = dp[5]; 
    786         delps = dp[6]; 
    787         bkg = dp[7];                         
     809        sldc = dp[5]; 
     810        slds = dp[6]; 
     811        sld = dp[7]; 
     812        delpc = sldc - slds;            //core - shell 
     813        delps = slds - sld;             //shell  - sovent 
     814        bkg = dp[8];                         
    788815         
    789816        for(i=0;i<nord;i++) { 
     
    873900        double scale,del,sig,contr,bkg;         //local variables of coefficient wave 
    874901        double inten, qval,Pq; 
    875         double Pi; 
     902        double Pi,sldb,sld; 
    876903         
    877904         
     
    880907        del = dp[1]; 
    881908        sig = dp[2]*del; 
    882         contr = dp[3]; 
    883         bkg = dp[4]; 
     909        sldb = dp[3]; 
     910        sld = dp[4]; 
     911        contr = sldb - sld; 
     912        bkg = dp[5]; 
    884913        qval=q; 
    885914         
     
    904933{ 
    905934        double scale,dd,del,sig,contr,NN,Cp,bkg;                //local variables of coefficient wave 
    906         double inten, qval,Pq,Sq,alpha,temp,t1,t2,t3,dQ; 
    907         double Pi,Euler,dQDefault,fii; 
     935        double inten,qval,Pq,Sq,alpha,temp,t1,t2,t3,dQ; 
     936        double Pi,Euler,dQDefault,fii,sldb,sld; 
    908937        int ii,NNint; 
     938//      char buf[256]; 
     939 
    909940         
    910941        Euler = 0.5772156649;           // Euler's constant 
     
    919950        del = dp[2]; 
    920951        sig = dp[3]*del; 
    921         contr = dp[4]; 
    922         NN = trunc(dp[5]);              //be sure that NN is an integer 
    923         Cp = dp[6]; 
    924         bkg = dp[7]; 
     952        sldb = dp[4]; 
     953        sld = dp[5]; 
     954        contr = sldb - sld; 
     955        NN = trunc(dp[6]);              //be sure that NN is an integer 
     956        Cp = dp[7]; 
     957        bkg = dp[8]; 
    925958         
    926959        Pq = 2.0*contr*contr/qval/qval*(1.0-cos(qval*del)*exp(-0.5*qval*qval*sig*sig)); 
     960         
     961        NNint = (int)NN;                //cast to an integer for the loop 
     962         
     963//      sprintf(buf, "qval = %g\r", qval); 
     964//      XOPNotice(buf); 
     965         
     966        ii=0; 
     967        Sq = 0.0; 
     968        for(ii=1;ii<(NNint-1);ii+=1) { 
     969         
     970                fii = (double)ii;               //do I really need to do this? 
     971                 
     972                temp = 0.0; 
     973                alpha = Cp/4.0/Pi/Pi*(log(Pi*fii) + Euler); 
     974                t1 = 2.0*dQ*dQ*dd*dd*alpha; 
     975                t2 = 2.0*qval*qval*dd*dd*alpha; 
     976                t3 = dQ*dQ*dd*dd*fii*fii; 
     977                 
     978                temp = 1.0-fii/NN; 
     979                temp *= cos(dd*qval*fii/(1.0+t1)); 
     980                temp *= exp(-1.0*(t2 + t3)/(2.0*(1.0+t1)) ); 
     981                temp /= sqrt(1.0+t1); 
     982                 
     983                Sq += temp; 
     984        } 
     985         
     986        Sq *= 2.0; 
     987        Sq += 1.0; 
     988         
     989        inten = 2.0*Pi*scale*Pq*Sq/(dd*qval*qval); 
     990         
     991        inten *= 1.0e8;         // 1/A to 1/cm 
     992         
     993    return(inten+bkg); 
     994} 
     995 
     996 
     997/*      LamellarPS_HGX  :  calculates the form factor of a lamellar structure - with S(q) effects included 
     998------- 
     999------- resolution effects ARE included, but only a CONSTANT default value, not the real q-dependent resolution!! 
     1000 
     1001        */ 
     1002double 
     1003LamellarPS_HG(double dp[], double q) 
     1004{ 
     1005        double scale,dd,delT,delH,SLD_T,SLD_H,SLD_S,NN,Cp,bkg;          //local variables of coefficient wave 
     1006        double inten,qval,Pq,Sq,alpha,temp,t1,t2,t3,dQ,drh,drt; 
     1007        double Pi,Euler,dQDefault,fii; 
     1008        int ii,NNint; 
     1009         
     1010         
     1011        Euler = 0.5772156649;           // Euler's constant 
     1012        dQDefault = 0.0025;             //[=] 1/A, q-resolution, default value 
     1013        dQ = dQDefault; 
     1014         
     1015        Pi = 4.0*atan(1.0); 
     1016        qval= q; 
     1017         
     1018        scale = dp[0]; 
     1019        dd = dp[1]; 
     1020        delT = dp[2]; 
     1021        delH = dp[3]; 
     1022        SLD_T = dp[4]; 
     1023        SLD_H = dp[5]; 
     1024        SLD_S = dp[6]; 
     1025        NN = trunc(dp[7]);              //be sure that NN is an integer 
     1026        Cp = dp[8]; 
     1027        bkg = dp[9]; 
     1028         
     1029         
     1030        drh = SLD_H - SLD_S; 
     1031        drt = SLD_T - SLD_S;    //correction 13FEB06 by L.Porcar 
     1032         
     1033        Pq = drh*(sin(qval*(delH+delT))-sin(qval*delT)) + drt*sin(qval*delT); 
     1034        Pq *= Pq; 
     1035        Pq *= 4.0/(qval*qval); 
    9271036         
    9281037        NNint = (int)NN;                //cast to an integer for the loop 
     
    9541063        inten *= 1.0e8;         // 1/A to 1/cm 
    9551064         
    956     return(inten+bkg); 
    957 } 
    958  
    959  
    960 /*      LamellarPS_HGX  :  calculates the form factor of a lamellar structure - with S(q) effects included 
    961 ------- 
    962 ------- resolution effects ARE included, but only a CONSTANT default value, not the real q-dependent resolution!! 
    963  
    964         */ 
    965 double 
    966 LamellarPS_HG(double dp[], double q) 
    967 { 
    968         double scale,dd,delT,delH,SLD_T,SLD_H,SLD_S,NN,Cp,bkg;          //local variables of coefficient wave 
    969         double inten,qval,Pq,Sq,alpha,temp,t1,t2,t3,dQ,drh,drt; 
    970         double Pi,Euler,dQDefault,fii; 
    971         int ii,NNint; 
    972          
    973          
    974         Euler = 0.5772156649;           // Euler's constant 
    975         dQDefault = 0.0025;             //[=] 1/A, q-resolution, default value 
    976         dQ = dQDefault; 
    977          
    978         Pi = 4.0*atan(1.0); 
    979         qval= q; 
    980          
    981         scale = dp[0]; 
    982         dd = dp[1]; 
    983         delT = dp[2]; 
    984         delH = dp[3]; 
    985         SLD_T = dp[4]; 
    986         SLD_H = dp[5]; 
    987         SLD_S = dp[6]; 
    988         NN = trunc(dp[7]);              //be sure that NN is an integer 
    989         Cp = dp[8]; 
    990         bkg = dp[9]; 
    991          
    992          
    993         drh = SLD_H - SLD_S; 
    994         drt = SLD_T - SLD_S;    //correction 13FEB06 by L.Porcar 
    995          
    996         Pq = drh*(sin(qval*(delH+delT))-sin(qval*delT)) + drt*sin(qval*delT); 
    997         Pq *= Pq; 
    998         Pq *= 4.0/(qval*qval); 
    999          
    1000         NNint = (int)NN;                //cast to an integer for the loop 
    1001         ii=0; 
    1002         Sq = 0.0; 
    1003         for(ii=1;ii<(NNint-1);ii+=1) { 
    1004          
    1005                 fii = (double)ii;               //do I really need to do this? 
    1006                  
    1007                 temp = 0.0; 
    1008                 alpha = Cp/4.0/Pi/Pi*(log(Pi*ii) + Euler); 
    1009                 t1 = 2.0*dQ*dQ*dd*dd*alpha; 
    1010                 t2 = 2.0*qval*qval*dd*dd*alpha; 
    1011                 t3 = dQ*dQ*dd*dd*ii*ii; 
    1012                  
    1013                 temp = 1.0-ii/NN; 
    1014                 temp *= cos(dd*qval*ii/(1.0+t1)); 
    1015                 temp *= exp(-1.0*(t2 + t3)/(2.0*(1.0+t1)) ); 
    1016                 temp /= sqrt(1.0+t1); 
    1017                  
    1018                 Sq += temp; 
    1019         } 
    1020          
    1021         Sq *= 2.0; 
    1022         Sq += 1.0; 
    1023          
    1024         inten = 2.0*Pi*scale*Pq*Sq/(dd*qval*qval); 
    1025          
    1026         inten *= 1.0e8;         // 1/A to 1/cm 
    1027          
    10281065        return(inten+bkg); 
    10291066} 
     
    10751112FlexExclVolCyl(double dp[], double q) 
    10761113{ 
    1077         double scale,L,B,bkg,rad,qr,cont; 
     1114        double scale,L,B,bkg,rad,qr,cont,sldc,slds; 
    10781115        double Pi,flex,crossSect,answer; 
    10791116         
     
    10851122        B = dp[2]; 
    10861123        rad = dp[3]; 
    1087         cont = dp[4]; 
    1088         bkg = dp[5]; 
     1124        sldc = dp[4]; 
     1125        slds = dp[5]; 
     1126        cont = sldc-slds; 
     1127        bkg = dp[6]; 
    10891128         
    10901129     
     
    11101149FlexCyl_Ellip(double dp[], double q) 
    11111150{ 
    1112         double scale,L,B,bkg,rad,qr,cont,ellRatio; 
     1151        double scale,L,B,bkg,rad,qr,cont,ellRatio,slds,sldc; 
    11131152        double Pi,flex,crossSect,answer; 
    11141153         
     
    11201159        rad = dp[3]; 
    11211160        ellRatio = dp[4]; 
    1122         cont = dp[5]; 
    1123         bkg = dp[6]; 
    1124          
     1161        sldc = dp[5]; 
     1162        slds = dp[6]; 
     1163        bkg = dp[7]; 
     1164         
     1165        cont = sldc - slds; 
    11251166        qr = q*rad; 
    11261167         
     
    11681209{ 
    11691210        int i; 
    1170         double scale,radius,length,pd,delrho,bkg,lb;            //local variables of coefficient wave 
     1211        double scale,radius,length,pd,bkg,lb,delrho,sldc,slds;          //local variables of coefficient wave 
    11711212        int nord=20;                    //order of integration 
    11721213        double uplim,lolim;             //upper and lower integration limits 
     
    11831224        lb = dp[3]; 
    11841225        radius = dp[4]; 
    1185         delrho = dp[5]; 
    1186         bkg = dp[6]; 
    1187          
     1226        sldc = dp[5]; 
     1227        slds = dp[6]; 
     1228        bkg = dp[7]; 
     1229         
     1230        delrho = sldc - slds; 
    11881231        zz = (1.0/pd)*(1.0/pd) - 1.0; 
    11891232         
     
    12281271{ 
    12291272        int i; 
    1230         double scale,radius,length,pd,delrho,bkg,lb;            //local variables of coefficient wave 
     1273        double scale,radius,length,pd,delrho,bkg,lb,sldc,slds;          //local variables of coefficient wave 
    12311274        int nord=76;                    //order of integration 
    12321275        double uplim,lolim;             //upper and lower integration limits 
     
    12451288        radius = dp[3]; 
    12461289        pd = dp[4]; 
    1247         delrho = dp[5]; 
    1248         bkg = dp[6]; 
    1249          
     1290        sldc = dp[5]; 
     1291        slds = dp[6]; 
     1292        bkg = dp[7]; 
     1293         
     1294        delrho = sldc-slds; 
    12501295        zz = (1.0/pd)*(1.0/pd) - 1.0; 
    12511296         
  • sans/Analysis/branches/ajj_23APR07/XOPs/SANSAnalysis/lib/libSphere.c

    r217 r235  
    1313SphereForm(double dp[], double q) 
    1414{ 
    15         double scale,radius,delrho,bkg;         //my local names 
     15        double scale,radius,delrho,bkg,sldSph,sldSolv;          //my local names 
    1616        double bes,f,vol,f2,pi; 
    1717         
     
    1919        scale = dp[0]; 
    2020        radius = dp[1]; 
    21         delrho = dp[2]; 
    22         bkg = dp[3]; 
     21        sldSph = dp[2]; 
     22        sldSolv = dp[3]; 
     23        bkg = dp[4]; 
     24         
     25        delrho = sldSph - sldSolv; 
    2326        //handle q==0 separately 
    2427        if(q==0){ 
     
    217220        double capl,capl1,capmu,capmu1,r3,pq; 
    218221        double ka2,r1,heff; 
    219         double hh,k; 
     222        double hh,k,slds,sld; 
    220223         
    221224        pi = 4.0*atan(1.0); 
     
    225228        z2 = dp[1];             //polydispersity (0<z2<1) 
    226229        phi = dp[2];            // volume fraction (0<phi<1) 
    227         cont = dp[3]*1.0e4;             // contrast (odd units) 
    228         bkg = dp[4]; 
     230        slds = dp[3]; 
     231        sld = dp[4]; 
     232        cont = (slds - sld)*1.0e4;              // contrast (odd units) 
     233        bkg = dp[5]; 
    229234        sigma = 2*rad; 
    230235         
     
    448453        double pi,x; 
    449454        double scale,rad,pd,cont,bkg;           //my local names 
    450         double inten,h1,qw,qr,width,sig,averad3,Rg2; 
     455        double inten,h1,qw,qr,width,sig,averad3,Rg2,slds,sld; 
    451456         
    452457        pi = 4.0*atan(1.0); 
     
    456461        rad = dp[1];            // radius (A) 
    457462        pd = dp[2];             //polydispersity of rectangular distribution 
    458         cont = dp[3];           // contrast (A^-2) 
    459         bkg = dp[4]; 
     463        slds = dp[3]; 
     464        sld = dp[4]; 
     465        cont = slds - sld;              // contrast (A^-2) 
     466        bkg = dp[5]; 
    460467         
    461468        // as usual, poly = sig/ravg 
Note: See TracChangeset for help on using the changeset viewer.