Changeset 623


Ignore:
Timestamp:
Jan 28, 2010 6:09:34 PM (12 years ago)
Author:
srkline
Message:

Updated the MonteCarlo? code to allow 4 processors, but simply copying the function 4 times, and defining 4 different random number generators. Still can't figure out what the problem is with threading a single version, but not worth the effort. Copy/paste is way faster.

Also added some simple (non-optimized) calculations for using Debye's sphere method. These are largely undocumented at this point - so see the code. These are XOP versions of the old ipf code I've used in the past, and stripped of the now-obsolete AltiVec? code (I now lose the 4x speedup from the vectorization...)

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

Legend:

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

    r591 r623  
    1111#include "XOPStandardHeaders.h"                 // Include ANSI headers, Mac headers, IgorXOP.h, XOP.h and XOPSupport.h 
    1212#include "MonteCarlo.h" 
     13#include "DebyeSpheres.h" 
    1314 
    1415static int gCallSpinProcess = 1;                // Set to 1 to all user abort (cmd dot) and background processing. 
     
    597598#undef RNMX 
    598599 
     600 
     601//////////a complete copy of ran1(), simply renamed ran1a() 
     602#define IA 16807 
     603#define IM 2147483647 
     604#define AM (1.0/IM) 
     605#define IQ 127773 
     606#define IR 2836 
     607#define NTAB 32 
     608#define NDIV (1+(IM-1)/NTAB) 
     609#define EPS 1.2e-7 
     610#define RNMX (1.0-EPS) 
     611 
     612float ran1a(long *idum) 
     613{ 
     614        int j; 
     615        long k; 
     616        static long iy=0; 
     617        static long iv[NTAB]; 
     618        float temp; 
     619 
     620        if (*idum <= 0 || !iy) { 
     621                if (-(*idum) < 1) *idum=1; 
     622                else *idum = -(*idum); 
     623                for (j=NTAB+7;j>=0;j--) { 
     624                        k=(*idum)/IQ; 
     625                        *idum=IA*(*idum-k*IQ)-IR*k; 
     626                        if (*idum < 0) *idum += IM; 
     627                        if (j < NTAB) iv[j] = *idum; 
     628                } 
     629                iy=iv[0]; 
     630        } 
     631        k=(*idum)/IQ; 
     632        *idum=IA*(*idum-k*IQ)-IR*k; 
     633        if (*idum < 0) *idum += IM; 
     634        j=iy/NDIV; 
     635        iy=iv[j]; 
     636        iv[j] = *idum; 
     637        if ((temp=AM*iy) > RNMX) return RNMX; 
     638        else return temp; 
     639} 
     640#undef IA 
     641#undef IM 
     642#undef AM 
     643#undef IQ 
     644#undef IR 
     645#undef NTAB 
     646#undef NDIV 
     647#undef EPS 
     648#undef RNMX 
     649/////////////// 
     650 
     651 
    599652//////////////////////// 
    600653#define MBIG 1000000000 
     
    645698#undef FAC 
    646699 
     700//////////////////////// a complete copy of ran3() renamed ran3a() 
     701#define MBIG 1000000000 
     702#define MSEED 161803398 
     703#define MZ 0 
     704#define FAC (1.0/MBIG) 
     705 
     706float ran3a(long *idum) 
     707{ 
     708        static int inext,inextp; 
     709        static long ma[56]; 
     710        static int iff=0; 
     711        long mj,mk; 
     712        int i,ii,k; 
     713 
     714        if (*idum < 0 || iff == 0) { 
     715                iff=1; 
     716                mj=MSEED-(*idum < 0 ? -*idum : *idum); 
     717                mj %= MBIG; 
     718                ma[55]=mj; 
     719                mk=1; 
     720                for (i=1;i<=54;i++) { 
     721                        ii=(21*i) % 55; 
     722                        ma[ii]=mk; 
     723                        mk=mj-mk; 
     724                        if (mk < MZ) mk += MBIG; 
     725                        mj=ma[ii]; 
     726                } 
     727                for (k=1;k<=4;k++) 
     728                        for (i=1;i<=55;i++) { 
     729                                ma[i] -= ma[1+(i+30) % 55]; 
     730                                if (ma[i] < MZ) ma[i] += MBIG; 
     731                        } 
     732                inext=0; 
     733                inextp=31; 
     734                *idum=1; 
     735        } 
     736        if (++inext == 56) inext=1; 
     737        if (++inextp == 56) inextp=1; 
     738        mj=ma[inext]-ma[inextp]; 
     739        if (mj < MZ) mj += MBIG; 
     740        ma[inext]=mj; 
     741        return mj*FAC; 
     742} 
     743#undef MBIG 
     744#undef MSEED 
     745#undef MZ 
     746#undef FAC 
     747 
    647748 
    648749// returns the interpolated point value in xx[0,n-1] that has the value x 
     
    696797                        return((long)Monte_SANSX2); 
    697798                        break; 
    698  
     799                case 2:                                         //  
     800                        return((long)DebyeSpheresX); 
     801                        break; 
     802                case 3:                                         //  
     803                        return((long)Monte_SANSX3); 
     804                        break; 
     805                case 4:                                         //  
     806                        return((long)Monte_SANSX4); 
     807                        break; 
    699808        } 
    700809        return(NIL); 
  • sans/XOP_Dev/MonteCarlo/MonteCarlo.h

    r458 r623  
    4141        waveHndl inputWaveH; 
    4242        void* tp;                               //unused void for ThreadSafe functions 
    43         double result;          // return value is unused, save for error if needed 
     43        double retVal;          // return value is unused, save for error if needed 
    4444}; 
    4545typedef struct MC_Params MC_Params; 
     
    5252int Monte_SANSX(MC_ParamsPtr p); 
    5353int Monte_SANSX2(MC_ParamsPtr p); 
     54int Monte_SANSX3(MC_ParamsPtr p); 
     55int Monte_SANSX4(MC_ParamsPtr p); 
    5456int FindPixel(double testQ, double testPhi, double lam, double sdd, double pixSize, double xCtr, double yCtr, long *xPixel, long *yPixel); 
    5557int NewDirection(double *vx, double *vy, double *vz, double theta, double phi); 
     
    5759float ran1(long *idum); 
    5860float ran3(long *idum); 
     61float ran1a(long *idum); 
     62float ran3a(long *idum); 
    5963double locate_interp(double xx[], long n, double x); 
  • sans/XOP_Dev/MonteCarlo/MonteCarlo.r

    r458 r623  
    6363                }, 
    6464                 
     65                "DebyeSpheresX",                                                /* function name */ 
     66                F_UTIL | F_THREADSAFE | F_EXTERNAL,                             /* function category == Utility */ 
     67                NT_FP64,                                                        /* return value type */  
     68                { 
     69                                                NT_FP64,                        /* single precision wave (q-wave) */ 
     70                        NT_FP32 + WAVE_TYPE,                            /* single precision wave (x coordinates) */ 
     71                        NT_FP32 + WAVE_TYPE,                            /* single precision wave (y coordinates) */ 
     72                        NT_FP32 + WAVE_TYPE,                            /* single precision wave (z coordinates) */ 
     73                        NT_FP32 + WAVE_TYPE,                            /* single precision wave (rho at xyz) */ 
     74                        NT_FP64,                                // Rprimary, the primary sphere radius 
     75                        NT_FP64,                                // grid, should be passed as 0.62*Rprimary 
     76                }, 
     77                 
     78                "Monte_SANSX3",         /* function name */ 
     79                F_UTIL | F_THREADSAFE | F_EXTERNAL,                                     /* function category == UTILITY */ 
     80                NT_FP64,                                                        /* return value type */                  
     81                { 
     82                        NT_FP64 + WAVE_TYPE, 
     83                        NT_FP64 + WAVE_TYPE, 
     84                        NT_FP64 + WAVE_TYPE, 
     85                        NT_FP64 + WAVE_TYPE, 
     86                        NT_FP64 + WAVE_TYPE, 
     87                        NT_FP64 + WAVE_TYPE, 
     88                        NT_FP64 + WAVE_TYPE, 
     89                        NT_FP64 + WAVE_TYPE, 
     90                }, 
     91                 
     92                "Monte_SANSX4",         /* function name */ 
     93                F_UTIL | F_THREADSAFE | F_EXTERNAL,                                     /* function category == UTILITY */ 
     94                NT_FP64,                                                        /* return value type */                  
     95                { 
     96                        NT_FP64 + WAVE_TYPE, 
     97                        NT_FP64 + WAVE_TYPE, 
     98                        NT_FP64 + WAVE_TYPE, 
     99                        NT_FP64 + WAVE_TYPE, 
     100                        NT_FP64 + WAVE_TYPE, 
     101                        NT_FP64 + WAVE_TYPE, 
     102                        NT_FP64 + WAVE_TYPE, 
     103                        NT_FP64 + WAVE_TYPE, 
     104                }, 
     105                 
    65106        } 
    66107}; 
  • sans/XOP_Dev/MonteCarlo/MonteCarlo2.c

    r591 r623  
    1414static int gCallSpinProcess = 1;                // Set to 1 to all user abort (cmd dot) and background processing. 
    1515 
    16 ////////// 
    17 //    PROGRAM Monte_SANS 
    18 //    PROGRAM simulates multiple SANS. 
    19 //       revised 2/12/99  JGB 
    20 //            added calculation of random deviate, and 2D 10/2008 SRK 
    21  
    22 //    N1 = NUMBER OF INCIDENT NEUTRONS. 
    23 //    N2 = NUMBER INTERACTED IN THE SAMPLE. 
    24 //    N3 = NUMBER ABSORBED. 
    25 //    THETA = SCATTERING ANGLE. 
    26  
    27 // works fine in the single-threaded case. 
     16// these versions are DIRECT COPIES of the main version in MonteCarlo.c 
     17// make changes there and copy them here. All that changes here is that the random 
     18// number calls are different.  
    2819// 
    29 /// currently crashes if threaded. apparently something here is either doing an unknown callback, or is accessing 
    30 // a bad place in memory.  
    31 // 
    32 // the operations SpinProcess() and WaveHandleModified() are callbacks and MUST be commented out before threading. 
    33 // - some locks are non-existent 
    34 // - supposedly safe wave access routines are used 
    35 // 
    36 // random number generators are not thread-safe, and can give less than random results, but is this enough to crash? 
    37 // -- a possible workaround is to define multiple versions (poor man's threading) 
    38 // 
    39 // 
    40 // 
    41  
    4220// version X uses ran3 
    4321// version X2 uses ran1 
     22// version X3 uses ran3a 
     23// version X4 usus ran1a 
    4424 
    4525int 
     
    469449        return(0); 
    470450} 
    471 ////////        end of main function for calculating multiple scattering 
    472  
     451////////        end of X2 
     452 
     453 
     454 
     455////////////////                X3 using ran3a 
     456int 
     457Monte_SANSX3(MC_ParamsPtr p) { 
     458        double *inputWave;                              /* pointer to double precision wave data */ 
     459        double *ran_dev;                                /* pointer to double precision wave data */ 
     460        double *nt;                             /* pointer to double precision wave data */ 
     461        double *j1;                             /* pointer to double precision wave data */ 
     462        double *j2;                             /* pointer to double precision wave data */ 
     463        double *nn;                             /* pointer to double precision wave data */ 
     464//      double *MC_linear_data;                         /* pointer to double precision wave data */ 
     465        double *results;                                /* pointer to double precision wave data */ 
     466        double retVal;                          //return value 
     467 
     468        long imon; 
     469        double r1,r2,xCtr,yCtr,sdd,pixSize,thick,wavelength,sig_incoh,sig_sas; 
     470        long ind,index,n_index; 
     471        double qmax,theta_max,q0,zpow; 
     472        long n1,n2,n3; 
     473        double dth,zz,xx,yy,phi; 
     474        double theta,ran,ll,rr,ttot; 
     475        long done,find_theta,err;               //used as logicals 
     476        long xPixel,yPixel; 
     477        double vx,vy,vz,theta_z; 
     478        double sig_abs,ratio,sig_total; 
     479        double testQ,testPhi,left,delta,dummy,pi; 
     480        double sigabs_0,num_bins; 
     481        long NSingleIncoherent,NSingleCoherent,NScatterEvents,incoherentEvent,coherentEvent; 
     482        long NDoubleCoherent,NMultipleScatter,isOn,xCtr_long,yCtr_long; 
     483        long NMultipleCoherent,NCoherentEvents; 
     484 
     485 
     486        // for accessing the 2D wave data, direct method (see the WaveAccess example XOP) 
     487        waveHndl wavH; 
     488        int waveType,hState; 
     489        long numDimensions; 
     490        long dimensionSizes[MAX_DIMENSIONS+1]; 
     491        char* dataStartPtr; 
     492        long dataOffset; 
     493        long numRows, numColumns,numRows_ran_dev; 
     494        double *dp0, *dp, value[2];                             // Pointers used for double data. 
     495        long seed; 
     496        long indices[MAX_DIMENSIONS]; 
     497         
     498        char buf[256]; 
     499                 
     500        /* check that wave handles are all valid */ 
     501        if (p->inputWaveH == NIL) { 
     502                SetNaN64(&p->retVal);                                   /* return NaN if wave is not valid */ 
     503                return(NON_EXISTENT_WAVE); 
     504        } 
     505        if (p->ran_devH == NIL) { 
     506                SetNaN64(&p->retVal);                                   /* return NaN if wave is not valid */ 
     507                return(NON_EXISTENT_WAVE); 
     508        }        
     509        if (p->ntH == NIL) { 
     510                SetNaN64(&p->retVal);                                   /* return NaN if wave is not valid */ 
     511                return(NON_EXISTENT_WAVE); 
     512        } 
     513        if (p->j1H == NIL) { 
     514                SetNaN64(&p->retVal);                                   /* return NaN if wave is not valid */ 
     515                return(NON_EXISTENT_WAVE); 
     516        } 
     517        if (p->j2H == NIL) { 
     518                SetNaN64(&p->retVal);                                   /* return NaN if wave is not valid */ 
     519                return(NON_EXISTENT_WAVE); 
     520        } 
     521        if (p->nnH == NIL) { 
     522                SetNaN64(&p->retVal);                                   /* return NaN if wave is not valid */ 
     523                return(NON_EXISTENT_WAVE); 
     524        } 
     525        if (p->MC_linear_dataH == NIL) { 
     526                SetNaN64(&p->retVal);                                   /* return NaN if wave is not valid */ 
     527                return(NON_EXISTENT_WAVE); 
     528        } 
     529        if (p->resultsH == NIL) { 
     530                SetNaN64(&p->retVal);                                   /* return NaN if wave is not valid */ 
     531                return(NON_EXISTENT_WAVE); 
     532        } 
     533         
     534        p->retVal = 0; 
     535         
     536// trusting that all inputs are DOUBLE PRECISION WAVES!!! 
     537        inputWave = WaveData(p->inputWaveH); 
     538        ran_dev = WaveData(p->ran_devH); 
     539        nt = WaveData(p->ntH); 
     540        j1 = WaveData(p->j1H); 
     541        j2 = WaveData(p->j2H); 
     542        nn = WaveData(p->nnH); 
     543//      MC_linear_data = WaveData(p->MC_linear_dataH); 
     544        results = WaveData(p->resultsH); 
     545         
     546        seed = (long)results[0]; 
     547         
     548//      sprintf(buf, "input seed = %ld\r", seed); 
     549//      XOPNotice(buf); 
     550         
     551        if(seed >= 0) { 
     552                seed = -1234509876; 
     553        } 
     554 
     555        dummy = ran3a(&seed);           //initialize the random sequence by passing in a negative value 
     556        seed = 12348765;                //non-negative after that does nothing 
     557 
     558        imon = (int)inputWave[0]; 
     559        r1 = inputWave[1]; 
     560        r2 = inputWave[2]; 
     561        xCtr = inputWave[3]; 
     562        yCtr = inputWave[4]; 
     563        sdd = inputWave[5]; 
     564        pixSize = inputWave[6]; 
     565        thick = inputWave[7]; 
     566        wavelength = inputWave[8]; 
     567        sig_incoh = inputWave[9]; 
     568        sig_sas = inputWave[10]; 
     569        xCtr_long = round(xCtr); 
     570        yCtr_long = round(yCtr); 
     571         
     572        dummy = MDGetWaveScaling(p->ran_devH, 0, &delta, &left);                //0 is the rows 
     573        if (retVal = MDGetWaveDimensions(p->ran_devH, &numDimensions, dimensionSizes)) 
     574                return retVal; 
     575        numRows_ran_dev = dimensionSizes[0]; 
     576         
     577        pi = 4.0*atan(1.0);      
     578         
     579        // access the 2D wave data for writing using the direct method 
     580        wavH = p->MC_linear_dataH; 
     581        if (wavH == NIL) 
     582                return NOWAV; 
     583 
     584//      waveType = WaveType(wavH); 
     585//      if (waveType & NT_CMPLX) 
     586//              return NO_COMPLEX_WAVE; 
     587//      if (waveType==TEXT_WAVE_TYPE) 
     588//              return NUMERIC_ACCESS_ON_TEXT_WAVE; 
     589//      if (retVal = MDGetWaveDimensions(wavH, &numDimensions, dimensionSizes)) 
     590//              return retVal; 
     591//      numRows = dimensionSizes[0]; 
     592//      numColumns = dimensionSizes[1]; 
     593         
     594//      if (retVal = MDAccessNumericWaveData(wavH, kMDWaveAccessMode0, &dataOffset)) 
     595//              return retVal; 
     596                 
     597//      hState = MoveLockHandle(wavH);          // So wave data can't move. Remember to call HSetState when done. 
     598//      dataStartPtr = (char*)(*wavH) + dataOffset; 
     599//      dp0 = (double*)dataStartPtr;                    // Pointer to the start of the 2D wave data. 
     600         
     601//scattering power and maximum qvalue to bin 
     602//      zpow = .1               //scattering power, calculated below 
     603        qmax = 4.0*pi/wavelength;       //maximum Q to bin 1D data. (A-1) (not really used) 
     604        sigabs_0 = 0.0;         // ignore absorption cross section/wavelength [1/(cm A)] 
     605        n_index = 50;   // maximum number of scattering events per neutron 
     606        num_bins = 200;         //number of 1-D bins (not really used) 
     607         
     608//c       total SAS cross-section 
     609// 
     610        zpow = sig_sas*thick;                   //since I now calculate the sig_sas from the model 
     611        sig_abs = sigabs_0 * wavelength; 
     612        sig_total = sig_abs + sig_sas + sig_incoh; 
     613//      Print "The TOTAL XSECTION. (CM-1) is ",sig_total 
     614//      Print "The TOTAL SAS XSECTION. (CM-1) is ",sig_sas 
     615//      results[0] = sig_total; 
     616//      results[1] = sig_sas; 
     617//      RATIO = SIG_ABS / SIG_TOTAL 
     618        ratio = sig_incoh / sig_total; 
     619         
     620        theta_max = wavelength*qmax/(2*pi); 
     621//C     SET Theta-STEP SIZE. 
     622        dth = theta_max/num_bins; 
     623//      Print "theta bin size = dth = ",dth 
     624 
     625//C     INITIALIZE COUNTERS. 
     626        n1 = 0; 
     627        n2 = 0; 
     628        n3 = 0; 
     629        NSingleIncoherent = 0; 
     630        NSingleCoherent = 0; 
     631        NDoubleCoherent = 0; 
     632        NMultipleScatter = 0; 
     633        NScatterEvents = 0; 
     634        NMultipleCoherent = 0; 
     635        NCoherentEvents = 0; 
     636         
     637        isOn = 0; 
     638         
     639//C     MONITOR LOOP - looping over the number of incedent neutrons 
     640//note that zz, is the z-position in the sample - NOT the scattering power 
     641// NOW, start the loop, throwing neutrons at the sample. 
     642        do { 
     643                ////SpinProcess() IS A CALLBACK, and not good for Threading! 
     644//              if ((n1 % 1000 == 0) && gCallSpinProcess && SpinProcess()) {            // Spins cursor and allows background processing. 
     645//                              retVal = -1;                                                            // User aborted. 
     646//                              break; 
     647//              } 
     648         
     649                vx = 0.0;                       // Initialize direction vector. 
     650                vy = 0.0; 
     651                vz = 1.0; 
     652                 
     653                theta = 0.0;            //      Initialize scattering angle. 
     654                phi = 0.0;                      //      Intialize azimuthal angle. 
     655                n1 += 1;                        //      Increment total number neutrons counter. 
     656                done = 0;                       //      True when neutron is absorbed or when  scattered out of the sample. 
     657                index = 0;                      //      Set counter for number of scattering events. 
     658                zz = 0.0;                       //      Set entering dimension of sample. 
     659                incoherentEvent = 0; 
     660                coherentEvent = 0; 
     661                 
     662                do      {                               //      Makes sure position is within circle. 
     663                        ran = ran3a(&seed);             //[0,1] 
     664                        xx = 2.0*r1*(ran-0.5);          //X beam position of neutron entering sample. 
     665                        ran = ran3a(&seed);             //[0,1] 
     666                        yy = 2.0*r1*(ran-0.5);          //Y beam position ... 
     667                        rr = sqrt(xx*xx+yy*yy);         //Radial position of neutron in incident beam. 
     668                } while(rr>r1); 
     669 
     670                do {   //Scattering Loop, will exit when "done" == 1 
     671                                // keep scattering multiple times until the neutron exits the sample 
     672                        ran = ran3a(&seed);             //[0,1]  RANDOM NUMBER FOR DETERMINING PATH LENGTH 
     673                        ll = path_len(ran,sig_total); 
     674                        //Determine new scattering direction vector. 
     675                        err = NewDirection(&vx,&vy,&vz,theta,phi);              //vx,vy,vz updated, theta, phi unchanged by function 
     676                                                                         
     677                        //X,Y,Z-POSITION OF SCATTERING EVENT. 
     678                        xx += ll*vx; 
     679                        yy += ll*vy; 
     680                        zz += ll*vz; 
     681                        rr = sqrt(xx*xx+yy*yy);         //radial position of scattering event. 
     682 
     683                        //sprintf(buf, "xx,yy,zz,vx,vy,vz,ll = %g %g %g %g %g %g %g\r",xx,yy,zz,vx,vy,vz,ll); 
     684                        //XOPNotice(buf); 
     685                                                 
     686                        //Check whether interaction occurred within sample volume. 
     687                        if (((zz > 0.0) && (zz < thick)) && (rr < r2)) { 
     688                                //NEUTRON INTERACTED. 
     689                                //sprintf(buf,"neutron interacted\r"); 
     690                                //XOPNotice(buf); 
     691                                 
     692                                index += 1;                     //Increment counter of scattering events. 
     693                                if (index == 1) { 
     694                                        n2 += 1;                //Increment # of scat. neutrons 
     695                                } 
     696                                ran = ran3a(&seed);             //[0,1] 
     697                                //Split neutron interactions into scattering and absorption events 
     698                                if (ran > ratio ) {             //C             NEUTRON SCATTERED coherently 
     699                                        //sprintf(buf,"neutron scatters coherently\r"); 
     700                                        //XOPNotice(buf); 
     701                                        coherentEvent += 1; 
     702                                        find_theta = 0;                 //false 
     703                                        do { 
     704                                                // pick a q-value from the deviate function 
     705                                                // pnt2x truncates the point to an integer before returning the x 
     706                                                // so get it from the wave scaling instead 
     707//                                              q0 =left + binarysearchinterp(ran_dev,ran3a(seed))*delta; 
     708                                                 
     709                                                q0 =left + locate_interp(ran_dev,numRows_ran_dev,ran3a(&seed))*delta; 
     710                                                theta = q0/2/pi*wavelength;             //SAS approximation 
     711                                                 
     712                                                find_theta = 1;         //always accept 
     713 
     714                                                //sprintf(buf, "after locate_interp call q0 = %g, theta = %g,left = %g,delta = %g\r",q0,theta,left,delta); 
     715                                                //XOPNotice(buf); 
     716 
     717                                        } while(!find_theta); 
     718                                         
     719                                        ran = ran3a(&seed);             //[0,1] 
     720                                        phi = 2.0*pi*ran;                       //Chooses azimuthal scattering angle. 
     721                                } else { 
     722                                        //NEUTRON scattered incoherently 
     723                                        //sprintf(buf,"neutron scatters incoherent\r"); 
     724                                        //XOPNotice(buf); 
     725                                        incoherentEvent += 1; 
     726                                  // phi and theta are random over the entire sphere of scattering 
     727                                        // !can't just choose random theta and phi, won't be random over sphere solid angle 
     728 
     729                                        ran = ran3a(&seed);             //[0,1] 
     730                                        theta = acos(2.0*ran-1); 
     731                         
     732                                        ran = ran3a(&seed);             //[0,1] 
     733                                        phi = 2.0*pi*ran;                       //Chooses azimuthal scattering angle. 
     734                                }               //(ran > ratio) 
     735                        } else { 
     736                                //NEUTRON ESCAPES FROM SAMPLE -- bin it somewhere                                                                
     737                                done = 1;               //done = true, will exit from loop 
     738                                //Increment #scattering events array 
     739                                MemClear(indices, sizeof(indices)); // Must be 0 for unused dimensions. 
     740                                indices[0] =index;                      //this sets access to nn[index] 
     741                                if (index <= n_index) { 
     742                                        if (retVal = MDGetNumericWavePointValue(p->nnH, indices, value)) 
     743                                                return retVal; 
     744                                        value[0] += 1; // add one to the value 
     745                                        if (retVal = MDSetNumericWavePointValue(p->nnH, indices, value)) 
     746                                                return retVal; 
     747                                //      nn[index] += 1; 
     748                                } 
     749                                                                                                 
     750                                if( index != 0) {               //neutron was scattered, figure out where it went 
     751                                        theta_z = acos(vz);             // Angle (= 2theta) WITH respect to z axis. 
     752                                        testQ = 2*pi*sin(theta_z)/wavelength; 
     753                                         
     754                                        // pick a random phi angle, and see if it lands on the detector 
     755                                        // since the scattering is isotropic, I can safely pick a new, random value 
     756                                        // this would not be true if simulating anisotropic scattering. 
     757                                        testPhi = ran3a(&seed)*2*pi; 
     758                                         
     759                                        // is it on the detector?        
     760                                        FindPixel(testQ,testPhi,wavelength,sdd,pixSize,xCtr,yCtr,&xPixel,&yPixel); 
     761                                                                                                         
     762                                        if(xPixel != -1 && yPixel != -1) { 
     763                                                isOn += 1; 
     764                                                MemClear(indices, sizeof(indices)); // Must be 0 for unused dimensions. 
     765                                                indices[0] = xPixel; 
     766                                                indices[1] = yPixel; 
     767                                                if (retVal = MDGetNumericWavePointValue(wavH, indices, value)) 
     768                                                        return retVal; 
     769                                                value[0] += 1; // Real part 
     770                                                if (retVal = MDSetNumericWavePointValue(wavH, indices, value)) 
     771                                                        return retVal; 
     772                                                //if(index==1)  // only the single scattering events 
     773                                                        //dp = dp0 + xPixel + yPixel*numColumns;                //offset the pointer to the exact memory location 
     774                                                        //*dp += 1;             //increment the value there 
     775                                                //endif 
     776                                        } 
     777                                         
     778 
     779        /*              is this causing me a problem since I'm not locking these? Probably not, since it crashes even if I comment these out... */ 
     780                                        if(theta_z < theta_max) { 
     781                                                //Choose index for scattering angle array. 
     782                                                //IND = NINT(THETA_z/DTH + 0.4999999) 
     783                                                ind = round(theta_z/dth + 0.4999999);           //round is eqivalent to nint() 
     784                                                nt[ind] += 1;                   //Increment bin for angle. 
     785                                                //Increment angle array for single scattering events. 
     786                                                if (index == 1) { 
     787                                                        j1[ind] += 1; 
     788                                                } 
     789                                                //Increment angle array for double scattering events. 
     790                                                if (index == 2) { 
     791                                                        j2[ind] += 1; 
     792                                                } 
     793                                        } 
     794        /**/ 
     795                                         
     796                                        // increment all of the counters now since done==1 here and I'm sure to exit and get another neutron 
     797                                        NScatterEvents += index;                //total number of scattering events 
     798                                        if(index == 1 && incoherentEvent == 1) { 
     799                                                NSingleIncoherent += 1; 
     800                                        } 
     801                                        if(index == 1 && coherentEvent == 1) { 
     802                                                NSingleCoherent += 1; 
     803                                        } 
     804                                        if(index == 2 && coherentEvent == 1 && incoherentEvent == 0) { 
     805                                                NDoubleCoherent += 1; 
     806                                        } 
     807                                        if(index > 1) { 
     808                                                NMultipleScatter += 1; 
     809                                        } 
     810                                        if(coherentEvent >= 1 && incoherentEvent == 0) { 
     811                                                NCoherentEvents += 1; 
     812                                        } 
     813                                        if(coherentEvent > 1 && incoherentEvent == 0) { 
     814                                                NMultipleCoherent += 1; 
     815                                        } 
     816 
     817                                } else {        // index was zero, neutron must be transmitted, so just increment the proper counters and data 
     818                                                isOn += 1; 
     819                                                nt[0] += 1; 
     820                                                MemClear(indices, sizeof(indices)); // Must be 0 for unused dimensions. 
     821                                                //indices[0] = xCtr_long;               //don't put everything in one pixel 
     822                                                //indices[1] = yCtr_long; 
     823                                                indices[0] = (long)round(xCtr+xx/pixSize); 
     824                                                indices[1] = (long)round(yCtr+yy/pixSize); 
     825                                                // check for valid indices - got an XOP error, probably from here 
     826                                                if(indices[0] > 127) indices[0] = 127; 
     827                                                if(indices[0] < 0) indices[0] = 0; 
     828                                                if(indices[1] > 127) indices[1] = 127; 
     829                                                if(indices[1] < 0) indices[1] = 0; 
     830                                                 
     831                                                if (retVal = MDGetNumericWavePointValue(wavH, indices, value)) 
     832                                                        return retVal; 
     833                                                value[0] += 1; // Real part 
     834                                                if (retVal = MDSetNumericWavePointValue(wavH, indices, value)) 
     835                                                        return retVal; 
     836                                        }        
     837                        } 
     838                 } while (!done); 
     839        } while(n1 < imon); 
     840         
     841// assign the results to the wave 
     842 
     843        MemClear(indices, sizeof(indices)); // Must be 0 for unused dimensions. 
     844        value[0] = (double)n1; 
     845        indices[0] = 0; 
     846        if (retVal = MDSetNumericWavePointValue(p->resultsH, indices, value)) 
     847                return retVal; 
     848        value[0] = (double)n2; 
     849        indices[0] = 1; 
     850        if (retVal = MDSetNumericWavePointValue(p->resultsH, indices, value)) 
     851                return retVal; 
     852        value[0] = (double)isOn; 
     853        indices[0] = 2; 
     854        if (retVal = MDSetNumericWavePointValue(p->resultsH, indices, value)) 
     855                return retVal; 
     856        value[0] = (double)NScatterEvents; 
     857        indices[0] = 3; 
     858        if (retVal = MDSetNumericWavePointValue(p->resultsH, indices, value)) 
     859                return retVal; 
     860        value[0] = (double)NSingleCoherent; 
     861        indices[0] = 4; 
     862        if (retVal = MDSetNumericWavePointValue(p->resultsH, indices, value)) 
     863                return retVal; 
     864        value[0] = (double)NMultipleCoherent; 
     865        indices[0] = 5; 
     866        if (retVal = MDSetNumericWavePointValue(p->resultsH, indices, value)) 
     867                return retVal; 
     868        value[0] = (double)NMultipleScatter; 
     869        indices[0] = 6; 
     870        if (retVal = MDSetNumericWavePointValue(p->resultsH, indices, value)) 
     871                return retVal;   
     872        value[0] = (double)NCoherentEvents; 
     873        indices[0] = 7; 
     874        if (retVal = MDSetNumericWavePointValue(p->resultsH, indices, value)) 
     875                return retVal; 
     876 
     877//      HSetState((Handle)wavH, hState);                //release the handle of the 2D data wave 
     878//      WaveHandleModified(wavH);                       // Inform Igor that we have changed the wave. (CALLBACK! needed, but not allowed in Threading) 
     879         
     880        return(0); 
     881} 
     882////////        end of X3 
     883 
     884 
     885///////////////// X4 using ran1a() 
     886int 
     887Monte_SANSX4(MC_ParamsPtr p) { 
     888        double *inputWave;                              /* pointer to double precision wave data */ 
     889        double *ran_dev;                                /* pointer to double precision wave data */ 
     890        double *nt;                             /* pointer to double precision wave data */ 
     891        double *j1;                             /* pointer to double precision wave data */ 
     892        double *j2;                             /* pointer to double precision wave data */ 
     893        double *nn;                             /* pointer to double precision wave data */ 
     894//      double *MC_linear_data;                         /* pointer to double precision wave data */ 
     895        double *results;                                /* pointer to double precision wave data */ 
     896        double retVal;                          //return value 
     897 
     898        long imon; 
     899        double r1,r2,xCtr,yCtr,sdd,pixSize,thick,wavelength,sig_incoh,sig_sas; 
     900        long ind,index,n_index; 
     901        double qmax,theta_max,q0,zpow; 
     902        long n1,n2,n3; 
     903        double dth,zz,xx,yy,phi; 
     904        double theta,ran,ll,rr,ttot; 
     905        long done,find_theta,err;               //used as logicals 
     906        long xPixel,yPixel; 
     907        double vx,vy,vz,theta_z; 
     908        double sig_abs,ratio,sig_total; 
     909        double testQ,testPhi,left,delta,dummy,pi; 
     910        double sigabs_0,num_bins; 
     911        long NSingleIncoherent,NSingleCoherent,NScatterEvents,incoherentEvent,coherentEvent; 
     912        long NDoubleCoherent,NMultipleScatter,isOn,xCtr_long,yCtr_long; 
     913        long NMultipleCoherent,NCoherentEvents; 
     914 
     915 
     916        // for accessing the 2D wave data, direct method (see the WaveAccess example XOP) 
     917        waveHndl wavH; 
     918        int waveType,hState; 
     919        long numDimensions; 
     920        long dimensionSizes[MAX_DIMENSIONS+1]; 
     921        char* dataStartPtr; 
     922        long dataOffset; 
     923        long numRows, numColumns,numRows_ran_dev; 
     924        double *dp0, *dp, value[2];                             // Pointers used for double data. 
     925        long seed; 
     926        long indices[MAX_DIMENSIONS]; 
     927         
     928        char buf[256]; 
     929                 
     930        /* check that wave handles are all valid */ 
     931        if (p->inputWaveH == NIL) { 
     932                SetNaN64(&p->retVal);                                   /* return NaN if wave is not valid */ 
     933                return(NON_EXISTENT_WAVE); 
     934        } 
     935        if (p->ran_devH == NIL) { 
     936                SetNaN64(&p->retVal);                                   /* return NaN if wave is not valid */ 
     937                return(NON_EXISTENT_WAVE); 
     938        }        
     939        if (p->ntH == NIL) { 
     940                SetNaN64(&p->retVal);                                   /* return NaN if wave is not valid */ 
     941                return(NON_EXISTENT_WAVE); 
     942        } 
     943        if (p->j1H == NIL) { 
     944                SetNaN64(&p->retVal);                                   /* return NaN if wave is not valid */ 
     945                return(NON_EXISTENT_WAVE); 
     946        } 
     947        if (p->j2H == NIL) { 
     948                SetNaN64(&p->retVal);                                   /* return NaN if wave is not valid */ 
     949                return(NON_EXISTENT_WAVE); 
     950        } 
     951        if (p->nnH == NIL) { 
     952                SetNaN64(&p->retVal);                                   /* return NaN if wave is not valid */ 
     953                return(NON_EXISTENT_WAVE); 
     954        } 
     955        if (p->MC_linear_dataH == NIL) { 
     956                SetNaN64(&p->retVal);                                   /* return NaN if wave is not valid */ 
     957                return(NON_EXISTENT_WAVE); 
     958        } 
     959        if (p->resultsH == NIL) { 
     960                SetNaN64(&p->retVal);                                   /* return NaN if wave is not valid */ 
     961                return(NON_EXISTENT_WAVE); 
     962        } 
     963         
     964        p->retVal = 0; 
     965         
     966// trusting that all inputs are DOUBLE PRECISION WAVES!!! 
     967        inputWave = WaveData(p->inputWaveH); 
     968        ran_dev = WaveData(p->ran_devH); 
     969        nt = WaveData(p->ntH); 
     970        j1 = WaveData(p->j1H); 
     971        j2 = WaveData(p->j2H); 
     972        nn = WaveData(p->nnH); 
     973//      MC_linear_data = WaveData(p->MC_linear_dataH); 
     974        results = WaveData(p->resultsH); 
     975         
     976        seed = (long)results[0]; 
     977         
     978//      sprintf(buf, "input seed = %ld\r", seed); 
     979//      XOPNotice(buf); 
     980         
     981        if(seed >= 0) { 
     982                seed = -1234509876; 
     983        } 
     984 
     985        dummy = ran1a(&seed);           //initialize the random sequence by passing in a negative value 
     986        seed = 12348765;                //non-negative after that does nothing 
     987 
     988        imon = (int)inputWave[0]; 
     989        r1 = inputWave[1]; 
     990        r2 = inputWave[2]; 
     991        xCtr = inputWave[3]; 
     992        yCtr = inputWave[4]; 
     993        sdd = inputWave[5]; 
     994        pixSize = inputWave[6]; 
     995        thick = inputWave[7]; 
     996        wavelength = inputWave[8]; 
     997        sig_incoh = inputWave[9]; 
     998        sig_sas = inputWave[10]; 
     999        xCtr_long = round(xCtr); 
     1000        yCtr_long = round(yCtr); 
     1001         
     1002        dummy = MDGetWaveScaling(p->ran_devH, 0, &delta, &left);                //0 is the rows 
     1003        if (retVal = MDGetWaveDimensions(p->ran_devH, &numDimensions, dimensionSizes)) 
     1004                return retVal; 
     1005        numRows_ran_dev = dimensionSizes[0]; 
     1006         
     1007        pi = 4.0*atan(1.0);      
     1008         
     1009        // access the 2D wave data for writing using the direct method 
     1010        wavH = p->MC_linear_dataH; 
     1011        if (wavH == NIL) 
     1012                return NOWAV; 
     1013 
     1014//      waveType = WaveType(wavH); 
     1015//      if (waveType & NT_CMPLX) 
     1016//              return NO_COMPLEX_WAVE; 
     1017//      if (waveType==TEXT_WAVE_TYPE) 
     1018//              return NUMERIC_ACCESS_ON_TEXT_WAVE; 
     1019//      if (retVal = MDGetWaveDimensions(wavH, &numDimensions, dimensionSizes)) 
     1020//              return retVal; 
     1021//      numRows = dimensionSizes[0]; 
     1022//      numColumns = dimensionSizes[1]; 
     1023         
     1024//      if (retVal = MDAccessNumericWaveData(wavH, kMDWaveAccessMode0, &dataOffset)) 
     1025//              return retVal; 
     1026                 
     1027//      hState = MoveLockHandle(wavH);          // So wave data can't move. Remember to call HSetState when done. 
     1028//      dataStartPtr = (char*)(*wavH) + dataOffset; 
     1029//      dp0 = (double*)dataStartPtr;                    // Pointer to the start of the 2D wave data. 
     1030         
     1031//scattering power and maximum qvalue to bin 
     1032//      zpow = .1               //scattering power, calculated below 
     1033        qmax = 4.0*pi/wavelength;       //maximum Q to bin 1D data. (A-1) (not really used) 
     1034        sigabs_0 = 0.0;         // ignore absorption cross section/wavelength [1/(cm A)] 
     1035        n_index = 50;   // maximum number of scattering events per neutron 
     1036        num_bins = 200;         //number of 1-D bins (not really used) 
     1037         
     1038//c       total SAS cross-section 
     1039// 
     1040        zpow = sig_sas*thick;                   //since I now calculate the sig_sas from the model 
     1041        sig_abs = sigabs_0 * wavelength; 
     1042        sig_total = sig_abs + sig_sas + sig_incoh; 
     1043//      Print "The TOTAL XSECTION. (CM-1) is ",sig_total 
     1044//      Print "The TOTAL SAS XSECTION. (CM-1) is ",sig_sas 
     1045//      results[0] = sig_total; 
     1046//      results[1] = sig_sas; 
     1047//      RATIO = SIG_ABS / SIG_TOTAL 
     1048        ratio = sig_incoh / sig_total; 
     1049         
     1050        theta_max = wavelength*qmax/(2*pi); 
     1051//C     SET Theta-STEP SIZE. 
     1052        dth = theta_max/num_bins; 
     1053//      Print "theta bin size = dth = ",dth 
     1054 
     1055//C     INITIALIZE COUNTERS. 
     1056        n1 = 0; 
     1057        n2 = 0; 
     1058        n3 = 0; 
     1059        NSingleIncoherent = 0; 
     1060        NSingleCoherent = 0; 
     1061        NDoubleCoherent = 0; 
     1062        NMultipleScatter = 0; 
     1063        NScatterEvents = 0; 
     1064        NMultipleCoherent = 0; 
     1065        NCoherentEvents = 0; 
     1066         
     1067        isOn = 0; 
     1068         
     1069//C     MONITOR LOOP - looping over the number of incedent neutrons 
     1070//note that zz, is the z-position in the sample - NOT the scattering power 
     1071// NOW, start the loop, throwing neutrons at the sample. 
     1072        do { 
     1073                ////SpinProcess() IS A CALLBACK, and not good for Threading! 
     1074//              if ((n1 % 1000 == 0) && gCallSpinProcess && SpinProcess()) {            // Spins cursor and allows background processing. 
     1075//                              retVal = -1;                                                            // User aborted. 
     1076//                              break; 
     1077//              } 
     1078         
     1079                vx = 0.0;                       // Initialize direction vector. 
     1080                vy = 0.0; 
     1081                vz = 1.0; 
     1082                 
     1083                theta = 0.0;            //      Initialize scattering angle. 
     1084                phi = 0.0;                      //      Intialize azimuthal angle. 
     1085                n1 += 1;                        //      Increment total number neutrons counter. 
     1086                done = 0;                       //      True when neutron is absorbed or when  scattered out of the sample. 
     1087                index = 0;                      //      Set counter for number of scattering events. 
     1088                zz = 0.0;                       //      Set entering dimension of sample. 
     1089                incoherentEvent = 0; 
     1090                coherentEvent = 0; 
     1091                 
     1092                do      {                               //      Makes sure position is within circle. 
     1093                        ran = ran1a(&seed);             //[0,1] 
     1094                        xx = 2.0*r1*(ran-0.5);          //X beam position of neutron entering sample. 
     1095                        ran = ran1a(&seed);             //[0,1] 
     1096                        yy = 2.0*r1*(ran-0.5);          //Y beam position ... 
     1097                        rr = sqrt(xx*xx+yy*yy);         //Radial position of neutron in incident beam. 
     1098                } while(rr>r1); 
     1099 
     1100                do {   //Scattering Loop, will exit when "done" == 1 
     1101                                // keep scattering multiple times until the neutron exits the sample 
     1102                        ran = ran1a(&seed);             //[0,1]  RANDOM NUMBER FOR DETERMINING PATH LENGTH 
     1103                        ll = path_len(ran,sig_total); 
     1104                        //Determine new scattering direction vector. 
     1105                        err = NewDirection(&vx,&vy,&vz,theta,phi);              //vx,vy,vz updated, theta, phi unchanged by function 
     1106                                                                         
     1107                        //X,Y,Z-POSITION OF SCATTERING EVENT. 
     1108                        xx += ll*vx; 
     1109                        yy += ll*vy; 
     1110                        zz += ll*vz; 
     1111                        rr = sqrt(xx*xx+yy*yy);         //radial position of scattering event. 
     1112 
     1113                        //sprintf(buf, "xx,yy,zz,vx,vy,vz,ll = %g %g %g %g %g %g %g\r",xx,yy,zz,vx,vy,vz,ll); 
     1114                        //XOPNotice(buf); 
     1115                                                 
     1116                        //Check whether interaction occurred within sample volume. 
     1117                        if (((zz > 0.0) && (zz < thick)) && (rr < r2)) { 
     1118                                //NEUTRON INTERACTED. 
     1119                                //sprintf(buf,"neutron interacted\r"); 
     1120                                //XOPNotice(buf); 
     1121                                 
     1122                                index += 1;                     //Increment counter of scattering events. 
     1123                                if (index == 1) { 
     1124                                        n2 += 1;                //Increment # of scat. neutrons 
     1125                                } 
     1126                                ran = ran1a(&seed);             //[0,1] 
     1127                                //Split neutron interactions into scattering and absorption events 
     1128                                if (ran > ratio ) {             //C             NEUTRON SCATTERED coherently 
     1129                                        //sprintf(buf,"neutron scatters coherently\r"); 
     1130                                        //XOPNotice(buf); 
     1131                                        coherentEvent += 1; 
     1132                                        find_theta = 0;                 //false 
     1133                                        do { 
     1134                                                // pick a q-value from the deviate function 
     1135                                                // pnt2x truncates the point to an integer before returning the x 
     1136                                                // so get it from the wave scaling instead 
     1137//                                              q0 =left + binarysearchinterp(ran_dev,ran1a(seed))*delta; 
     1138                                                 
     1139                                                q0 =left + locate_interp(ran_dev,numRows_ran_dev,ran1a(&seed))*delta; 
     1140                                                theta = q0/2/pi*wavelength;             //SAS approximation 
     1141                                                 
     1142                                                find_theta = 1;         //always accept 
     1143 
     1144                                                //sprintf(buf, "after locate_interp call q0 = %g, theta = %g,left = %g,delta = %g\r",q0,theta,left,delta); 
     1145                                                //XOPNotice(buf); 
     1146 
     1147                                        } while(!find_theta); 
     1148                                         
     1149                                        ran = ran1a(&seed);             //[0,1] 
     1150                                        phi = 2.0*pi*ran;                       //Chooses azimuthal scattering angle. 
     1151                                } else { 
     1152                                        //NEUTRON scattered incoherently 
     1153                                        //sprintf(buf,"neutron scatters incoherent\r"); 
     1154                                        //XOPNotice(buf); 
     1155                                        incoherentEvent += 1; 
     1156                                  // phi and theta are random over the entire sphere of scattering 
     1157                                        // !can't just choose random theta and phi, won't be random over sphere solid angle 
     1158 
     1159                                        ran = ran1a(&seed);             //[0,1] 
     1160                                        theta = acos(2.0*ran-1); 
     1161                         
     1162                                        ran = ran1a(&seed);             //[0,1] 
     1163                                        phi = 2.0*pi*ran;                       //Chooses azimuthal scattering angle. 
     1164                                }               //(ran > ratio) 
     1165                        } else { 
     1166                                //NEUTRON ESCAPES FROM SAMPLE -- bin it somewhere                                                                
     1167                                done = 1;               //done = true, will exit from loop 
     1168                                //Increment #scattering events array 
     1169                                MemClear(indices, sizeof(indices)); // Must be 0 for unused dimensions. 
     1170                                indices[0] =index;                      //this sets access to nn[index] 
     1171                                if (index <= n_index) { 
     1172                                        if (retVal = MDGetNumericWavePointValue(p->nnH, indices, value)) 
     1173                                                return retVal; 
     1174                                        value[0] += 1; // add one to the value 
     1175                                        if (retVal = MDSetNumericWavePointValue(p->nnH, indices, value)) 
     1176                                                return retVal; 
     1177                                //      nn[index] += 1; 
     1178                                } 
     1179                                                                                                 
     1180                                if( index != 0) {               //neutron was scattered, figure out where it went 
     1181                                        theta_z = acos(vz);             // Angle (= 2theta) WITH respect to z axis. 
     1182                                        testQ = 2*pi*sin(theta_z)/wavelength; 
     1183                                         
     1184                                        // pick a random phi angle, and see if it lands on the detector 
     1185                                        // since the scattering is isotropic, I can safely pick a new, random value 
     1186                                        // this would not be true if simulating anisotropic scattering. 
     1187                                        testPhi = ran1a(&seed)*2*pi; 
     1188                                         
     1189                                        // is it on the detector?        
     1190                                        FindPixel(testQ,testPhi,wavelength,sdd,pixSize,xCtr,yCtr,&xPixel,&yPixel); 
     1191                                                                                                         
     1192                                        if(xPixel != -1 && yPixel != -1) { 
     1193                                                isOn += 1; 
     1194                                                MemClear(indices, sizeof(indices)); // Must be 0 for unused dimensions. 
     1195                                                indices[0] = xPixel; 
     1196                                                indices[1] = yPixel; 
     1197                                                if (retVal = MDGetNumericWavePointValue(wavH, indices, value)) 
     1198                                                        return retVal; 
     1199                                                value[0] += 1; // Real part 
     1200                                                if (retVal = MDSetNumericWavePointValue(wavH, indices, value)) 
     1201                                                        return retVal; 
     1202                                                //if(index==1)  // only the single scattering events 
     1203                                                        //dp = dp0 + xPixel + yPixel*numColumns;                //offset the pointer to the exact memory location 
     1204                                                        //*dp += 1;             //increment the value there 
     1205                                                //endif 
     1206                                        } 
     1207                                         
     1208 
     1209        /*              is this causing me a problem since I'm not locking these? Probably not, since it crashes even if I comment these out... */ 
     1210                                        if(theta_z < theta_max) { 
     1211                                                //Choose index for scattering angle array. 
     1212                                                //IND = NINT(THETA_z/DTH + 0.4999999) 
     1213                                                ind = round(theta_z/dth + 0.4999999);           //round is eqivalent to nint() 
     1214                                                nt[ind] += 1;                   //Increment bin for angle. 
     1215                                                //Increment angle array for single scattering events. 
     1216                                                if (index == 1) { 
     1217                                                        j1[ind] += 1; 
     1218                                                } 
     1219                                                //Increment angle array for double scattering events. 
     1220                                                if (index == 2) { 
     1221                                                        j2[ind] += 1; 
     1222                                                } 
     1223                                        } 
     1224        /**/ 
     1225                                         
     1226                                        // increment all of the counters now since done==1 here and I'm sure to exit and get another neutron 
     1227                                        NScatterEvents += index;                //total number of scattering events 
     1228                                        if(index == 1 && incoherentEvent == 1) { 
     1229                                                NSingleIncoherent += 1; 
     1230                                        } 
     1231                                        if(index == 1 && coherentEvent == 1) { 
     1232                                                NSingleCoherent += 1; 
     1233                                        } 
     1234                                        if(index == 2 && coherentEvent == 1 && incoherentEvent == 0) { 
     1235                                                NDoubleCoherent += 1; 
     1236                                        } 
     1237                                        if(index > 1) { 
     1238                                                NMultipleScatter += 1; 
     1239                                        } 
     1240                                        if(coherentEvent >= 1 && incoherentEvent == 0) { 
     1241                                                NCoherentEvents += 1; 
     1242                                        } 
     1243                                        if(coherentEvent > 1 && incoherentEvent == 0) { 
     1244                                                NMultipleCoherent += 1; 
     1245                                        } 
     1246 
     1247                                } else {        // index was zero, neutron must be transmitted, so just increment the proper counters and data 
     1248                                                isOn += 1; 
     1249                                                nt[0] += 1; 
     1250                                                MemClear(indices, sizeof(indices)); // Must be 0 for unused dimensions. 
     1251                                                //indices[0] = xCtr_long;               //don't put everything in one pixel 
     1252                                                //indices[1] = yCtr_long; 
     1253                                                indices[0] = (long)round(xCtr+xx/pixSize); 
     1254                                                indices[1] = (long)round(yCtr+yy/pixSize); 
     1255                                                // check for valid indices - got an XOP error, probably from here 
     1256                                                if(indices[0] > 127) indices[0] = 127; 
     1257                                                if(indices[0] < 0) indices[0] = 0; 
     1258                                                if(indices[1] > 127) indices[1] = 127; 
     1259                                                if(indices[1] < 0) indices[1] = 0; 
     1260                                                 
     1261                                                if (retVal = MDGetNumericWavePointValue(wavH, indices, value)) 
     1262                                                        return retVal; 
     1263                                                value[0] += 1; // Real part 
     1264                                                if (retVal = MDSetNumericWavePointValue(wavH, indices, value)) 
     1265                                                        return retVal; 
     1266                                        }        
     1267                        } 
     1268                 } while (!done); 
     1269        } while(n1 < imon); 
     1270         
     1271// assign the results to the wave 
     1272 
     1273        MemClear(indices, sizeof(indices)); // Must be 0 for unused dimensions. 
     1274        value[0] = (double)n1; 
     1275        indices[0] = 0; 
     1276        if (retVal = MDSetNumericWavePointValue(p->resultsH, indices, value)) 
     1277                return retVal; 
     1278        value[0] = (double)n2; 
     1279        indices[0] = 1; 
     1280        if (retVal = MDSetNumericWavePointValue(p->resultsH, indices, value)) 
     1281                return retVal; 
     1282        value[0] = (double)isOn; 
     1283        indices[0] = 2; 
     1284        if (retVal = MDSetNumericWavePointValue(p->resultsH, indices, value)) 
     1285                return retVal; 
     1286        value[0] = (double)NScatterEvents; 
     1287        indices[0] = 3; 
     1288        if (retVal = MDSetNumericWavePointValue(p->resultsH, indices, value)) 
     1289                return retVal; 
     1290        value[0] = (double)NSingleCoherent; 
     1291        indices[0] = 4; 
     1292        if (retVal = MDSetNumericWavePointValue(p->resultsH, indices, value)) 
     1293                return retVal; 
     1294        value[0] = (double)NMultipleCoherent; 
     1295        indices[0] = 5; 
     1296        if (retVal = MDSetNumericWavePointValue(p->resultsH, indices, value)) 
     1297                return retVal; 
     1298        value[0] = (double)NMultipleScatter; 
     1299        indices[0] = 6; 
     1300        if (retVal = MDSetNumericWavePointValue(p->resultsH, indices, value)) 
     1301                return retVal;   
     1302        value[0] = (double)NCoherentEvents; 
     1303        indices[0] = 7; 
     1304        if (retVal = MDSetNumericWavePointValue(p->resultsH, indices, value)) 
     1305                return retVal; 
     1306 
     1307//      HSetState((Handle)wavH, hState);                //release the handle of the 2D data wave 
     1308//      WaveHandleModified(wavH);                       // Inform Igor that we have changed the wave. (CALLBACK! needed, but not allowed in Threading) 
     1309         
     1310        return(0); 
     1311} 
     1312////////        end of X4 
     1313 
     1314 
     1315 
  • sans/XOP_Dev/MonteCarlo/Xcode/MonteCarlo.xcodeproj/project.pbxproj

    r458 r623  
    1111                06C8DC610EA7CB1600E49E7B /* MonteCarlo.c in Sources */ = {isa = PBXBuildFile; fileRef = 06C8DC5F0EA7CB1600E49E7B /* MonteCarlo.c */; }; 
    1212                06C8DC620EA7CB1600E49E7B /* MonteCarlo.h in Headers */ = {isa = PBXBuildFile; fileRef = 06C8DC600EA7CB1600E49E7B /* MonteCarlo.h */; }; 
     13                06DA0F6810D81DD000ACEE13 /* DebyeSpheres.c in Sources */ = {isa = PBXBuildFile; fileRef = 06DA0F6610D81DD000ACEE13 /* DebyeSpheres.c */; }; 
     14                06DA0F6910D81DD000ACEE13 /* DebyeSpheres.h in Headers */ = {isa = PBXBuildFile; fileRef = 06DA0F6710D81DD000ACEE13 /* DebyeSpheres.h */; }; 
    1315                8D01CCC80486CAD60068D4B7 /* MonteCarlo_Prefix.pch in Headers */ = {isa = PBXBuildFile; fileRef = 32BAE0B30371A71500C91783 /* MonteCarlo_Prefix.pch */; }; 
    1416                8D01CCCA0486CAD60068D4B7 /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = 089C167DFE841241C02AAC07 /* InfoPlist.strings */; }; 
     
    6163                06C8DC600EA7CB1600E49E7B /* MonteCarlo.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = MonteCarlo.h; path = ../MonteCarlo.h; sourceTree = SOURCE_ROOT; }; 
    6264                06C8DCA90EA7CFB000E49E7B /* MonteCarlo.xop */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = MonteCarlo.xop; sourceTree = BUILT_PRODUCTS_DIR; }; 
     65                06DA0F6610D81DD000ACEE13 /* DebyeSpheres.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = DebyeSpheres.c; path = ../DebyeSpheres.c; sourceTree = SOURCE_ROOT; }; 
     66                06DA0F6710D81DD000ACEE13 /* DebyeSpheres.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = DebyeSpheres.h; path = ../DebyeSpheres.h; sourceTree = SOURCE_ROOT; }; 
    6367                089C167EFE841241C02AAC07 /* English */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = English; path = English.lproj/InfoPlist.strings; sourceTree = "<group>"; }; 
    6468                08EA7FFBFE8413EDC02AAC07 /* Carbon.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Carbon.framework; path = /System/Library/Frameworks/Carbon.framework; sourceTree = "<absolute>"; }; 
     
    116120                                32BAE0B30371A71500C91783 /* MonteCarlo_Prefix.pch */, 
    117121                                AA53F5630587C7410055F2C1 /* MonteCarlo.r */, 
     122                                06DA0F6610D81DD000ACEE13 /* DebyeSpheres.c */, 
     123                                06DA0F6710D81DD000ACEE13 /* DebyeSpheres.h */, 
    118124                                06C8DC5F0EA7CB1600E49E7B /* MonteCarlo.c */, 
    119125                                0651C06A0EDDC6E300823BAB /* MonteCarlo2.c */, 
     
    140146                                8D01CCC80486CAD60068D4B7 /* MonteCarlo_Prefix.pch in Headers */, 
    141147                                06C8DC620EA7CB1600E49E7B /* MonteCarlo.h in Headers */, 
     148                                06DA0F6910D81DD000ACEE13 /* DebyeSpheres.h in Headers */, 
    142149                        ); 
    143150                        runOnlyForDeploymentPostprocessing = 0; 
     
    245252                                06C8DC610EA7CB1600E49E7B /* MonteCarlo.c in Sources */, 
    246253                                0651C06B0EDDC6E300823BAB /* MonteCarlo2.c in Sources */, 
     254                                06DA0F6810D81DD000ACEE13 /* DebyeSpheres.c in Sources */, 
    247255                        ); 
    248256                        runOnlyForDeploymentPostprocessing = 0; 
     
    327335                                EXPORTED_SYMBOLS_FILE = ./Exports.exp; 
    328336                                FRAMEWORK_SEARCH_PATHS = ""; 
     337                                GCC_AUTO_VECTORIZATION = YES; 
    329338                                GCC_ENABLE_FIX_AND_CONTINUE = NO; 
    330339                                GCC_ENABLE_TRIGRAPHS = NO; 
     
    379388                                EXPORTED_SYMBOLS_FILE = ./Exports.exp; 
    380389                                FRAMEWORK_SEARCH_PATHS = ""; 
     390                                GCC_AUTO_VECTORIZATION = YES; 
    381391                                GCC_ENABLE_TRIGRAPHS = NO; 
    382392                                GCC_GENERATE_DEBUGGING_SYMBOLS = NO; 
  • sans/XOP_Dev/MonteCarlo/Xcode/MonteCarlo.xcodeproj/srkline.mode1

    r591 r623  
    314314                                                        <array> 
    315315                                                                <array> 
    316                                                                         <integer>4</integer> 
     316                                                                        <integer>7</integer> 
    317317                                                                        <integer>1</integer> 
    318318                                                                        <integer>0</integer> 
     
    339339                                                </array> 
    340340                                                <key>RubberWindowFrame</key> 
    341                                                 <string>83 70 1189 1108 0 0 1600 1178 </string> 
     341                                                <string>66 70 1189 1108 0 0 1600 1178 </string> 
    342342                                        </dict> 
    343343                                        <key>Module</key> 
     
    367367                                                                                <integer>10</integer> 
    368368                                                                                <key>bookmark</key> 
    369                                                                                 <string>06BEBC1010A075AA00F47EA7</string> 
     369                                                                                <string>0674616D11120725007269DF</string> 
    370370                                                                                <key>history</key> 
    371371                                                                                <array> 
    372372                                                                                        <string>06C8DCE60EA7D5DA00E49E7B</string> 
    373                                                                                         <string>06C8DD2B0EA7E5C900E49E7B</string> 
    374                                                                                         <string>0651C0720EDDDEDD00823BAB</string> 
    375                                                                                         <string>0651C0730EDDDEDD00823BAB</string> 
    376                                                                                         <string>06628CBB1092384D00F7FB01</string> 
    377                                                                                 </array> 
    378                                                                                 <key>prevStack</key> 
    379                                                                                 <array> 
    380                                                                                         <string>06C8DC810EA7CF3000E49E7B</string> 
    381                                                                                         <string>06C8DC820EA7CF3000E49E7B</string> 
    382                                                                                         <string>06C8DC850EA7CF3000E49E7B</string> 
    383                                                                                         <string>06C8DC860EA7CF3000E49E7B</string> 
    384                                                                                 </array> 
    385                                                                         </dict> 
    386                                                                         <key>SplitCount</key> 
    387                                                                         <string>1</string> 
    388                                                                 </dict> 
    389                                                                 <key>StatusBarVisibility</key> 
    390                                                                 <true/> 
    391                                                         </dict> 
    392                                                         <key>GeometryConfiguration</key> 
    393                                                         <dict> 
    394                                                                 <key>Frame</key> 
    395                                                                 <string>{{0, 0}, {941, 436}}</string> 
    396                                                                 <key>RubberWindowFrame</key> 
    397                                                                 <string>83 70 1189 1108 0 0 1600 1178 </string> 
    398                                                         </dict> 
    399                                                         <key>Module</key> 
    400                                                         <string>PBXNavigatorGroup</string> 
    401                                                         <key>Proportion</key> 
    402                                                         <string>436pt</string> 
    403                                                 </dict> 
    404                                                 <dict> 
    405                                                         <key>BecomeActive</key> 
    406                                                         <true/> 
    407                                                         <key>ContentConfiguration</key> 
    408                                                         <dict> 
    409                                                                 <key>PBXProjectModuleGUID</key> 
    410                                                                 <string>1CE0B20306471E060097A5F4</string> 
    411                                                                 <key>PBXProjectModuleLabel</key> 
    412                                                                 <string>MonteCarlo.c</string> 
    413                                                                 <key>PBXSplitModuleInNavigatorKey</key> 
    414                                                                 <dict> 
    415                                                                         <key>Split0</key> 
    416                                                                         <dict> 
    417                                                                                 <key>PBXProjectModuleGUID</key> 
    418                                                                                 <string>1CE0B20406471E060097A5F4</string> 
    419                                                                                 <key>PBXProjectModuleLabel</key> 
    420                                                                                 <string>MonteCarlo.c</string> 
    421                                                                                 <key>_historyCapacity</key> 
    422                                                                                 <integer>10</integer> 
    423                                                                                 <key>bookmark</key> 
    424                                                                                 <string>06BEBC1110A075AA00F47EA7</string> 
    425                                                                                 <key>history</key> 
    426                                                                                 <array> 
    427                                                                                         <string>06C8DCE60EA7D5DA00E49E7B</string> 
    428                                                                                         <string>06FC64500EBF4BDA00F1F7E9</string> 
    429                                                                                         <string>06863A521059483A003A0897</string> 
    430                                                                                         <string>06863A531059483A003A0897</string> 
    431                                                                                         <string>06628CBC1092384D00F7FB01</string> 
     373                                                                                        <string>06DA0FC910D83CCB00ACEE13</string> 
     374                                                                                        <string>06DA0FCA10D83CCB00ACEE13</string> 
     375                                                                                        <string>067461511111FE60007269DF</string> 
     376                                                                                        <string>0674615F11120540007269DF</string> 
     377                                                                                        <string>0674616011120540007269DF</string> 
     378                                                                                        <string>0674616111120540007269DF</string> 
    432379                                                                                </array> 
    433380                                                                                <key>prevStack</key> 
     
    438385                                                                                        <string>06C8DC860EA7CF3000E49E7B</string> 
    439386                                                                                        <string>06863A561059483A003A0897</string> 
     387                                                                                        <string>06DA0F7410D81F9400ACEE13</string> 
     388                                                                                        <string>06DA0F8C10D8253900ACEE13</string> 
     389                                                                                        <string>067461531111FE60007269DF</string> 
     390                                                                                        <string>0674616211120540007269DF</string> 
     391                                                                                        <string>0674616311120540007269DF</string> 
     392                                                                                        <string>0674616411120540007269DF</string> 
     393                                                                                        <string>0674616511120540007269DF</string> 
    440394                                                                                </array> 
    441395                                                                        </dict> 
     
    449403                                                        <dict> 
    450404                                                                <key>Frame</key> 
    451                                                                 <string>{{0, 441}, {941, 621}}</string> 
     405                                                                <string>{{0, 0}, {941, 768}}</string> 
    452406                                                                <key>RubberWindowFrame</key> 
    453                                                                 <string>83 70 1189 1108 0 0 1600 1178 </string> 
     407                                                                <string>66 70 1189 1108 0 0 1600 1178 </string> 
    454408                                                        </dict> 
    455409                                                        <key>Module</key> 
    456410                                                        <string>PBXNavigatorGroup</string> 
    457411                                                        <key>Proportion</key> 
    458                                                         <string>621pt</string> 
     412                                                        <string>768pt</string> 
     413                                                </dict> 
     414                                                <dict> 
     415                                                        <key>BecomeActive</key> 
     416                                                        <true/> 
     417                                                        <key>ContentConfiguration</key> 
     418                                                        <dict> 
     419                                                                <key>PBXProjectModuleGUID</key> 
     420                                                                <string>1CE0B20306471E060097A5F4</string> 
     421                                                                <key>PBXProjectModuleLabel</key> 
     422                                                                <string>MonteCarlo.h</string> 
     423                                                                <key>PBXSplitModuleInNavigatorKey</key> 
     424                                                                <dict> 
     425                                                                        <key>Split0</key> 
     426                                                                        <dict> 
     427                                                                                <key>PBXProjectModuleGUID</key> 
     428                                                                                <string>1CE0B20406471E060097A5F4</string> 
     429                                                                                <key>PBXProjectModuleLabel</key> 
     430                                                                                <string>MonteCarlo.h</string> 
     431                                                                                <key>_historyCapacity</key> 
     432                                                                                <integer>10</integer> 
     433                                                                                <key>bookmark</key> 
     434                                                                                <string>0674616E11120725007269DF</string> 
     435                                                                                <key>history</key> 
     436                                                                                <array> 
     437                                                                                        <string>06C8DCE60EA7D5DA00E49E7B</string> 
     438                                                                                        <string>06DA0F6C10D81F9400ACEE13</string> 
     439                                                                                        <string>06DA0F8810D8253900ACEE13</string> 
     440                                                                                        <string>06DA0FCA10D83CCB00ACEE13</string> 
     441                                                                                        <string>067461511111FE60007269DF</string> 
     442                                                                                        <string>0674616711120540007269DF</string> 
     443                                                                                        <string>0674616811120540007269DF</string> 
     444                                                                                </array> 
     445                                                                                <key>prevStack</key> 
     446                                                                                <array> 
     447                                                                                        <string>06C8DC810EA7CF3000E49E7B</string> 
     448                                                                                        <string>06C8DC820EA7CF3000E49E7B</string> 
     449                                                                                        <string>06C8DC850EA7CF3000E49E7B</string> 
     450                                                                                        <string>06C8DC860EA7CF3000E49E7B</string> 
     451                                                                                        <string>06863A561059483A003A0897</string> 
     452                                                                                        <string>06DA0F7410D81F9400ACEE13</string> 
     453                                                                                        <string>06DA0F8C10D8253900ACEE13</string> 
     454                                                                                        <string>0674616911120540007269DF</string> 
     455                                                                                </array> 
     456                                                                        </dict> 
     457                                                                        <key>SplitCount</key> 
     458                                                                        <string>1</string> 
     459                                                                </dict> 
     460                                                                <key>StatusBarVisibility</key> 
     461                                                                <true/> 
     462                                                        </dict> 
     463                                                        <key>GeometryConfiguration</key> 
     464                                                        <dict> 
     465                                                                <key>Frame</key> 
     466                                                                <string>{{0, 773}, {941, 290}}</string> 
     467                                                                <key>RubberWindowFrame</key> 
     468                                                                <string>66 70 1189 1108 0 0 1600 1178 </string> 
     469                                                        </dict> 
     470                                                        <key>Module</key> 
     471                                                        <string>PBXNavigatorGroup</string> 
     472                                                        <key>Proportion</key> 
     473                                                        <string>290pt</string> 
    459474                                                </dict> 
    460475                                                <dict> 
     
    469484                                                        <dict> 
    470485                                                                <key>Frame</key> 
    471                                                                 <string>{{0, 1067}, {941, 0}}</string> 
     486                                                                <string>{{0, 1068}, {941, 0}}</string> 
    472487                                                                <key>RubberWindowFrame</key> 
    473                                                                 <string>83 70 1189 1108 0 0 1600 1178 </string> 
     488                                                                <string>66 70 1189 1108 0 0 1600 1178 </string> 
    474489                                                        </dict> 
    475490                                                        <key>Module</key> 
     
    496511                        <key>TableOfContents</key> 
    497512                        <array> 
    498                                 <string>06BEBC1210A075AA00F47EA7</string> 
     513                                <string>0674616B11120540007269DF</string> 
    499514                                <string>1CE0B1FE06471DED0097A5F4</string> 
    500                                 <string>06BEBC1310A075AA00F47EA7</string> 
     515                                <string>0674616C11120540007269DF</string> 
    501516                                <string>1CE0B20306471E060097A5F4</string> 
    502517                                <string>1CE0B20306471E060097A5F4</string> 
     
    618633        <true/> 
    619634        <key>TimeStamp</key> 
    620         <real>278950944.97376198</real> 
     635        <real>286394149.518444</real> 
    621636        <key>ToolbarDisplayMode</key> 
    622637        <integer>1</integer> 
     
    633648        <key>WindowOrderList</key> 
    634649        <array> 
     650                <string>06C8DC6D0EA7CD4E00E49E7B</string> 
    635651                <string>/Users/srkline/IGOR_Programming/SVN/XOP_Dev/MonteCarlo/Xcode/MonteCarlo.xcodeproj</string> 
    636652        </array> 
    637653        <key>WindowString</key> 
    638         <string>83 70 1189 1108 0 0 1600 1178 </string> 
     654        <string>66 70 1189 1108 0 0 1600 1178 </string> 
    639655        <key>WindowTools</key> 
    640656        <array> 
     
    657673                                                                <string>1CD0528F0623707200166675</string> 
    658674                                                                <key>PBXProjectModuleLabel</key> 
    659                                                                 <string></string> 
     675                                                                <string>MonteCarlo.c</string> 
    660676                                                                <key>StatusBarVisibility</key> 
    661677                                                                <true/> 
     
    664680                                                        <dict> 
    665681                                                                <key>Frame</key> 
    666                                                                 <string>{{0, 0}, {1183, 461}}</string> 
     682                                                                <string>{{0, 0}, {1183, 288}}</string> 
    667683                                                                <key>RubberWindowFrame</key> 
    668684                                                                <string>62 412 1183 743 0 0 1600 1178 </string> 
     
    671687                                                        <string>PBXNavigatorGroup</string> 
    672688                                                        <key>Proportion</key> 
    673                                                         <string>461pt</string> 
     689                                                        <string>288pt</string> 
    674690                                                </dict> 
    675691                                                <dict> 
     
    678694                                                        <key>ContentConfiguration</key> 
    679695                                                        <dict> 
     696                                                                <key>PBXBuildLogShowsTranscriptDefaultKey</key> 
     697                                                                <string>{{0, 200}, {1183, 209}}</string> 
    680698                                                                <key>PBXProjectModuleGUID</key> 
    681699                                                                <string>XCMainBuildResultsModuleGUID</string> 
     
    690708                                                        <dict> 
    691709                                                                <key>Frame</key> 
    692                                                                 <string>{{0, 466}, {1183, 236}}</string> 
     710                                                                <string>{{0, 293}, {1183, 409}}</string> 
    693711                                                                <key>RubberWindowFrame</key> 
    694712                                                                <string>62 412 1183 743 0 0 1600 1178 </string> 
     
    697715                                                        <string>PBXBuildResultsModule</string> 
    698716                                                        <key>Proportion</key> 
    699                                                         <string>236pt</string> 
     717                                                        <string>409pt</string> 
    700718                                                </dict> 
    701719                                        </array> 
     
    715733                        <array> 
    716734                                <string>06C8DC6D0EA7CD4E00E49E7B</string> 
    717                                 <string>06628CBA1092201300F7FB01</string> 
     735                                <string>0674615E11120536007269DF</string> 
    718736                                <string>1CD0528F0623707200166675</string> 
    719737                                <string>XCMainBuildResultsModuleGUID</string> 
  • sans/XOP_Dev/MonteCarlo/Xcode/MonteCarlo.xcodeproj/srkline.pbxuser

    r591 r623  
    33        0651C06A0EDDC6E300823BAB /* MonteCarlo2.c */ = { 
    44                uiCtxt = { 
    5                         sepNavIntBoundsRect = "{{0, 0}, {900, 6622}}"; 
    6                         sepNavSelRange = "{1836, 6}"; 
    7                         sepNavVisRect = "{{0, 547}, {900, 404}}"; 
    8                 }; 
    9         }; 
    10         0651C0720EDDDEDD00823BAB /* PBXTextBookmark */ = { 
    11                 isa = PBXTextBookmark; 
    12                 fRef = 06C8DC600EA7CB1600E49E7B /* MonteCarlo.h */; 
    13                 name = "MonteCarlo.h: FindPixel"; 
    14                 rLen = 0; 
    15                 rLoc = 1185; 
    16                 rType = 0; 
    17                 vrLen = 1344; 
    18                 vrLoc = 225; 
    19         }; 
    20         0651C0730EDDDEDD00823BAB /* PBXTextBookmark */ = { 
     5                        sepNavIntBoundsRect = "{{0, 0}, {900, 18424}}"; 
     6                        sepNavSelRange = "{613, 4}"; 
     7                        sepNavVisRect = "{{0, 0}, {900, 736}}"; 
     8                }; 
     9        }; 
     10        067461511111FE60007269DF /* PBXTextBookmark */ = { 
     11                isa = PBXTextBookmark; 
     12                fRef = 06DA0F6710D81DD000ACEE13 /* DebyeSpheres.h */; 
     13                name = "DebyeSpheres.h: 8"; 
     14                rLen = 0; 
     15                rLoc = 125; 
     16                rType = 0; 
     17                vrLen = 301; 
     18                vrLoc = 442; 
     19        }; 
     20        067461531111FE60007269DF /* PBXTextBookmark */ = { 
     21                isa = PBXTextBookmark; 
     22                fRef = 06DA0F6710D81DD000ACEE13 /* DebyeSpheres.h */; 
     23                name = "DebyeSpheres.h: 8"; 
     24                rLen = 0; 
     25                rLoc = 125; 
     26                rType = 0; 
     27                vrLen = 301; 
     28                vrLoc = 442; 
     29        }; 
     30        0674615F11120540007269DF /* PBXTextBookmark */ = { 
     31                isa = PBXTextBookmark; 
     32                fRef = 06C8DC5F0EA7CB1600E49E7B /* MonteCarlo.c */; 
     33                name = "MonteCarlo.c: 805"; 
     34                rLen = 0; 
     35                rLoc = 22547; 
     36                rType = 0; 
     37                vrLen = 436; 
     38                vrLoc = 21164; 
     39        }; 
     40        0674616011120540007269DF /* PBXTextBookmark */ = { 
    2141                isa = PBXTextBookmark; 
    2242                fRef = AA53F5630587C7410055F2C1 /* MonteCarlo.r */; 
    23                 name = "MonteCarlo.r: 51"; 
    24                 rLen = 0; 
    25                 rLoc = 1288; 
    26                 rType = 0; 
    27                 vrLen = 1042; 
    28                 vrLoc = 601; 
    29         }; 
    30         06628CBB1092384D00F7FB01 /* PBXTextBookmark */ = { 
    31                 isa = PBXTextBookmark; 
    32                 fRef = 0651C06A0EDDC6E300823BAB /* MonteCarlo2.c */; 
    33                 name = "MonteCarlo2.c: 398"; 
    34                 rLen = 186; 
    35                 rLoc = 13752; 
    36                 rType = 0; 
    37                 vrLen = 1132; 
    38                 vrLoc = 15248; 
    39         }; 
    40         06628CBC1092384D00F7FB01 /* PBXTextBookmark */ = { 
    41                 isa = PBXTextBookmark; 
    42                 fRef = 06C8DC5F0EA7CB1600E49E7B /* MonteCarlo.c */; 
    43                 name = "MonteCarlo.c: 616"; 
    44                 rLen = 0; 
    45                 rLoc = 19155; 
    46                 rType = 0; 
    47                 vrLen = 603; 
    48                 vrLoc = 18736; 
    49         }; 
    50         06863A521059483A003A0897 /* PBXTextBookmark */ = { 
     43                name = "MonteCarlo.r: 92"; 
     44                rLen = 0; 
     45                rLoc = 2679; 
     46                rType = 0; 
     47                vrLen = 1511; 
     48                vrLoc = 1389; 
     49        }; 
     50        0674616111120540007269DF /* PBXTextBookmark */ = { 
    5151                isa = PBXTextBookmark; 
    5252                fRef = 0651C06A0EDDC6E300823BAB /* MonteCarlo2.c */; 
    5353                name = "MonteCarlo2.c: 378"; 
    5454                rLen = 0; 
    55                 rLoc = 13144; 
     55                rLoc = 12467; 
     56                rType = 0; 
     57                vrLen = 1966; 
     58                vrLoc = 11158; 
     59        }; 
     60        0674616211120540007269DF /* PBXTextBookmark */ = { 
     61                isa = PBXTextBookmark; 
     62                fRef = 06C8DC5F0EA7CB1600E49E7B /* MonteCarlo.c */; 
     63                name = "MonteCarlo.c: 700"; 
     64                rLen = 0; 
     65                rLoc = 20583; 
     66                rType = 0; 
     67                vrLen = 476; 
     68                vrLoc = 20486; 
     69        }; 
     70        0674616311120540007269DF /* PBXTextBookmark */ = { 
     71                isa = PBXTextBookmark; 
     72                fRef = 0651C06A0EDDC6E300823BAB /* MonteCarlo2.c */; 
     73                name = "MonteCarlo2.c: 378"; 
     74                rLen = 0; 
     75                rLoc = 12467; 
     76                rType = 0; 
     77                vrLen = 1071; 
     78                vrLoc = 11569; 
     79        }; 
     80        0674616411120540007269DF /* PBXTextBookmark */ = { 
     81                isa = PBXTextBookmark; 
     82                fRef = 06C8DC5F0EA7CB1600E49E7B /* MonteCarlo.c */; 
     83                name = "MonteCarlo.c: 805"; 
     84                rLen = 0; 
     85                rLoc = 22547; 
     86                rType = 0; 
     87                vrLen = 436; 
     88                vrLoc = 21164; 
     89        }; 
     90        0674616511120540007269DF /* PBXTextBookmark */ = { 
     91                isa = PBXTextBookmark; 
     92                fRef = AA53F5630587C7410055F2C1 /* MonteCarlo.r */; 
     93                name = "MonteCarlo.r: 92"; 
     94                rLen = 0; 
     95                rLoc = 2679; 
     96                rType = 0; 
     97                vrLen = 1511; 
     98                vrLoc = 1389; 
     99        }; 
     100        0674616711120540007269DF /* PBXTextBookmark */ = { 
     101                isa = PBXTextBookmark; 
     102                fRef = 06C8DC5F0EA7CB1600E49E7B /* MonteCarlo.c */; 
     103                name = "MonteCarlo.c: 683"; 
     104                rLen = 0; 
     105                rLoc = 22073; 
     106                rType = 0; 
     107                vrLen = 223; 
     108                vrLoc = 20252; 
     109        }; 
     110        0674616811120540007269DF /* PBXTextBookmark */ = { 
     111                isa = PBXTextBookmark; 
     112                fRef = 06C8DC600EA7CB1600E49E7B /* MonteCarlo.h */; 
     113                name = "MonteCarlo.h: 15"; 
     114                rLen = 0; 
     115                rLoc = 224; 
     116                rType = 0; 
     117                vrLen = 388; 
     118                vrLoc = 682; 
     119        }; 
     120        0674616911120540007269DF /* PBXTextBookmark */ = { 
     121                isa = PBXTextBookmark; 
     122                fRef = 06C8DC5F0EA7CB1600E49E7B /* MonteCarlo.c */; 
     123                name = "MonteCarlo.c: 683"; 
     124                rLen = 0; 
     125                rLoc = 22073; 
     126                rType = 0; 
     127                vrLen = 223; 
     128                vrLoc = 20252; 
     129        }; 
     130        0674616D11120725007269DF /* PBXTextBookmark */ = { 
     131                isa = PBXTextBookmark; 
     132                fRef = 0651C06A0EDDC6E300823BAB /* MonteCarlo2.c */; 
     133                name = ran1; 
     134                rLen = 4; 
     135                rLoc = 613; 
     136                rType = 0; 
     137                vrLen = 1853; 
     138                vrLoc = 0; 
     139        }; 
     140        0674616E11120725007269DF /* PBXTextBookmark */ = { 
     141                isa = PBXTextBookmark; 
     142                fRef = 06C8DC600EA7CB1600E49E7B /* MonteCarlo.h */; 
     143                name = "MonteCarlo.h: Monte_SANSX4"; 
     144                rLen = 0; 
     145                rLoc = 1253; 
     146                rType = 0; 
     147                vrLen = 643; 
     148                vrLoc = 991; 
     149        }; 
     150        06863A561059483A003A0897 /* PBXTextBookmark */ = { 
     151                isa = PBXTextBookmark; 
     152                fRef = 0651C06A0EDDC6E300823BAB /* MonteCarlo2.c */; 
     153                name = "MonteCarlo2.c: 378"; 
     154                rLen = 0; 
     155                rLoc = 12467; 
    56156                rType = 0; 
    57157                vrLen = 1374; 
    58158                vrLoc = 12385; 
    59         }; 
    60         06863A531059483A003A0897 /* PBXTextBookmark */ = { 
    61                 isa = PBXTextBookmark; 
    62                 fRef = AA53F5630587C7410055F2C1 /* MonteCarlo.r */; 
    63                 name = "MonteCarlo.r: 39"; 
    64                 rLen = 0; 
    65                 rLoc = 1027; 
    66                 rType = 0; 
    67                 vrLen = 1028; 
    68                 vrLoc = 601; 
    69         }; 
    70         06863A561059483A003A0897 /* PBXTextBookmark */ = { 
    71                 isa = PBXTextBookmark; 
    72                 fRef = 0651C06A0EDDC6E300823BAB /* MonteCarlo2.c */; 
    73                 name = "MonteCarlo2.c: 378"; 
    74                 rLen = 0; 
    75                 rLoc = 13144; 
    76                 rType = 0; 
    77                 vrLen = 1374; 
    78                 vrLoc = 12385; 
    79         }; 
    80         06BEBC1010A075AA00F47EA7 /* PBXTextBookmark */ = { 
    81                 isa = PBXTextBookmark; 
    82                 fRef = 0651C06A0EDDC6E300823BAB /* MonteCarlo2.c */; 
    83                 name = result; 
    84                 rLen = 6; 
    85                 rLoc = 1836; 
    86                 rType = 0; 
    87                 vrLen = 1016; 
    88                 vrLoc = 1294; 
    89         }; 
    90         06BEBC1110A075AA00F47EA7 /* PBXTextBookmark */ = { 
    91                 isa = PBXTextBookmark; 
    92                 fRef = 06C8DC5F0EA7CB1600E49E7B /* MonteCarlo.c */; 
    93                 name = "MonteCarlo.c: 27"; 
    94                 rLen = 0; 
    95                 rLoc = 739; 
    96                 rType = 0; 
    97                 vrLen = 1608; 
    98                 vrLoc = 380; 
    99159        }; 
    100160        06C8DBF40EA7B37900E49E7B /* Source Control */ = { 
     
    112172        06C8DC5F0EA7CB1600E49E7B /* MonteCarlo.c */ = { 
    113173                uiCtxt = { 
    114                         sepNavIntBoundsRect = "{{0, 0}, {1004, 10346}}"; 
    115                         sepNavSelRange = "{739, 0}"; 
    116                         sepNavVisRect = "{{0, 203}, {900, 589}}"; 
     174                        sepNavIntBoundsRect = "{{0, 0}, {1142, 11872}}"; 
     175                        sepNavSelRange = "{22498, 31}"; 
     176                        sepNavVisRect = "{{0, 11136}, {1142, 256}}"; 
    117177                }; 
    118178        }; 
    119179        06C8DC600EA7CB1600E49E7B /* MonteCarlo.h */ = { 
    120180                uiCtxt = { 
    121                         sepNavIntBoundsRect = "{{0, 0}, {900, 840}}"; 
    122                         sepNavSelRange = "{1185, 0}"; 
    123                         sepNavVisRect = "{{0, 211}, {900, 615}}"; 
     181                        sepNavIntBoundsRect = "{{0, 0}, {900, 896}}"; 
     182                        sepNavSelRange = "{1253, 0}"; 
     183                        sepNavVisRect = "{{0, 610}, {900, 258}}"; 
    124184                }; 
    125185        }; 
     
    180240                vrLoc = 0; 
    181241        }; 
    182         06C8DD2B0EA7E5C900E49E7B /* PBXTextBookmark */ = { 
    183                 isa = PBXTextBookmark; 
    184                 fRef = 06C8DC5F0EA7CB1600E49E7B /* MonteCarlo.c */; 
    185                 name = "MonteCarlo.c: 48"; 
    186                 rLen = 0; 
    187                 rLoc = 1963; 
    188                 rType = 0; 
    189                 vrLen = 676; 
    190                 vrLoc = 3322; 
    191         }; 
    192         06FC64500EBF4BDA00F1F7E9 /* PBXTextBookmark */ = { 
     242        06DA0F6610D81DD000ACEE13 /* DebyeSpheres.c */ = { 
     243                uiCtxt = { 
     244                        sepNavIntBoundsRect = "{{0, 0}, {900, 1974}}"; 
     245                        sepNavSelRange = "{1804, 0}"; 
     246                        sepNavVisRect = "{{0, 948}, {900, 807}}"; 
     247                }; 
     248        }; 
     249        06DA0F6710D81DD000ACEE13 /* DebyeSpheres.h */ = { 
     250                uiCtxt = { 
     251                        sepNavIntBoundsRect = "{{0, 0}, {900, 392}}"; 
     252                        sepNavSelRange = "{125, 0}"; 
     253                        sepNavVisRect = "{{0, 210}, {900, 117}}"; 
     254                }; 
     255        }; 
     256        06DA0F6C10D81F9400ACEE13 /* PBXTextBookmark */ = { 
     257                isa = PBXTextBookmark; 
     258                fRef = AA53F5630587C7410055F2C1 /* MonteCarlo.r */; 
     259                name = "MonteCarlo.r: 51"; 
     260                rLen = 0; 
     261                rLoc = 1285; 
     262                rType = 0; 
     263                vrLen = 1138; 
     264                vrLoc = 1100; 
     265        }; 
     266        06DA0F7410D81F9400ACEE13 /* PBXTextBookmark */ = { 
     267                isa = PBXTextBookmark; 
     268                fRef = 06DA0F6710D81DD000ACEE13 /* DebyeSpheres.h */; 
     269                name = "DebyeSpheres.h: 11"; 
     270                rLen = 0; 
     271                rLoc = 157; 
     272                rType = 0; 
     273                vrLen = 777; 
     274                vrLoc = 0; 
     275        }; 
     276        06DA0F8810D8253900ACEE13 /* PBXTextBookmark */ = { 
     277                isa = PBXTextBookmark; 
     278                fRef = 0651C06A0EDDC6E300823BAB /* MonteCarlo2.c */; 
     279                name = "MonteCarlo2.c: 378"; 
     280                rLen = 0; 
     281                rLoc = 12467; 
     282                rType = 0; 
     283                vrLen = 2660; 
     284                vrLoc = 11569; 
     285        }; 
     286        06DA0F8C10D8253900ACEE13 /* PBXTextBookmark */ = { 
     287                isa = PBXTextBookmark; 
     288                fRef = 06DA0F6610D81DD000ACEE13 /* DebyeSpheres.c */; 
     289                name = "DebyeSpheres.c: 192"; 
     290                rLen = 0; 
     291                rLoc = 2328; 
     292                rType = 0; 
     293                vrLen = 0; 
     294                vrLoc = 3284; 
     295        }; 
     296        06DA0FC910D83CCB00ACEE13 /* PBXTextBookmark */ = { 
    193297                isa = PBXTextBookmark; 
    194298                fRef = 06C8DC600EA7CB1600E49E7B /* MonteCarlo.h */; 
    195                 name = "MonteCarlo.h: Monte_SANSX2"; 
    196                 rLen = 0; 
    197                 rLoc = 1203; 
    198                 rType = 0; 
    199                 vrLen = 1535; 
     299                name = "MonteCarlo.h: 15"; 
     300                rLen = 0; 
     301                rLoc = 224; 
     302                rType = 0; 
     303                vrLen = 1093; 
     304                vrLoc = 476; 
     305        }; 
     306        06DA0FCA10D83CCB00ACEE13 /* PBXTextBookmark */ = { 
     307                isa = PBXTextBookmark; 
     308                fRef = 06DA0F6610D81DD000ACEE13 /* DebyeSpheres.c */; 
     309                name = "DebyeSpheres.c: 19"; 
     310                rLen = 0; 
     311                rLoc = 452; 
     312                rType = 0; 
     313                vrLen = 1169; 
    200314                vrLoc = 0; 
    201315        }; 
    202316        089C1669FE841209C02AAC07 /* Project object */ = { 
    203                 activeBuildConfigurationName = Default; 
     317                activeBuildConfigurationName = Release; 
    204318                activeBuildStyle = 4F9091AC011F3BD104CA0E50 /* Development */; 
    205319                activeTarget = 8D01CCC60486CAD60068D4B7 /* MonteCarlo */; 
     
    256370                                ); 
    257371                        }; 
    258                         PBXPerProjectTemplateStateSaveDate = 278950944; 
    259                         PBXWorkspaceStateSaveDate = 278950944; 
     372                        PBXPerProjectTemplateStateSaveDate = 286391858; 
     373                        PBXWorkspaceStateSaveDate = 286391858; 
    260374                }; 
    261375                perUserProjectItems = { 
    262                         0651C0720EDDDEDD00823BAB /* PBXTextBookmark */ = 0651C0720EDDDEDD00823BAB /* PBXTextBookmark */; 
    263                         0651C0730EDDDEDD00823BAB /* PBXTextBookmark */ = 0651C0730EDDDEDD00823BAB /* PBXTextBookmark */; 
    264                         06628CBB1092384D00F7FB01 /* PBXTextBookmark */ = 06628CBB1092384D00F7FB01 /* PBXTextBookmark */; 
    265                         06628CBC1092384D00F7FB01 /* PBXTextBookmark */ = 06628CBC1092384D00F7FB01 /* PBXTextBookmark */; 
    266                         06863A521059483A003A0897 /* PBXTextBookmark */ = 06863A521059483A003A0897 /* PBXTextBookmark */; 
    267                         06863A531059483A003A0897 /* PBXTextBookmark */ = 06863A531059483A003A0897 /* PBXTextBookmark */; 
     376                        067461511111FE60007269DF /* PBXTextBookmark */ = 067461511111FE60007269DF /* PBXTextBookmark */; 
     377                        067461531111FE60007269DF /* PBXTextBookmark */ = 067461531111FE60007269DF /* PBXTextBookmark */; 
     378                        0674615F11120540007269DF /* PBXTextBookmark */ = 0674615F11120540007269DF /* PBXTextBookmark */; 
     379                        0674616011120540007269DF /* PBXTextBookmark */ = 0674616011120540007269DF /* PBXTextBookmark */; 
     380                        0674616111120540007269DF /* PBXTextBookmark */ = 0674616111120540007269DF /* PBXTextBookmark */; 
     381                        0674616211120540007269DF /* PBXTextBookmark */ = 0674616211120540007269DF /* PBXTextBookmark */; 
     382                        0674616311120540007269DF /* PBXTextBookmark */ = 0674616311120540007269DF /* PBXTextBookmark */; 
     383                        0674616411120540007269DF /* PBXTextBookmark */ = 0674616411120540007269DF /* PBXTextBookmark */; 
     384                        0674616511120540007269DF /* PBXTextBookmark */ = 0674616511120540007269DF /* PBXTextBookmark */; 
     385                        0674616711120540007269DF /* PBXTextBookmark */ = 0674616711120540007269DF /* PBXTextBookmark */; 
     386                        0674616811120540007269DF /* PBXTextBookmark */ = 0674616811120540007269DF /* PBXTextBookmark */; 
     387                        0674616911120540007269DF /* PBXTextBookmark */ = 0674616911120540007269DF /* PBXTextBookmark */; 
     388                        0674616D11120725007269DF /* PBXTextBookmark */ = 0674616D11120725007269DF /* PBXTextBookmark */; 
     389                        0674616E11120725007269DF /* PBXTextBookmark */ = 0674616E11120725007269DF /* PBXTextBookmark */; 
    268390                        06863A561059483A003A0897 /* PBXTextBookmark */ = 06863A561059483A003A0897 /* PBXTextBookmark */; 
    269                         06BEBC1010A075AA00F47EA7 /* PBXTextBookmark */ = 06BEBC1010A075AA00F47EA7 /* PBXTextBookmark */; 
    270                         06BEBC1110A075AA00F47EA7 /* PBXTextBookmark */ = 06BEBC1110A075AA00F47EA7 /* PBXTextBookmark */; 
    271391                        06C8DC810EA7CF3000E49E7B /* PBXTextBookmark */ = 06C8DC810EA7CF3000E49E7B /* PBXTextBookmark */; 
    272392                        06C8DC820EA7CF3000E49E7B /* PBXTextBookmark */ = 06C8DC820EA7CF3000E49E7B /* PBXTextBookmark */; 
     
    274394                        06C8DC860EA7CF3000E49E7B /* PBXTextBookmark */ = 06C8DC860EA7CF3000E49E7B /* PBXTextBookmark */; 
    275395                        06C8DCE60EA7D5DA00E49E7B /* PBXTextBookmark */ = 06C8DCE60EA7D5DA00E49E7B /* PBXTextBookmark */; 
    276                         06C8DD2B0EA7E5C900E49E7B /* PBXTextBookmark */ = 06C8DD2B0EA7E5C900E49E7B /* PBXTextBookmark */; 
    277                         06FC64500EBF4BDA00F1F7E9 /* PBXTextBookmark */ = 06FC64500EBF4BDA00F1F7E9 /* PBXTextBookmark */; 
     396                        06DA0F6C10D81F9400ACEE13 /* PBXTextBookmark */ = 06DA0F6C10D81F9400ACEE13 /* PBXTextBookmark */; 
     397                        06DA0F7410D81F9400ACEE13 /* PBXTextBookmark */ = 06DA0F7410D81F9400ACEE13 /* PBXTextBookmark */; 
     398                        06DA0F8810D8253900ACEE13 /* PBXTextBookmark */ = 06DA0F8810D8253900ACEE13 /* PBXTextBookmark */; 
     399                        06DA0F8C10D8253900ACEE13 /* PBXTextBookmark */ = 06DA0F8C10D8253900ACEE13 /* PBXTextBookmark */; 
     400                        06DA0FC910D83CCB00ACEE13 /* PBXTextBookmark */ = 06DA0FC910D83CCB00ACEE13 /* PBXTextBookmark */; 
     401                        06DA0FCA10D83CCB00ACEE13 /* PBXTextBookmark */ = 06DA0FCA10D83CCB00ACEE13 /* PBXTextBookmark */; 
    278402                }; 
    279403                sourceControlManager = 06C8DBF40EA7B37900E49E7B /* Source Control */; 
     
    281405                }; 
    282406        }; 
     407        089C167EFE841241C02AAC07 /* English */ = { 
     408                uiCtxt = { 
     409                        sepNavIntBoundsRect = "{{0, 0}, {1142, 429}}"; 
     410                        sepNavSelRange = "{0, 0}"; 
     411                        sepNavVisRect = "{{0, 0}, {1142, 429}}"; 
     412                }; 
     413        }; 
    283414        32BAE0B30371A71500C91783 /* MonteCarlo_Prefix.pch */ = { 
    284415                uiCtxt = { 
    285                         sepNavIntBoundsRect = "{{0, 0}, {919, 726}}"; 
     416                        sepNavIntBoundsRect = "{{0, 0}, {900, 488}}"; 
    286417                        sepNavSelRange = "{128, 0}"; 
    287                         sepNavVisRect = "{{0, 0}, {919, 726}}"; 
     418                        sepNavVisRect = "{{0, 0}, {900, 488}}"; 
    288419                        sepNavWindowFrame = "{{15, 268}, {937, 905}}"; 
    289420                }; 
     
    294425        AA53F5630587C7410055F2C1 /* MonteCarlo.r */ = { 
    295426                uiCtxt = { 
    296                         sepNavIntBoundsRect = "{{0, 0}, {900, 938}}"; 
    297                         sepNavSelRange = "{1027, 0}"; 
    298                         sepNavVisRect = "{{0, 329}, {900, 535}}"; 
     427                        sepNavIntBoundsRect = "{{0, 0}, {900, 1512}}"; 
     428                        sepNavSelRange = "{2679, 0}"; 
     429                        sepNavVisRect = "{{0, 729}, {900, 643}}"; 
    299430                }; 
    300431        }; 
Note: See TracChangeset for help on using the changeset viewer.