Changeset 997 for sans/XOP_Dev


Ignore:
Timestamp:
May 11, 2016 3:39:08 PM (7 years ago)
Author:
srkline
Message:

Updates for Xcode 7, Toolkit 7, and 64-bit version

Location:
sans/XOP_Dev/MonteCarlo
Files:
2 added
8 edited

Legend:

Unmodified
Added
Removed
  • sans/XOP_Dev/MonteCarlo/DebyeSpheres.c

    r834 r997  
    1010 
    1111// Prototypes 
    12 HOST_IMPORT int main(IORecHandle ioRecHandle); 
     12HOST_IMPORT int XOPMain(IORecHandle ioRecHandle); 
    1313 
    1414// Custom error codes 
     
    3434        double ival;                            //output intensity value 
    3535        double *xv,*yv,*zv,*rv;         //pointers to input xyz-rho coordinates 
    36         int i,j; 
    37     int npt; 
     36        CountInt i,j; 
     37    CountInt npt; 
    3838        double rval,grid,vol,fQR,dum,dij; 
    3939 
     
    106106 
    107107// 
    108     npt = (int) WavePoints(p->xwavH);   //wavePoints returns long, number of XYZ points 
     108    npt = (CountInt) WavePoints(p->xwavH);      //wavePoints returns long, number of XYZ points 
    109109        xv = (double*)WaveData(p->xwavH);               //xyz locations 
    110110        yv = (double*)WaveData(p->ywavH); 
     
    170170        double dmax,dij;                                //output dmax value, dij 
    171171        double *xv,*yv,*zv;             //pointers to input xyz coordinates 
    172         int i,j; 
    173     int npt; 
    174         int p1,p2; 
     172        CountInt i,j; 
     173    CountInt npt; 
     174        CountInt p1,p2; 
    175175         
    176176        // check for all of the required waves 
     
    203203         
    204204        // 
    205     npt = (int) WavePoints(p->xwavH);   //wavePoints returns long, number of XYZ points 
     205    npt = (CountInt) WavePoints(p->xwavH);      //wavePoints returns long, number of XYZ points 
    206206        xv = (double*)WaveData(p->xwavH);               //xyz locations 
    207207        yv = (double*)WaveData(p->ywavH); 
    208208        zv = (double*)WaveData(p->zwavH); 
    209209         
    210         p1 = (int) p->p1; 
    211         p2 = (int) p->p2; 
     210        p1 = (CountInt) p->p1; 
     211        p2 = (CountInt) p->p2; 
    212212         
    213213        dmax = 0; 
     
    240240{ 
    241241        double *xv,*yv,*zv,*bv;         //pointers to input xyz coordinates 
    242         int i,j; 
    243     int npt,numBins,binIndex; 
     242        CountInt i,j; 
     243    CountInt npt,numBins,binIndex; 
    244244        double grid,binWidth,val; 
    245         int p1,p2; 
     245        CountInt p1,p2; 
    246246         
    247247         
     
    284284         
    285285        // 
    286     npt = (int) WavePoints(p->xwavH);   //wavePoints returns long, number of XYZ points 
    287     numBins = (int) WavePoints(p->bwavH);       //wavePoints returns long, number of points in bin wave 
    288         p1 = (int) p->p1; 
    289         p2 = (int) p->p2; 
     286    npt = (CountInt) WavePoints(p->xwavH);      //wavePoints returns long, number of XYZ points 
     287    numBins = (CountInt) WavePoints(p->bwavH);  //wavePoints returns long, number of points in bin wave 
     288        p1 = (CountInt) p->p1; 
     289        p2 = (CountInt) p->p2; 
    290290         
    291291         
     
    302302                for(j=(i+1);j<npt;j+=1) { 
    303303                        val = XYZDistance(xv[i],xv[j],yv[i],yv[j],zv[i],zv[j])*grid; 
    304                         binIndex = (int)(val/binWidth-0.5); 
     304                        binIndex = (CountInt)(val/binWidth-0.5); 
    305305                        if(binIndex > numBins -1 ) { 
    306306                                //Print "bad index" 
     
    332332        double *xv,*yv,*zv;             //pointers to input xyz coordinates 
    333333        double *rho,*SLDLook,*PSFid;    // rho and the SLD lookup vector 
    334         int i,j; 
    335     int npt,numBins,binIndex; 
     334        CountInt i,j; 
     335    CountInt npt,numBins,binIndex; 
    336336        double grid,binWidth,val,retVal; 
    337         int p1,p2; 
    338         int intSLD; 
     337        CountInt p1,p2; 
     338        CountInt intSLD; 
    339339 
    340340         
     
    344344//      long dimensionSizes[MAX_DIMENSIONS+1]; 
    345345        double value[2];                                // Pointers used for double data. 
    346         long indices[MAX_DIMENSIONS]; 
     346        IndexInt indices[MAX_DIMENSIONS]; 
    347347//       
    348         long rhoi,rhoj,rii,rji,PSFIndex; 
     348        CountInt rhoi,rhoj,rii,rji,PSFIndex; 
    349349         
    350350         
     
    417417        PSFwavH = p->PSFidH; 
    418418         
    419     npt = (int) WavePoints(p->xwavH);   //wavePoints returns long, number of XYZ points 
    420     numBins = (int) WavePoints(p->bwavH);       //wavePoints returns long, number of points in bin wave 
     419    npt = (CountInt) WavePoints(p->xwavH);      //wavePoints returns long, number of XYZ points 
     420    numBins = (CountInt) WavePoints(p->bwavH);  //wavePoints returns long, number of points in bin wave 
    421421         
    422422        xv = (double*)WaveData(p->xwavH);               //xyz locations 
     
    427427        PSFid = (double*)WaveData(p->PSFidH);                   //this one is 2D 
    428428         
    429         p1 = (int) p->p1; 
    430         p2 = (int) p->p2; 
    431          
    432         intSLD = (int) p->minSLD;               //convert to int for use as index 
     429        p1 = (CountInt) p->p1; 
     430        p2 = (CountInt) p->p2; 
     431         
     432        intSLD = (CountInt) p->minSLD;          //convert to int for use as index 
    433433 
    434434        grid = p->grid; 
     
    439439                for(j=(i+1);j<npt;j+=1) { 
    440440                        val = XYZDistance(xv[i],xv[j],yv[i],yv[j],zv[i],zv[j])*grid; 
    441                         binIndex = (int)(val/binWidth-0.5); 
     441                        binIndex = (CountInt)(val/binWidth-0.5); 
    442442                        if(binIndex > numBins -1 ) { 
    443443                                //Print "bad index" 
    444444                        } else { 
    445                                 rhoi = (long) rho[i];                           //get the rho value at i and j 
    446                                 rhoj = (long) rho[j]; 
    447                                 rii = (long) SLDLook[rhoi+intSLD];                      //rho i index 
    448                                 rji = (long) SLDLook[rhoj+intSLD];                      //rho j index 
     445                                rhoi = (CountInt) rho[i];                               //get the rho value at i and j 
     446                                rhoj = (CountInt) rho[j]; 
     447                                rii = (CountInt) SLDLook[rhoi+intSLD];                  //rho i index 
     448                                rji = (CountInt) SLDLook[rhoj+intSLD];                  //rho j index 
    449449                                MemClear(indices, sizeof(indices)); // Must be 0 for unused dimensions. 
    450                                 indices[0] = rii; 
    451                                 indices[1] = rji; 
     450                                indices[0] = (IndexInt)rii; 
     451                                indices[1] = (IndexInt)rji; 
    452452                                if (retVal = MDGetNumericWavePointValue(PSFwavH, indices, value)) 
    453453                                        return retVal; 
    454454                                //PSFIndex = (long) PSFid[rii][rji];            //doesn't work 
    455                                 PSFIndex = (long) value[0]; 
     455                                PSFIndex = (CountInt) value[0]; 
    456456                                 
    457457                                //now do the assignment to the 2D 
     
    459459                                 
    460460                                MemClear(indices, sizeof(indices)); // Must be 0 for unused dimensions. 
    461                                 indices[0] = binIndex; 
    462                                 indices[1] = PSFIndex; 
     461                                indices[0] = (IndexInt)binIndex; 
     462                                indices[1] = (IndexInt)PSFIndex; 
    463463                                if (retVal = MDGetNumericWavePointValue(wavH, indices, value)) 
    464464                                        return retVal; 
  • sans/XOP_Dev/MonteCarlo/MonteCarlo.c

    r834 r997  
    3232        double retVal;                          //return value 
    3333 
    34         long imon; 
     34        SInt64 imon; 
    3535        double r1,r2,xCtr,yCtr,sdd,pixSize,thick,wavelength,sig_incoh,sig_sas; 
    36         long ind,index,n_index; 
     36        IndexInt ind,index,n_index; 
    3737        double qmax,theta_max,q0,zpow; 
    38         long n1,n2,n3; 
     38        CountInt n1,n2,n3; 
    3939        double dth,zz,xx,yy,phi; 
    4040        double theta,ran,ll,rr; 
    41         long done,find_theta,err;               //used as logicals 
    42         long xPixel,yPixel; 
     41        int done,find_theta,err;                //used as logicals 
     42        int xPixel,yPixel; 
    4343        double vx,vy,vz,theta_z; 
    4444        double sig_abs,ratio,sig_total; 
    4545        double testQ,testPhi,left,delta,dummy,pi; 
    4646        double sigabs_0,num_bins; 
    47         long NSingleIncoherent,NSingleCoherent,NScatterEvents,incoherentEvent,coherentEvent; 
    48         long NDoubleCoherent,NMultipleScatter,isOn,xCtr_long,yCtr_long; 
    49         long NMultipleCoherent,NCoherentEvents; 
     47        CountInt NSingleIncoherent,NSingleCoherent,NScatterEvents,incoherentEvent,coherentEvent; 
     48        CountInt NDoubleCoherent,NMultipleScatter,isOn,xCtr_long,yCtr_long; 
     49        CountInt NMultipleCoherent,NCoherentEvents; 
    5050        double deltaLam,v1,v2,currWavelength,rsq,fac;           //for simulating wavelength distribution 
    5151        double ssd, sourAp, souXX, souYY, magn;         //source-to-sample, and source Ap radius for initlal trajectory 
     
    6363//      long dataOffset; 
    6464//      long numRows, numColumns; 
    65         long numRows_ran_dev; 
     65        CountInt numRows_ran_dev; 
    6666//      double *dp0, *dp;  
    6767        double value[2];                                // Pointers used for double data. 
    68         long seed; 
    69         long indices[MAX_DIMENSIONS]; 
     68        SInt32 seed; 
     69        IndexInt indices[MAX_DIMENSIONS]; 
    7070         
    7171//      char buf[256]; 
     
    120120        results = (double*)WaveData(p->resultsH); 
    121121         
    122         seed = (long)results[0]; 
     122        seed = (SInt32)results[0]; 
    123123         
    124124        //      sprintf(buf, "input seed = %ld\r", seed); 
     
    132132        seed = 12348765;                //non-negative after that does nothing 
    133133 
    134         imon = (int)inputWave[0]; 
     134        imon = (SInt64)inputWave[0]; 
    135135        r1 = inputWave[1]; 
    136136        r2 = inputWave[2]; 
     
    147147        sourAp = inputWave[13];         // radius, in cm, like r1 and r2         
    148148         
    149         xCtr_long = (long)(xCtr+0.5);   //round() not defined in VC8 
    150         yCtr_long = (long)(yCtr+0.5);   // and is probably wrong to use anyways (returns double!) 
     149        xCtr_long = (CountInt)(xCtr+0.5);       //round() not defined in VC8 
     150        yCtr_long = (CountInt)(yCtr+0.5);       // and is probably wrong to use anyways (returns double!) 
    151151         
    152152        dummy = MDGetWaveScaling(p->ran_devH, 0, &delta, &left);                //0 is the rows 
     
    378378                                                //Choose index for scattering angle array. 
    379379                                                //IND = NINT(THETA_z/DTH + 0.4999999) 
    380                                                 ind = (long)(theta_z/dth + 0.4999999);          //round is eqivalent to nint() 
     380                                                ind = (IndexInt)(theta_z/dth + 0.4999999);              //round is eqivalent to nint() 
    381381                                                nt[ind] += 1;                   //Increment bin for angle. 
    382382                                                //Increment angle array for single scattering events. 
  • sans/XOP_Dev/MonteCarlo/MonteCarlo.h

    r834 r997  
    2121/* Prototypes */ 
    2222// for TK6 
    23 HOST_IMPORT int main(IORecHandle ioRecHandle); 
     23HOST_IMPORT int XOPMain(IORecHandle ioRecHandle); 
    2424 
    2525  
    26 //#define OLD_IGOR 1 + FIRST_XOP_ERR 
     26#define OLD_IGOR 1 + FIRST_XOP_ERR 
    2727#define NON_EXISTENT_WAVE 2 + FIRST_XOP_ERR 
    2828#define NEEDS_2D_WAVE 3 + FIRST_XOP_ERR 
     
    5555int Monte_SANSX4(MC_ParamsPtr p); 
    5656 
    57 long MC_round(double x); 
    58 int FindPixel(double testQ, double testPhi, double lam, double yg_d, double sdd, double pixSize, double xCtr, double yCtr, long *xPixel, long *yPixel); 
     57int MC_round(double x); 
     58int FindPixel(double testQ, double testPhi, double lam, double yg_d, double sdd, double pixSize, double xCtr, double yCtr, int *xPixel, int *yPixel); 
    5959int NewDirection(double *vx, double *vy, double *vz, double theta, double phi); 
    6060double path_len(double aval, double sig_tot); 
    61 float ran1(long *idum); 
    62 float ran3(long *idum); 
    63 float ran1a(long *idum); 
    64 float ran3a(long *idum); 
    65 double locate_interp(double xx[], long n, double x); 
     61float ran1(SInt32 *idum); 
     62float ran3(SInt32 *idum); 
     63float ran1a(SInt32 *idum); 
     64float ran3a(SInt32 *idum); 
     65double locate_interp(double xx[], IndexInt n, double x); 
  • sans/XOP_Dev/MonteCarlo/MonteCarlo.r

    r974 r997  
    88 
    99resource 'vers' (2) {                                           /* Igor version info */ 
    10         0x05, 0x00, release, 0x00, 0,                   /* version bytes and country integer */ 
    11         "5.00", 
    12         "(for Igor 5.00 or later)" 
     10    0x06, 0x20, release, 0x00, 0,                       /* version bytes and country integer */ 
     11    "6.20", 
     12    "(for Igor 6.20 or later)" 
    1313}; 
    1414 
     
    1616        { 
    1717                /* [1] */ 
    18                 "SANSMonteCarlo requires Igor Pro 6.1 or later.", 
     18                "SANSMonteCarlo requires Igor Pro 6.2 or later.", 
    1919                /* [2] */ 
    2020                "Wave does not exist.", 
  • sans/XOP_Dev/MonteCarlo/MonteCarlo2.c

    r834 r997  
    3535        double retVal;                          //return value 
    3636 
    37         long imon; 
     37        SInt64 imon; 
    3838        double r1,r2,xCtr,yCtr,sdd,pixSize,thick,wavelength,sig_incoh,sig_sas; 
    39         long ind,index,n_index; 
     39        IndexInt ind,index,n_index; 
    4040        double qmax,theta_max,q0,zpow; 
    41         long n1,n2,n3; 
     41        CountInt n1,n2,n3; 
    4242        double dth,zz,xx,yy,phi; 
    4343        double theta,ran,ll,rr; 
    44         long done,find_theta,err;               //used as logicals 
    45         long xPixel,yPixel; 
     44        int done,find_theta,err;                //used as logicals 
     45        int xPixel,yPixel; 
    4646        double vx,vy,vz,theta_z; 
    4747        double sig_abs,ratio,sig_total; 
    4848        double testQ,testPhi,left,delta,dummy,pi; 
    4949        double sigabs_0,num_bins; 
    50         long NSingleIncoherent,NSingleCoherent,NScatterEvents,incoherentEvent,coherentEvent; 
    51         long NDoubleCoherent,NMultipleScatter,isOn,xCtr_long,yCtr_long; 
    52         long NMultipleCoherent,NCoherentEvents; 
     50        CountInt NSingleIncoherent,NSingleCoherent,NScatterEvents,incoherentEvent,coherentEvent; 
     51        CountInt NDoubleCoherent,NMultipleScatter,isOn,xCtr_long,yCtr_long; 
     52        CountInt NMultipleCoherent,NCoherentEvents; 
    5353        double deltaLam,v1,v2,currWavelength,rsq,fac;           //for simulating wavelength distribution 
    5454        double ssd, sourAp, souXX, souYY, magn;         //source-to-sample, and source Ap radius for initlal trajectory 
     
    6666//      long dataOffset; 
    6767//      long numRows, numColumns; 
    68         long numRows_ran_dev; 
     68        CountInt numRows_ran_dev; 
    6969//      double *dp0, *dp; 
    7070        double value[2];                                // Pointers used for double data. 
    71         long seed; 
    72         long indices[MAX_DIMENSIONS]; 
     71        SInt32 seed; 
     72        IndexInt indices[MAX_DIMENSIONS]; 
    7373         
    7474//      char buf[256]; 
     
    123123        results = (double*)WaveData(p->resultsH); 
    124124         
    125         seed = (long)results[0]; 
     125        seed = (SInt32)results[0]; 
    126126         
    127127//      sprintf(buf, "input seed = %ld\r", seed); 
     
    135135        seed = 12348765;                //non-negative after that does nothing 
    136136 
    137         imon = (int)inputWave[0]; 
     137        imon = (SInt64)inputWave[0]; 
    138138        r1 = inputWave[1]; 
    139139        r2 = inputWave[2]; 
     
    150150        sourAp = inputWave[13];         // radius, in cm, like r1 and r2         
    151151         
    152         xCtr_long = (long)(xCtr+0.5); 
    153         yCtr_long = (long)(yCtr+0.5); 
     152        xCtr_long = (CountInt)(xCtr+0.5); 
     153        yCtr_long = (CountInt)(yCtr+0.5); 
    154154         
    155155        dummy = MDGetWaveScaling(p->ran_devH, 0, &delta, &left);                //0 is the rows 
     
    380380                                                //Choose index for scattering angle array. 
    381381                                                //IND = NINT(THETA_z/DTH + 0.4999999) 
    382                                                 ind = (long)(theta_z/dth + 0.4999999);          //round is eqivalent to nint() 
     382                                                ind = (IndexInt)(theta_z/dth + 0.4999999);              //round is eqivalent to nint() 
    383383                                                nt[ind] += 1;                   //Increment bin for angle. 
    384384                                                //Increment angle array for single scattering events. 
  • sans/XOP_Dev/MonteCarlo/MonteCarlo3.c

    r834 r997  
    3434        double retVal;                          //return value 
    3535         
    36         long imon; 
     36        SInt64 imon; 
    3737        double r1,r2,xCtr,yCtr,sdd,pixSize,thick,wavelength,sig_incoh,sig_sas; 
    38         long ind,index,n_index; 
     38        IndexInt ind,index,n_index; 
    3939        double qmax,theta_max,q0,zpow; 
    40         long n1,n2,n3; 
     40        CountInt n1,n2,n3; 
    4141        double dth,zz,xx,yy,phi; 
    4242        double theta,ran,ll,rr; 
    43         long done,find_theta,err;               //used as logicals 
    44         long xPixel,yPixel; 
     43        int done,find_theta,err;                //used as logicals 
     44        int xPixel,yPixel; 
    4545        double vx,vy,vz,theta_z; 
    4646        double sig_abs,ratio,sig_total; 
    4747        double testQ,testPhi,left,delta,dummy,pi; 
    4848        double sigabs_0,num_bins; 
    49         long NSingleIncoherent,NSingleCoherent,NScatterEvents,incoherentEvent,coherentEvent; 
    50         long NDoubleCoherent,NMultipleScatter,isOn,xCtr_long,yCtr_long; 
    51         long NMultipleCoherent,NCoherentEvents; 
     49        CountInt NSingleIncoherent,NSingleCoherent,NScatterEvents,incoherentEvent,coherentEvent; 
     50        CountInt NDoubleCoherent,NMultipleScatter,isOn,xCtr_long,yCtr_long; 
     51        CountInt NMultipleCoherent,NCoherentEvents; 
    5252        double deltaLam,v1,v2,currWavelength,rsq,fac;           //for simulating wavelength distribution 
    5353        double ssd, sourAp, souXX, souYY, magn;         //source-to-sample, and source Ap radius for initlal trajectory 
     
    6464        //      long dataOffset; 
    6565        //      long numRows, numColumns; 
    66         long numRows_ran_dev; 
     66        CountInt numRows_ran_dev; 
    6767        //      double *dp0, *dp; 
    6868        double value[2];                                // Pointers used for double data. 
    69         long seed; 
    70         long indices[MAX_DIMENSIONS]; 
     69        SInt32 seed; 
     70        IndexInt indices[MAX_DIMENSIONS]; 
    7171         
    7272        //      char buf[256]; 
     
    121121        results = (double*)WaveData(p->resultsH); 
    122122         
    123         seed = (long)results[0]; 
     123        seed = (SInt32)results[0]; 
    124124         
    125125        //      sprintf(buf, "input seed = %ld\r", seed); 
     
    133133        seed = 12348765;                //non-negative after that does nothing 
    134134         
    135         imon = (int)inputWave[0]; 
     135        imon = (SInt64)inputWave[0]; 
    136136        r1 = inputWave[1]; 
    137137        r2 = inputWave[2]; 
     
    148148        sourAp = inputWave[13];         // radius, in cm, like r1 and r2         
    149149         
    150         xCtr_long = (long)(xCtr+0.5); 
    151         yCtr_long = (long)(yCtr+0.5); 
     150        xCtr_long = (CountInt)(xCtr+0.5); 
     151        yCtr_long = (CountInt)(yCtr+0.5); 
    152152         
    153153        dummy = MDGetWaveScaling(p->ran_devH, 0, &delta, &left);                //0 is the rows 
     
    377377                                                //Choose index for scattering angle array. 
    378378                                                //IND = NINT(THETA_z/DTH + 0.4999999) 
    379                                                 ind = (long)(theta_z/dth + 0.4999999);          //round is eqivalent to nint() 
     379                                                ind = (IndexInt)(theta_z/dth + 0.4999999);              //round is eqivalent to nint() 
    380380                                                nt[ind] += 1;                   //Increment bin for angle. 
    381381                                                //Increment angle array for single scattering events. 
  • sans/XOP_Dev/MonteCarlo/MonteCarlo4.c

    r834 r997  
    3535        double retVal;                          //return value 
    3636         
    37         long imon; 
     37        SInt64 imon; 
    3838        double r1,r2,xCtr,yCtr,sdd,pixSize,thick,wavelength,sig_incoh,sig_sas; 
    39         long ind,index,n_index; 
     39        IndexInt ind,index,n_index; 
    4040        double qmax,theta_max,q0,zpow; 
    41         long n1,n2,n3; 
     41        CountInt n1,n2,n3; 
    4242        double dth,zz,xx,yy,phi; 
    4343        double theta,ran,ll,rr; 
    44         long done,find_theta,err;               //used as logicals 
    45         long xPixel,yPixel; 
     44        int done,find_theta,err;                //used as logicals 
     45        int xPixel,yPixel; 
    4646        double vx,vy,vz,theta_z; 
    4747        double sig_abs,ratio,sig_total; 
    4848        double testQ,testPhi,left,delta,dummy,pi; 
    4949        double sigabs_0,num_bins; 
    50         long NSingleIncoherent,NSingleCoherent,NScatterEvents,incoherentEvent,coherentEvent; 
    51         long NDoubleCoherent,NMultipleScatter,isOn,xCtr_long,yCtr_long; 
    52         long NMultipleCoherent,NCoherentEvents; 
     50        CountInt NSingleIncoherent,NSingleCoherent,NScatterEvents,incoherentEvent,coherentEvent; 
     51        CountInt NDoubleCoherent,NMultipleScatter,isOn,xCtr_long,yCtr_long; 
     52        CountInt NMultipleCoherent,NCoherentEvents; 
    5353        double deltaLam,v1,v2,currWavelength,rsq,fac;           //for simulating wavelength distribution 
    5454        double ssd, sourAp, souXX, souYY, magn;         //source-to-sample, and source Ap radius for initlal trajectory 
     
    6565        //      long dataOffset; 
    6666        //      long numRows, numColumns; 
    67         long numRows_ran_dev; 
     67        CountInt numRows_ran_dev; 
    6868        //      double *dp0, *dp; 
    6969        double value[2];                                // Pointers used for double data. 
    70         long seed; 
    71         long indices[MAX_DIMENSIONS]; 
     70        SInt32 seed; 
     71        IndexInt indices[MAX_DIMENSIONS]; 
    7272         
    7373        //      char buf[256]; 
     
    122122        results = (double*)WaveData(p->resultsH); 
    123123         
    124         seed = (long)results[0]; 
     124        seed = (SInt32)results[0]; 
    125125         
    126126        //      sprintf(buf, "input seed = %ld\r", seed); 
     
    134134        seed = 12348765;                //non-negative after that does nothing 
    135135         
    136         imon = (int)inputWave[0]; 
     136        imon = (SInt64)inputWave[0]; 
    137137        r1 = inputWave[1]; 
    138138        r2 = inputWave[2]; 
     
    149149        sourAp = inputWave[13];         // radius, in cm, like r1 and r2 
    150150         
    151         xCtr_long = (long)(xCtr+0.5); 
    152         yCtr_long = (long)(yCtr+0.5); 
     151        xCtr_long = (CountInt)(xCtr+0.5); 
     152        yCtr_long = (CountInt)(yCtr+0.5); 
    153153         
    154154        dummy = MDGetWaveScaling(p->ran_devH, 0, &delta, &left);                //0 is the rows 
     
    379379                                                //Choose index for scattering angle array. 
    380380                                                //IND = NINT(THETA_z/DTH + 0.4999999) 
    381                                                 ind = (long)(theta_z/dth + 0.4999999);          //round is eqivalent to nint() 
     381                                                ind = (IndexInt)(theta_z/dth + 0.4999999);              //round is eqivalent to nint() 
    382382                                                nt[ind] += 1;                   //Increment bin for angle. 
    383383                                                //Increment angle array for single scattering events. 
  • sans/XOP_Dev/MonteCarlo/MonteCarlo_Main.c

    r974 r997  
    2121// rounds away from zero 
    2222// -- only used in FindPixel 
    23 long MC_round(double x) 
     23int MC_round(double x) 
    2424{ 
    2525        if(x == 0)      { 
    26                 return (long)(0); 
     26                return (int)(0); 
    2727        } 
    2828        if(x > 0)       { 
    29                 return (long)(x + 0.5f); 
     29                return (int)(x + 0.5f); 
    3030        } else {                // x < 0 
    31                 return (long)(x - 0.5f); 
     31                return (int)(x - 0.5f); 
    3232        } 
    3333} 
     
    3838int 
    3939FindPixel(double testQ, double testPhi, double lam, double yg_d, double sdd, 
    40                   double pixSize, double xCtr, double yCtr, long *xPixel, long *yPixel) { 
     40                  double pixSize, double xCtr, double yCtr, int *xPixel, int *yPixel) { 
    4141         
    4242//      double theta,dy,dx,qx,qy,pi; 
     
    152152#define RNMX (1.0-EPS) 
    153153 
    154 float ran1(long *idum) 
     154float ran1(SInt32 *idum) 
    155155{ 
    156156        int j; 
    157         long k; 
    158         static long iy=0; 
    159         static long iv[NTAB]; 
     157        SInt32 k; 
     158        static SInt32 iy=0; 
     159        static SInt32 iv[NTAB]; 
    160160        float temp; 
    161161         
     
    202202#define RNMX2 (1.0-EPS2) 
    203203 
    204 float ran1a(long *idum) 
     204float ran1a(SInt32 *idum) 
    205205{ 
    206206        int j; 
    207         long k; 
    208         static long iy=0; 
    209         static long iv[NTAB2]; 
     207        SInt32 k; 
     208        static SInt32 iy=0; 
     209        static SInt32 iv[NTAB2]; 
    210210        float temp; 
    211211         
     
    248248#define FAC (1.0/MBIG) 
    249249 
    250 float ran3(long *idum) 
     250float ran3(SInt32 *idum) 
    251251{ 
    252252        static int inext,inextp; 
    253         static long ma[56]; 
     253        static SInt32 ma[56]; 
    254254        static int iff=0; 
    255         long mj,mk; 
     255        SInt32 mj,mk; 
    256256        int i,ii,k; 
    257257         
     
    296296#define FAC2 (1.0/MBIG2) 
    297297 
    298 float ran3a(long *idum) 
     298float ran3a(SInt32 *idum) 
    299299{ 
    300300        static int inext,inextp; 
    301         static long ma[56]; 
     301        static SInt32 ma[56]; 
    302302        static int iff=0; 
    303         long mj,mk; 
     303        SInt32 mj,mk; 
    304304        int i,ii,k; 
    305305         
     
    340340 
    341341// returns the interpolated point value in xx[0,n-1] that has the value x 
    342 double locate_interp(double xx[], long n, double x) 
    343 { 
    344         unsigned long ju,jm,jl,j; 
     342double locate_interp(double xx[], IndexInt n, double x) 
     343{ 
     344        UInt32 ju,jm,jl,j; 
    345345        int ascnd; 
    346346        double pt; 
     
    376376 XFUNCs added by this XOP. See XOP manual regarding "Direct XFUNCs". 
    377377 */ 
    378 static long 
     378static XOPIORecResult 
    379379RegisterFunction() 
    380380{ 
    381381        int funcIndex; 
    382382         
    383         funcIndex = GetXOPItem(0);              // Which function is Igor asking about? 
     383        funcIndex = (int)GetXOPItem(0);         // Which function is Igor asking about? 
    384384        switch (funcIndex) { 
    385385                case 0:                                         //  
    386                         return((long)Monte_SANSX); 
     386                        return((XOPIORecResult)Monte_SANSX); 
    387387                        break; 
    388388                case 1:                                         //  
    389                         return((long)Monte_SANSX2); 
     389                        return((XOPIORecResult)Monte_SANSX2); 
    390390                        break; 
    391391                case 2:                                         //  
    392                         return((long)DebyeSpheresX); 
     392                        return((XOPIORecResult)DebyeSpheresX); 
    393393                        break; 
    394394                case 3:                                         //  
    395                         return((long)Monte_SANSX3); 
     395                        return((XOPIORecResult)Monte_SANSX3); 
    396396                        break; 
    397397                case 4:                                         //  
    398                         return((long)Monte_SANSX4); 
     398                        return((XOPIORecResult)Monte_SANSX4); 
    399399                        break; 
    400400                case 5:                                         //  
    401                         return((long)maxDistanceX); 
     401                        return((XOPIORecResult)maxDistanceX); 
    402402                        break; 
    403403                case 6:                                         //  
    404                         return((long)binDistanceX); 
     404                        return((XOPIORecResult)binDistanceX); 
    405405                        break; 
    406406                case 7:                                         //  
    407                         return((long)SobolX); 
     407                        return((XOPIORecResult)SobolX); 
    408408                        break; 
    409409                case 8:                                         //  
    410                         return((long)binSLDDistanceX); 
     410                        return((XOPIORecResult)binSLDDistanceX); 
    411411                        break; 
    412412                case 9:                                         //  
    413                         return((long)MetropolisX); 
    414                         break; 
    415         } 
    416         return(NIL); 
     413                        return((XOPIORecResult)MetropolisX); 
     414                        break; 
     415        } 
     416        return(0); 
    417417} 
    418418 
     
    421421 This is the entry point from the host application to the XOP for all messages after the 
    422422 INIT message. 
     423  
     424 updated for TK7 May2016 
    423425 */ 
     426//extern "C" void       //only use this if file is .cpp 
    424427static void 
    425428XOPEntry(void) 
    426429{        
    427         long result = 0; 
     430    XOPIORecResult result = 0; 
    428431         
    429432        switch (GetXOPMessage()) { 
     
    445448 */ 
    446449HOST_IMPORT int 
    447 main(IORecHandle ioRecHandle) 
     450XOPMain(IORecHandle ioRecHandle) 
    448451{        
    449452        XOPInit(ioRecHandle);                                                   // Do standard XOP initialization. 
    450453        SetXOPEntry(XOPEntry);                                                  // Set entry point for future calls. 
    451454         
    452         if (igorVersion < 600)  {                                       // Requires Igor Pro 6.00 or later. 
    453                 SetXOPResult(IGOR_OBSOLETE);     
     455        if (igorVersion < 620)  {                                       // Requires Igor Pro 6.00 or later. 
     456                SetXOPResult(OLD_IGOR); 
    454457                return EXIT_FAILURE; 
    455458        } 
Note: See TracChangeset for help on using the changeset viewer.