Ignore:
Timestamp:
Jan 31, 2012 12:13:39 PM (11 years ago)
Author:
srkline
Message:

Changes to the XOP code to upgrade to ToolKit? v6. Changes are the ones outlined in the Appendix A of the TK6 manual. SOme of the XOP support routines and the #pragma for 2-byte structures have changed. Per Howard Rodstein, there is no need to change the c files to cpp. c should work and compile just fine.

These changes work correctly on my mac. Next is to make sure that they work correctly on the two build machines.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • sans/XOP_Dev/SANSAnalysis/XOP/TwoPhase.c

    r452 r834  
    2626        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    2727                case NT_FP32: 
    28                         fp= WaveData(p->waveHandle); 
     28                        fp= (float*)WaveData(p->waveHandle); 
    2929            SetNaN64(&p->result); 
    3030                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
    3131                case NT_FP64: 
    32                         dp= WaveData(p->waveHandle); 
     32                        dp= (double*)WaveData(p->waveHandle); 
    3333                        p->result = TeubnerStreyModel(dp,q);                                                                                                                             
    3434                        return 0; 
     
    5757        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    5858                case NT_FP32: 
    59                         fp= WaveData(p->waveHandle); 
    60                         SetNaN64(&p->result); 
    61                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
    62                 case NT_FP64: 
    63                         dp= WaveData(p->waveHandle); 
     59                        fp= (float*)WaveData(p->waveHandle); 
     60                        SetNaN64(&p->result); 
     61                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
     62                case NT_FP64: 
     63                        dp= (double*)WaveData(p->waveHandle); 
    6464                        p->result = Power_Law_Model(dp,q); 
    6565                        return 0; 
     
    8989        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    9090                case NT_FP32: 
    91                         fp= WaveData(p->waveHandle); 
    92                         SetNaN64(&p->result); 
    93                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
    94                 case NT_FP64: 
    95                         dp= WaveData(p->waveHandle); 
     91                        fp= (float*)WaveData(p->waveHandle); 
     92                        SetNaN64(&p->result); 
     93                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
     94                case NT_FP64: 
     95                        dp= (double*)WaveData(p->waveHandle); 
    9696                        p->result = Peak_Lorentz_Model(dp,q); 
    9797                        return 0; 
     
    120120        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    121121                case NT_FP32: 
    122                         fp= WaveData(p->waveHandle); 
    123                         SetNaN64(&p->result); 
    124                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
    125                 case NT_FP64: 
    126                         dp= WaveData(p->waveHandle); 
     122                        fp= (float*)WaveData(p->waveHandle); 
     123                        SetNaN64(&p->result); 
     124                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
     125                case NT_FP64: 
     126                        dp= (double*)WaveData(p->waveHandle); 
    127127                        p->result = Peak_Gauss_Model(dp,q); 
    128128                        return 0; 
     
    151151        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    152152                case NT_FP32: 
    153                         fp= WaveData(p->waveHandle); 
     153                        fp= (float*)WaveData(p->waveHandle); 
    154154                        SetNaN64(&p->result); 
    155155                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
    156156                case NT_FP64: 
    157                         dp= WaveData(p->waveHandle); 
     157                        dp= (double*)WaveData(p->waveHandle); 
    158158                        p->result=Lorentz_Model(dp,q); 
    159159                        return 0; 
     
    182182        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    183183                case NT_FP32: 
    184                         fp= WaveData(p->waveHandle);            
    185                         SetNaN64(&p->result); 
    186                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
    187                 case NT_FP64: 
    188                         dp= WaveData(p->waveHandle); 
     184                        fp= (float*)WaveData(p->waveHandle);            
     185                        SetNaN64(&p->result); 
     186                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
     187                case NT_FP64: 
     188                        dp= (double*)WaveData(p->waveHandle); 
    189189            p->result = Fractal(dp,q); 
    190190                        return 0; 
     
    213213        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    214214                case NT_FP32: 
    215                         fp= WaveData(p->waveHandle); 
    216                         SetNaN64(&p->result); 
    217                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
    218                 case NT_FP64: 
    219                         dp= WaveData(p->waveHandle); 
     215                        fp= (float*)WaveData(p->waveHandle); 
     216                        SetNaN64(&p->result); 
     217                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
     218                case NT_FP64: 
     219                        dp= (double*)WaveData(p->waveHandle); 
    220220                        p->result = DAB_Model(dp,q); 
    221221                        return 0; 
     
    246246        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    247247                case NT_FP32: 
    248                         fp= WaveData(p->waveHandle); 
    249                         SetNaN64(&p->result); 
    250                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
    251                 case NT_FP64: 
    252                         dp= WaveData(p->waveHandle); 
     248                        fp= (float*)WaveData(p->waveHandle); 
     249                        SetNaN64(&p->result); 
     250                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
     251                case NT_FP64: 
     252                        dp= (double*)WaveData(p->waveHandle); 
    253253                        p-> result = OneLevel(dp,q); 
    254254                        return 0; 
     
    279279        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    280280                case NT_FP32: 
    281                         fp= WaveData(p->waveHandle); 
    282                         SetNaN64(&p->result); 
    283                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
    284                 case NT_FP64: 
    285                         dp= WaveData(p->waveHandle); 
     281                        fp= (float*)WaveData(p->waveHandle); 
     282                        SetNaN64(&p->result); 
     283                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
     284                case NT_FP64: 
     285                        dp= (double*)WaveData(p->waveHandle); 
    286286                        p->result = TwoLevel(dp, q); 
    287287                        return 0; 
     
    312312        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    313313                case NT_FP32: 
    314                         fp= WaveData(p->waveHandle); 
    315                         SetNaN64(&p->result); 
    316                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
    317                 case NT_FP64: 
    318                         dp= WaveData(p->waveHandle); 
     314                        fp= (float*)WaveData(p->waveHandle); 
     315                        SetNaN64(&p->result); 
     316                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
     317                case NT_FP64: 
     318                        dp= (double*)WaveData(p->waveHandle); 
    319319                        p->result = ThreeLevel(dp, q); 
    320320                        return 0; 
     
    345345        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    346346                case NT_FP32: 
    347                         fp= WaveData(p->waveHandle); 
    348                         SetNaN64(&p->result); 
    349                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    350                 case NT_FP64: 
    351                         dp= WaveData(p->waveHandle); 
     347                        fp= (float*)WaveData(p->waveHandle); 
     348                        SetNaN64(&p->result); 
     349                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     350                case NT_FP64: 
     351                        dp= (double*)WaveData(p->waveHandle); 
    352352                        p->result = FourLevel(dp,q); 
    353353                        return 0; 
     
    376376        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    377377                case NT_FP32: 
    378                         fp= WaveData(p->waveHandle); 
    379                         SetNaN64(&p->result); 
    380                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    381                 case NT_FP64: 
    382                         dp= WaveData(p->waveHandle); 
     378                        fp= (float*)WaveData(p->waveHandle); 
     379                        SetNaN64(&p->result); 
     380                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     381                case NT_FP64: 
     382                        dp= (double*)WaveData(p->waveHandle); 
    383383                        p->result = BroadPeak(dp,q); 
    384384                        return 0; 
     
    407407        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    408408                case NT_FP32: 
    409                         fp= WaveData(p->waveHandle); 
    410                         SetNaN64(&p->result); 
    411                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    412                 case NT_FP64: 
    413                         dp= WaveData(p->waveHandle); 
     409                        fp= (float*)WaveData(p->waveHandle); 
     410                        SetNaN64(&p->result); 
     411                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     412                case NT_FP64: 
     413                        dp= (double*)WaveData(p->waveHandle); 
    414414                        p->result = CorrLength(dp,q); 
    415415                        return 0; 
     
    438438        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    439439                case NT_FP32: 
    440                         fp= WaveData(p->waveHandle); 
    441                         SetNaN64(&p->result); 
    442                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    443                 case NT_FP64: 
    444                         dp= WaveData(p->waveHandle); 
     440                        fp= (float*)WaveData(p->waveHandle); 
     441                        SetNaN64(&p->result); 
     442                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     443                case NT_FP64: 
     444                        dp= (double*)WaveData(p->waveHandle); 
    445445                        p->result = TwoLorentzian(dp,q); 
    446446                        return 0; 
     
    469469        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    470470                case NT_FP32: 
    471                         fp= WaveData(p->waveHandle); 
    472                         SetNaN64(&p->result); 
    473                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    474                 case NT_FP64: 
    475                         dp= WaveData(p->waveHandle); 
     471                        fp= (float*)WaveData(p->waveHandle); 
     472                        SetNaN64(&p->result); 
     473                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     474                case NT_FP64: 
     475                        dp= (double*)WaveData(p->waveHandle); 
    476476                        p->result = TwoPowerLaw(dp,q); 
    477477                        return 0; 
     
    500500        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    501501                case NT_FP32: 
    502                         fp= WaveData(p->waveHandle); 
    503                         SetNaN64(&p->result); 
    504                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    505                 case NT_FP64: 
    506                         dp= WaveData(p->waveHandle); 
     502                        fp= (float*)WaveData(p->waveHandle); 
     503                        SetNaN64(&p->result); 
     504                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     505                case NT_FP64: 
     506                        dp= (double*)WaveData(p->waveHandle); 
    507507                        p->result = PolyGaussCoil(dp,q); 
    508508                        return 0; 
     
    531531        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    532532                case NT_FP32: 
    533                         fp= WaveData(p->waveHandle); 
    534                         SetNaN64(&p->result); 
    535                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    536                 case NT_FP64: 
    537                         dp= WaveData(p->waveHandle); 
     533                        fp= (float*)WaveData(p->waveHandle); 
     534                        SetNaN64(&p->result); 
     535                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     536                case NT_FP64: 
     537                        dp= (double*)WaveData(p->waveHandle); 
    538538                        p->result = GaussLorentzGel(dp,q); 
    539539                        return 0; 
     
    562562        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    563563                case NT_FP32: 
    564                         fp= WaveData(p->waveHandle); 
    565                         SetNaN64(&p->result); 
    566                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    567                 case NT_FP64: 
    568                         dp= WaveData(p->waveHandle); 
     564                        fp= (float*)WaveData(p->waveHandle); 
     565                        SetNaN64(&p->result); 
     566                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     567                case NT_FP64: 
     568                        dp= (double*)WaveData(p->waveHandle); 
    569569                        p->result = GaussianShell(dp,q); 
    570570                        return 0; 
Note: See TracChangeset for help on using the changeset viewer.