Changeset 231


Ignore:
Timestamp:
Jan 8, 2008 5:15:47 PM (13 years ago)
Author:
srkline
Message:

EXTENSIVE changes to the XOP.

DANSE code has been directly incorporated into our libSANSAnalysis. Maybe not the cleanest way it Mathieu changes much in his code, but hopefully not too much of a mess.

Our old libFunc2D.c(.h) has been deleted (and replaced with multiple files of Mathieu's code, danse.h has the "exported" functions that we want
-note that there are some overlapping file names, (like cylinder.c), but they belong to different targets.

In our XOP, Func2D has the XOP wrappers to the 2D functions in danse.h

so far, works only for Mac. Still needs to be ported to WIN. Lots more entries in SANSAnalysis.c(.r)

Location:
sans/Analysis/branches/ajj_23APR07/XOPs/SANSAnalysis
Files:
28 added
2 deleted
8 edited

Legend:

Unmodified
Added
Removed
  • sans/Analysis/branches/ajj_23APR07/XOPs/SANSAnalysis/XCode/SANSAnalysis.xcodeproj/project.pbxproj

    r157 r231  
    3333                0530624C0BDE9E4D00578444 /* sphereform in CopyFiles */ = {isa = PBXBuildFile; fileRef = 053062400BDE9DC800578444 /* sphereform */; }; 
    3434                058F35C80BDD341100D07487 /* libXOPSupport.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 058F35C70BDD341100D07487 /* libXOPSupport.a */; }; 
    35                 05D47DBC0BF1FFD000335CA7 /* libFunc2D.h in Headers */ = {isa = PBXBuildFile; fileRef = 05D47DBA0BF1FFCF00335CA7 /* libFunc2D.h */; }; 
    36                 05D47DBD0BF1FFD000335CA7 /* libFunc2D.c in Sources */ = {isa = PBXBuildFile; fileRef = 05D47DBB0BF1FFD000335CA7 /* libFunc2D.c */; }; 
    3735                05D47DF80BF2029500335CA7 /* Func2D.c in Sources */ = {isa = PBXBuildFile; fileRef = 05D47DF60BF2029500335CA7 /* Func2D.c */; }; 
     36                068F1E4E0D32C52D004052EB /* c_disperser.c in Sources */ = {isa = PBXBuildFile; fileRef = 068F1E440D32C52D004052EB /* c_disperser.c */; }; 
     37                068F1E4F0D32C52D004052EB /* disp_core_shell_cylinder.c in Sources */ = {isa = PBXBuildFile; fileRef = 068F1E450D32C52D004052EB /* disp_core_shell_cylinder.c */; }; 
     38                068F1E500D32C52D004052EB /* disp_cylinder.c in Sources */ = {isa = PBXBuildFile; fileRef = 068F1E460D32C52D004052EB /* disp_cylinder.c */; }; 
     39                068F1E510D32C52D004052EB /* disp_ellipsoid.c in Sources */ = {isa = PBXBuildFile; fileRef = 068F1E470D32C52D004052EB /* disp_ellipsoid.c */; }; 
     40                068F1E520D32C52D004052EB /* disp_elliptical_cylinder.c in Sources */ = {isa = PBXBuildFile; fileRef = 068F1E480D32C52D004052EB /* disp_elliptical_cylinder.c */; }; 
     41                068F1E530D32C52D004052EB /* erf.c in Sources */ = {isa = PBXBuildFile; fileRef = 068F1E490D32C52D004052EB /* erf.c */; }; 
     42                068F1E540D32C52D004052EB /* weighted_core_shell_cylinder.c in Sources */ = {isa = PBXBuildFile; fileRef = 068F1E4A0D32C52D004052EB /* weighted_core_shell_cylinder.c */; }; 
     43                068F1E550D32C52D004052EB /* weighted_cylinder.c in Sources */ = {isa = PBXBuildFile; fileRef = 068F1E4B0D32C52D004052EB /* weighted_cylinder.c */; }; 
     44                068F1E560D32C52D004052EB /* weighted_ellipsoid.c in Sources */ = {isa = PBXBuildFile; fileRef = 068F1E4C0D32C52D004052EB /* weighted_ellipsoid.c */; }; 
     45                068F1E570D32C52D004052EB /* weighted_elliptical_cylinder.c in Sources */ = {isa = PBXBuildFile; fileRef = 068F1E4D0D32C52D004052EB /* weighted_elliptical_cylinder.c */; }; 
     46                068F1EB00D3403A2004052EB /* core_shell.c in Sources */ = {isa = PBXBuildFile; fileRef = 068F1E9A0D3403A2004052EB /* core_shell.c */; }; 
     47                068F1EB10D3403A2004052EB /* core_shell.h in Headers */ = {isa = PBXBuildFile; fileRef = 068F1E9B0D3403A2004052EB /* core_shell.h */; }; 
     48                068F1EB20D3403A2004052EB /* core_shell_cylinder.c in Sources */ = {isa = PBXBuildFile; fileRef = 068F1E9C0D3403A2004052EB /* core_shell_cylinder.c */; }; 
     49                068F1EB30D3403A2004052EB /* core_shell_cylinder.h in Headers */ = {isa = PBXBuildFile; fileRef = 068F1E9D0D3403A2004052EB /* core_shell_cylinder.h */; }; 
     50                068F1EB50D3403A2004052EB /* cylinder.c in Sources */ = {isa = PBXBuildFile; fileRef = 068F1E9F0D3403A2004052EB /* cylinder.c */; }; 
     51                068F1EB60D3403A2004052EB /* cylinder.h in Headers */ = {isa = PBXBuildFile; fileRef = 068F1EA00D3403A2004052EB /* cylinder.h */; }; 
     52                068F1EB80D3403A2004052EB /* ellipsoid.c in Sources */ = {isa = PBXBuildFile; fileRef = 068F1EA20D3403A2004052EB /* ellipsoid.c */; }; 
     53                068F1EB90D3403A2004052EB /* ellipsoid.h in Headers */ = {isa = PBXBuildFile; fileRef = 068F1EA30D3403A2004052EB /* ellipsoid.h */; }; 
     54                068F1EBA0D3403A2004052EB /* elliptical_cylinder.c in Sources */ = {isa = PBXBuildFile; fileRef = 068F1EA40D3403A2004052EB /* elliptical_cylinder.c */; }; 
     55                068F1EBB0D3403A2004052EB /* elliptical_cylinder.h in Headers */ = {isa = PBXBuildFile; fileRef = 068F1EA50D3403A2004052EB /* elliptical_cylinder.h */; }; 
     56                068F1EBD0D3403A2004052EB /* sphere.c in Sources */ = {isa = PBXBuildFile; fileRef = 068F1EA70D3403A2004052EB /* sphere.c */; }; 
     57                068F1EBE0D3403A2004052EB /* sphere.h in Headers */ = {isa = PBXBuildFile; fileRef = 068F1EA80D3403A2004052EB /* sphere.h */; }; 
     58                068F1EC20D3403B0004052EB /* c_disperser.h in Headers */ = {isa = PBXBuildFile; fileRef = 068F1EC00D3403B0004052EB /* c_disperser.h */; }; 
     59                068F1EC30D3403B0004052EB /* danse.h in Headers */ = {isa = PBXBuildFile; fileRef = 068F1EC10D3403B0004052EB /* danse.h */; }; 
    3860                8D01CCCA0486CAD60068D4B7 /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = 089C167DFE841241C02AAC07 /* InfoPlist.strings */; }; 
    3961                8D01CCCE0486CAD60068D4B7 /* Carbon.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 08EA7FFBFE8413EDC02AAC07 /* Carbon.framework */; }; 
     
    118140                05305EF00BDDB5DD00578444 /* GaussWeights.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = GaussWeights.h; path = ../lib/GaussWeights.h; sourceTree = SOURCE_ROOT; }; 
    119141                053061090BDE78A200578444 /* libSANSAnalysis.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = libSANSAnalysis.h; path = ../lib/libSANSAnalysis.h; sourceTree = SOURCE_ROOT; }; 
    120                 053062400BDE9DC800578444 /* sphereform */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = sphereform; sourceTree = BUILT_PRODUCTS_DIR; }; 
     142                053062400BDE9DC800578444 /* sphereform */ = {isa = PBXFileReference; includeInIndex = 0; lastKnownFileType = "compiled.mach-o.executable"; path = sphereform; sourceTree = BUILT_PRODUCTS_DIR; }; 
    121143                053062460BDE9DFF00578444 /* sphereform.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = sphereform.c; path = ../test/sphereform.c; sourceTree = SOURCE_ROOT; }; 
    122144                058F35C70BDD341100D07487 /* libXOPSupport.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libXOPSupport.a; path = /Users/srkline/IGOR_Programming/XOP_Toolkit_5/IgorXOPs5/XOPSupport/Xcode/libXOPSupport.a; sourceTree = "<absolute>"; }; 
    123                 05D47DBA0BF1FFCF00335CA7 /* libFunc2D.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = libFunc2D.h; path = ../lib/libFunc2D.h; sourceTree = SOURCE_ROOT; }; 
    124                 05D47DBB0BF1FFD000335CA7 /* libFunc2D.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = libFunc2D.c; path = ../lib/libFunc2D.c; sourceTree = SOURCE_ROOT; }; 
    125145                05D47DF60BF2029500335CA7 /* Func2D.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = Func2D.c; path = ../XOP/Func2D.c; sourceTree = SOURCE_ROOT; }; 
    126146                05D47EBF0BF20EF700335CA7 /* Func2D.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = Func2D.h; path = ../XOP/Func2D.h; sourceTree = SOURCE_ROOT; }; 
     147                068F1E440D32C52D004052EB /* c_disperser.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; path = c_disperser.c; sourceTree = "<group>"; }; 
     148                068F1E450D32C52D004052EB /* disp_core_shell_cylinder.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; path = disp_core_shell_cylinder.c; sourceTree = "<group>"; }; 
     149                068F1E460D32C52D004052EB /* disp_cylinder.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; path = disp_cylinder.c; sourceTree = "<group>"; }; 
     150                068F1E470D32C52D004052EB /* disp_ellipsoid.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; path = disp_ellipsoid.c; sourceTree = "<group>"; }; 
     151                068F1E480D32C52D004052EB /* disp_elliptical_cylinder.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; path = disp_elliptical_cylinder.c; sourceTree = "<group>"; }; 
     152                068F1E490D32C52D004052EB /* erf.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; path = erf.c; sourceTree = "<group>"; }; 
     153                068F1E4A0D32C52D004052EB /* weighted_core_shell_cylinder.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; path = weighted_core_shell_cylinder.c; sourceTree = "<group>"; }; 
     154                068F1E4B0D32C52D004052EB /* weighted_cylinder.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; path = weighted_cylinder.c; sourceTree = "<group>"; }; 
     155                068F1E4C0D32C52D004052EB /* weighted_ellipsoid.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; path = weighted_ellipsoid.c; sourceTree = "<group>"; }; 
     156                068F1E4D0D32C52D004052EB /* weighted_elliptical_cylinder.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; path = weighted_elliptical_cylinder.c; sourceTree = "<group>"; }; 
     157                068F1E9A0D3403A2004052EB /* core_shell.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; path = core_shell.c; sourceTree = "<group>"; }; 
     158                068F1E9B0D3403A2004052EB /* core_shell.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = core_shell.h; sourceTree = "<group>"; }; 
     159                068F1E9C0D3403A2004052EB /* core_shell_cylinder.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; path = core_shell_cylinder.c; sourceTree = "<group>"; }; 
     160                068F1E9D0D3403A2004052EB /* core_shell_cylinder.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = core_shell_cylinder.h; sourceTree = "<group>"; }; 
     161                068F1E9F0D3403A2004052EB /* cylinder.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; path = cylinder.c; sourceTree = "<group>"; }; 
     162                068F1EA00D3403A2004052EB /* cylinder.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = cylinder.h; sourceTree = "<group>"; }; 
     163                068F1EA20D3403A2004052EB /* ellipsoid.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; path = ellipsoid.c; sourceTree = "<group>"; }; 
     164                068F1EA30D3403A2004052EB /* ellipsoid.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = ellipsoid.h; sourceTree = "<group>"; }; 
     165                068F1EA40D3403A2004052EB /* elliptical_cylinder.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; path = elliptical_cylinder.c; sourceTree = "<group>"; }; 
     166                068F1EA50D3403A2004052EB /* elliptical_cylinder.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = elliptical_cylinder.h; sourceTree = "<group>"; }; 
     167                068F1EA70D3403A2004052EB /* sphere.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; path = sphere.c; sourceTree = "<group>"; }; 
     168                068F1EA80D3403A2004052EB /* sphere.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = sphere.h; sourceTree = "<group>"; }; 
     169                068F1EC00D3403B0004052EB /* c_disperser.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = c_disperser.h; sourceTree = "<group>"; }; 
     170                068F1EC10D3403B0004052EB /* danse.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = danse.h; sourceTree = "<group>"; }; 
    127171                089C167EFE841241C02AAC07 /* English */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = English; path = English.lproj/InfoPlist.strings; sourceTree = "<group>"; }; 
    128172                08EA7FFBFE8413EDC02AAC07 /* Carbon.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Carbon.framework; path = /System/Library/Frameworks/Carbon.framework; sourceTree = "<absolute>"; }; 
     
    154198 
    155199/* Begin PBXGroup section */ 
    156                 089C166AFE841209C02AAC07 /* SANSAnalysis */ = { 
    157                         isa = PBXGroup; 
    158                         children = ( 
    159                                 08FB77ADFE841716C02AAC07 /* Source */, 
    160                                 089C167CFE841241C02AAC07 /* Resources */, 
    161                                 089C1671FE841209C02AAC07 /* External Frameworks and Libraries */, 
    162                                 19C28FB4FE9D528D11CA2CBB /* Products */, 
    163                         ); 
    164                         name = SANSAnalysis; 
    165                         sourceTree = "<group>"; 
    166                 }; 
    167                 089C1671FE841209C02AAC07 /* External Frameworks and Libraries */ = { 
    168                         isa = PBXGroup; 
    169                         children = ( 
    170                                 05305DF50BDDA45000578444 /* libSANSAnalysis.a */, 
    171                                 058F35C70BDD341100D07487 /* libXOPSupport.a */, 
    172                                 08EA7FFBFE8413EDC02AAC07 /* Carbon.framework */, 
    173                         ); 
    174                         name = "External Frameworks and Libraries"; 
    175                         sourceTree = "<group>"; 
    176                 }; 
    177                 089C167CFE841241C02AAC07 /* Resources */ = { 
    178                         isa = PBXGroup; 
    179                         children = ( 
    180                                 8D01CCD10486CAD60068D4B7 /* Info.plist */, 
    181                                 089C167DFE841241C02AAC07 /* InfoPlist.strings */, 
    182                         ); 
    183                         name = Resources; 
    184                         sourceTree = "<group>"; 
    185                 }; 
    186                 08FB77ADFE841716C02AAC07 /* Source */ = { 
    187                         isa = PBXGroup; 
    188                         children = ( 
    189                                 05D47EBF0BF20EF700335CA7 /* Func2D.h */, 
    190                                 053062460BDE9DFF00578444 /* sphereform.c */, 
    191                                 05305EF00BDDB5DD00578444 /* GaussWeights.h */, 
    192                                 05305CDC0BDD9D1A00578444 /* StandardHeaders.h */, 
    193                                 05305C7D0BDD79F500578444 /* libCylinder.c */, 
    194                                 05305C7E0BDD79F500578444 /* libCylinder.h */, 
    195                                 05305C7F0BDD79F500578444 /* libSphere.c */, 
    196                                 05305C800BDD79F500578444 /* libSphere.h */, 
    197                                 05305C810BDD79F500578444 /* libStructureFactor.c */, 
    198                                 05305C820BDD79F500578444 /* libStructureFactor.h */, 
    199                                 05305C830BDD79F500578444 /* libTwoPhase.c */, 
    200                                 05305C840BDD79F500578444 /* libTwoPhase.h */, 
     200                068F1E430D32C52D004052EB /* igor_wrapper_src */ = { 
     201                        isa = PBXGroup; 
     202                        children = ( 
     203                                068F1E440D32C52D004052EB /* c_disperser.c */, 
     204                                068F1E450D32C52D004052EB /* disp_core_shell_cylinder.c */, 
     205                                068F1E460D32C52D004052EB /* disp_cylinder.c */, 
     206                                068F1E470D32C52D004052EB /* disp_ellipsoid.c */, 
     207                                068F1E480D32C52D004052EB /* disp_elliptical_cylinder.c */, 
     208                                068F1E490D32C52D004052EB /* erf.c */, 
     209                                068F1E4A0D32C52D004052EB /* weighted_core_shell_cylinder.c */, 
     210                                068F1E4B0D32C52D004052EB /* weighted_cylinder.c */, 
     211                                068F1E4C0D32C52D004052EB /* weighted_ellipsoid.c */, 
     212                                068F1E4D0D32C52D004052EB /* weighted_elliptical_cylinder.c */, 
     213                        ); 
     214                        name = igor_wrapper_src; 
     215                        path = ../lib/DANSE/igor_wrapper_src; 
     216                        sourceTree = SOURCE_ROOT; 
     217                }; 
     218                068F1E920D3403A2004052EB /* c_extensions */ = { 
     219                        isa = PBXGroup; 
     220                        children = ( 
     221                                068F1E9A0D3403A2004052EB /* core_shell.c */, 
     222                                068F1E9B0D3403A2004052EB /* core_shell.h */, 
     223                                068F1E9C0D3403A2004052EB /* core_shell_cylinder.c */, 
     224                                068F1E9D0D3403A2004052EB /* core_shell_cylinder.h */, 
     225                                068F1E9F0D3403A2004052EB /* cylinder.c */, 
     226                                068F1EA00D3403A2004052EB /* cylinder.h */, 
     227                                068F1EA20D3403A2004052EB /* ellipsoid.c */, 
     228                                068F1EA30D3403A2004052EB /* ellipsoid.h */, 
     229                                068F1EA40D3403A2004052EB /* elliptical_cylinder.c */, 
     230                                068F1EA50D3403A2004052EB /* elliptical_cylinder.h */, 
     231                                068F1EA70D3403A2004052EB /* sphere.c */, 
     232                                068F1EA80D3403A2004052EB /* sphere.h */, 
     233                        ); 
     234                        name = c_extensions; 
     235                        path = ../lib/DANSE/c_extensions; 
     236                        sourceTree = SOURCE_ROOT; 
     237                }; 
     238                068F1EBF0D3403B0004052EB /* include */ = { 
     239                        isa = PBXGroup; 
     240                        children = ( 
     241                                068F1EC00D3403B0004052EB /* c_disperser.h */, 
     242                                068F1EC10D3403B0004052EB /* danse.h */, 
     243                        ); 
     244                        name = include; 
     245                        path = ../lib/DANSE/include; 
     246                        sourceTree = SOURCE_ROOT; 
     247                }; 
     248                06D661430D132F9D0025E5AA /* Source */ = { 
     249                        isa = PBXGroup; 
     250                        children = ( 
     251                                06D661510D13309E0025E5AA /* testing */, 
     252                                06D6614E0D1330600025E5AA /* libDANSE */, 
     253                                06D6614B0D13303B0025E5AA /* libSANS */, 
    201254                                05305C3B0BDD76E400578444 /* Cylinder.c */, 
    202255                                05305C3C0BDD76E400578444 /* Cylinder.h */, 
     
    213266                                05305C470BDD76E400578444 /* TwoPhase.h */, 
    214267                                32BAE0B30371A71500C91783 /* SANSAnalysis_Prefix.pch */, 
     268                                05D47DF60BF2029500335CA7 /* Func2D.c */, 
     269                                05D47EBF0BF20EF700335CA7 /* Func2D.h */, 
     270                        ); 
     271                        name = Source; 
     272                        sourceTree = "<group>"; 
     273                }; 
     274                06D6614B0D13303B0025E5AA /* libSANS */ = { 
     275                        isa = PBXGroup; 
     276                        children = ( 
    215277                                053061090BDE78A200578444 /* libSANSAnalysis.h */, 
    216                                 05D47DBA0BF1FFCF00335CA7 /* libFunc2D.h */, 
    217                                 05D47DBB0BF1FFD000335CA7 /* libFunc2D.c */, 
    218                                 05D47DF60BF2029500335CA7 /* Func2D.c */, 
    219                         ); 
    220                         name = Source; 
     278                                05305EF00BDDB5DD00578444 /* GaussWeights.h */, 
     279                                05305CDC0BDD9D1A00578444 /* StandardHeaders.h */, 
     280                                05305C7D0BDD79F500578444 /* libCylinder.c */, 
     281                                05305C7E0BDD79F500578444 /* libCylinder.h */, 
     282                                05305C7F0BDD79F500578444 /* libSphere.c */, 
     283                                05305C800BDD79F500578444 /* libSphere.h */, 
     284                                05305C810BDD79F500578444 /* libStructureFactor.c */, 
     285                                05305C820BDD79F500578444 /* libStructureFactor.h */, 
     286                                05305C830BDD79F500578444 /* libTwoPhase.c */, 
     287                                05305C840BDD79F500578444 /* libTwoPhase.h */, 
     288                        ); 
     289                        name = libSANS; 
     290                        sourceTree = "<group>"; 
     291                }; 
     292                06D6614E0D1330600025E5AA /* libDANSE */ = { 
     293                        isa = PBXGroup; 
     294                        children = ( 
     295                                068F1EBF0D3403B0004052EB /* include */, 
     296                                068F1E920D3403A2004052EB /* c_extensions */, 
     297                                068F1E430D32C52D004052EB /* igor_wrapper_src */, 
     298                        ); 
     299                        name = libDANSE; 
     300                        sourceTree = "<group>"; 
     301                }; 
     302                06D661510D13309E0025E5AA /* testing */ = { 
     303                        isa = PBXGroup; 
     304                        children = ( 
     305                                053062460BDE9DFF00578444 /* sphereform.c */, 
     306                        ); 
     307                        name = testing; 
     308                        sourceTree = "<group>"; 
     309                }; 
     310                089C166AFE841209C02AAC07 /* SANSAnalysis */ = { 
     311                        isa = PBXGroup; 
     312                        children = ( 
     313                                06D661430D132F9D0025E5AA /* Source */, 
     314                                089C167CFE841241C02AAC07 /* Resources */, 
     315                                089C1671FE841209C02AAC07 /* External Frameworks and Libraries */, 
     316                                19C28FB4FE9D528D11CA2CBB /* Products */, 
     317                        ); 
     318                        name = SANSAnalysis; 
     319                        sourceTree = "<group>"; 
     320                }; 
     321                089C1671FE841209C02AAC07 /* External Frameworks and Libraries */ = { 
     322                        isa = PBXGroup; 
     323                        children = ( 
     324                                05305DF50BDDA45000578444 /* libSANSAnalysis.a */, 
     325                                058F35C70BDD341100D07487 /* libXOPSupport.a */, 
     326                                08EA7FFBFE8413EDC02AAC07 /* Carbon.framework */, 
     327                        ); 
     328                        name = "External Frameworks and Libraries"; 
     329                        sourceTree = "<group>"; 
     330                }; 
     331                089C167CFE841241C02AAC07 /* Resources */ = { 
     332                        isa = PBXGroup; 
     333                        children = ( 
     334                                8D01CCD10486CAD60068D4B7 /* Info.plist */, 
     335                                089C167DFE841241C02AAC07 /* InfoPlist.strings */, 
     336                        ); 
     337                        name = Resources; 
    221338                        sourceTree = "<group>"; 
    222339                }; 
     
    245362                                05305EF10BDDB5DD00578444 /* GaussWeights.h in Headers */, 
    246363                                0530610A0BDE78A200578444 /* libSANSAnalysis.h in Headers */, 
    247                                 05D47DBC0BF1FFD000335CA7 /* libFunc2D.h in Headers */, 
     364                                068F1EB10D3403A2004052EB /* core_shell.h in Headers */, 
     365                                068F1EB30D3403A2004052EB /* core_shell_cylinder.h in Headers */, 
     366                                068F1EB60D3403A2004052EB /* cylinder.h in Headers */, 
     367                                068F1EB90D3403A2004052EB /* ellipsoid.h in Headers */, 
     368                                068F1EBB0D3403A2004052EB /* elliptical_cylinder.h in Headers */, 
     369                                068F1EBE0D3403A2004052EB /* sphere.h in Headers */, 
     370                                068F1EC20D3403B0004052EB /* c_disperser.h in Headers */, 
     371                                068F1EC30D3403B0004052EB /* danse.h in Headers */, 
    248372                        ); 
    249373                        runOnlyForDeploymentPostprocessing = 0; 
     
    360484                                05305C890BDD79F500578444 /* libStructureFactor.c in Sources */, 
    361485                                05305C8B0BDD79F500578444 /* libTwoPhase.c in Sources */, 
    362                                 05D47DBD0BF1FFD000335CA7 /* libFunc2D.c in Sources */, 
     486                                068F1E4E0D32C52D004052EB /* c_disperser.c in Sources */, 
     487                                068F1E4F0D32C52D004052EB /* disp_core_shell_cylinder.c in Sources */, 
     488                                068F1E500D32C52D004052EB /* disp_cylinder.c in Sources */, 
     489                                068F1E510D32C52D004052EB /* disp_ellipsoid.c in Sources */, 
     490                                068F1E520D32C52D004052EB /* disp_elliptical_cylinder.c in Sources */, 
     491                                068F1E530D32C52D004052EB /* erf.c in Sources */, 
     492                                068F1E540D32C52D004052EB /* weighted_core_shell_cylinder.c in Sources */, 
     493                                068F1E550D32C52D004052EB /* weighted_cylinder.c in Sources */, 
     494                                068F1E560D32C52D004052EB /* weighted_ellipsoid.c in Sources */, 
     495                                068F1E570D32C52D004052EB /* weighted_elliptical_cylinder.c in Sources */, 
     496                                068F1EB00D3403A2004052EB /* core_shell.c in Sources */, 
     497                                068F1EB20D3403A2004052EB /* core_shell_cylinder.c in Sources */, 
     498                                068F1EB50D3403A2004052EB /* cylinder.c in Sources */, 
     499                                068F1EB80D3403A2004052EB /* ellipsoid.c in Sources */, 
     500                                068F1EBA0D3403A2004052EB /* elliptical_cylinder.c in Sources */, 
     501                                068F1EBD0D3403A2004052EB /* sphere.c in Sources */, 
    363502                        ); 
    364503                        runOnlyForDeploymentPostprocessing = 0; 
     
    409548                                GCC_MODEL_TUNING = G5; 
    410549                                GCC_OPTIMIZATION_LEVEL = 0; 
     550                                HEADER_SEARCH_PATHS = ""; 
    411551                                INSTALL_PATH = /usr/local/lib; 
    412552                                PREBINDING = NO; 
    413553                                PRODUCT_NAME = libSANSAnalysis; 
     554                                USER_HEADER_SEARCH_PATHS = "/Users/srkline/IGOR_Programming/XOP_Toolkit_5/IgorXOPs5/XOPSupport  ../lib/DANSE/"; 
    414555                                ZERO_LINK = YES; 
    415556                        }; 
     
    426567                                GCC_ENABLE_FIX_AND_CONTINUE = YES; 
    427568                                GCC_MODEL_TUNING = G5; 
     569                                HEADER_SEARCH_PATHS = ""; 
    428570                                INSTALL_PATH = /usr/local/lib; 
    429571                                PREBINDING = NO; 
    430572                                PRODUCT_NAME = libSANSAnalysis; 
     573                                USER_HEADER_SEARCH_PATHS = "/Users/srkline/IGOR_Programming/XOP_Toolkit_5/IgorXOPs5/XOPSupport  ../lib/DANSE/"; 
    431574                                ZERO_LINK = NO; 
    432575                        }; 
     
    440583                                GCC_ENABLE_FIX_AND_CONTINUE = YES; 
    441584                                GCC_MODEL_TUNING = G5; 
     585                                HEADER_SEARCH_PATHS = ""; 
    442586                                INSTALL_PATH = /usr/local/lib; 
    443587                                PREBINDING = NO; 
    444588                                PRODUCT_NAME = libSANSAnalysis; 
     589                                USER_HEADER_SEARCH_PATHS = "/Users/srkline/IGOR_Programming/XOP_Toolkit_5/IgorXOPs5/XOPSupport  ../lib/DANSE/"; 
    445590                                ZERO_LINK = NO; 
    446591                        }; 
  • sans/Analysis/branches/ajj_23APR07/XOPs/SANSAnalysis/XOP/Func2D.c

    r196 r231  
    33 *  SANSAnalysis 
    44 * 
    5  *  Created by Andrew Jackson on 5/9/07. 
    6  *  Copyright 2007 __MyCompanyName__. All rights reserved. 
     5 * Steve Kline Jan 2008 
     6 * these are the XOP calls to DANSE 2D functions 
     7 * from the library supplied by M. Doucet 
    78 * 
    89 */ 
     
    1011 
    1112#include "XOPStandardHeaders.h"                 // Include ANSI headers, Mac headers, IgorXOP.h, XOP.h and XOPSupport.h 
    12 #include "SANSAnalysis.h" 
    13 #include "libSANSAnalysis.h" 
    14 #include "Func2D.h" 
    15  
    16 int 
    17 Cylinder_2D_Dist(FitParams2DPtr p) 
    18 { 
    19         double *dp; 
    20          
    21         float *fp;                              // Pointer to single precision wave data. 
    22         double qx; 
    23         double qy; 
    24         double q, phi; 
     13#include "SANSAnalysis.h"                               // structures, two-byte aligned 
     14#include "libSANSAnalysis.h"                    // functions from the libSANS    
     15#include "danse.h"                                              // functions from the DANSE part of libSANS 
     16#include <math.h> 
     17#include "Func2D.h"                                             // declarations for the 2D functions in this file 
     18 
     19int 
     20Cylinder_2D(FitParams2DPtr p) 
     21{ 
     22        double *dp; 
     23         
     24        float *fp;                              // Pointer to single precision wave data. 
     25        double qx; 
     26        double qy; 
     27        double q, phi; 
     28        double pars[11]; 
     29        int i; 
    2530//      char buf[256]; 
    2631         
     
    3540//      sprintf(buf, "Qx = %g, Qy = %g\r",qx, qy); 
    3641//      XOPNotice(buf); 
    37          
    38         q = hypot(qx,qy); 
    39         phi = atan2(qy,qx); 
    40          
    41         switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    42                 case NT_FP32: 
    43                         fp= WaveData(p->waveHandle); 
    44             SetNaN64(&p->result); 
    45                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
    46                 case NT_FP64: 
    47                         dp= WaveData(p->waveHandle); 
    48                         p->result = dist_cylinder_2D(dp,q,phi);                                                                                                                          
    49                         return 0; 
    50                 default:                                                                // We can't handle this wave data type. 
    51                         SetNaN64(&p->result); 
    52                         return REQUIRES_SP_OR_DP_WAVE; 
    53         } 
    54          
    55         return 0; 
    56 } 
     42 
     43        q = hypot(qx,qy); 
     44        phi = atan2(qy,qx); 
     45         
     46        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
     47                case NT_FP32: 
     48                        fp= WaveData(p->waveHandle); 
     49            SetNaN64(&p->result); 
     50                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
     51                case NT_FP64: 
     52                        dp= WaveData(p->waveHandle); 
     53                         
     54                        for(i=0; i<11; i++) { 
     55                                pars[i] = dp[i]; 
     56                        } 
     57 
     58                        p->result = disperse_cylinder_analytical_2D( pars, q, phi );  
     59                        return 0; 
     60                default:                                                                // We can't handle this wave data type. 
     61                        SetNaN64(&p->result); 
     62                        return REQUIRES_SP_OR_DP_WAVE; 
     63        } 
     64         
     65        return 0; 
     66} 
     67 
     68int 
     69Cylinder_2D_Weight2D(FitParams2DWeightPtr p) 
     70{ 
     71        double *dp; 
     72         
     73        float *fp;                              // Pointer to single precision wave data. 
     74        double qx; 
     75        double qy; 
     76        double q, phi; 
     77        double *par_values; 
     78        double *weight_values; 
     79        double pars[13]; 
     80        int i, i_theta; 
     81        double sum; 
     82        int n_slices; 
     83         
     84        if (p->waveHandle == NIL) { 
     85                SetNaN64(&p->result); 
     86                return NON_EXISTENT_WAVE; 
     87        } 
     88     
     89        qx = p->qx; 
     90        qy = p->qy; 
     91         
     92        q = hypot(qx,qy); 
     93        phi = atan2(qy,qx); 
     94         
     95        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
     96                case NT_FP32: 
     97                        fp= WaveData(p->waveHandle); 
     98            SetNaN64(&p->result); 
     99                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
     100                case NT_FP64: 
     101                        dp= WaveData(p->waveHandle); 
     102                        par_values = WaveData(p->par_values); 
     103                        weight_values = WaveData(p->weight_values); 
     104                         
     105                        for(i=0; i<13; i++) { 
     106                                pars[i] = dp[i]; 
     107                        } 
     108 
     109                        sum = 0.0; 
     110                        n_slices = (int)floor(dp[13]); 
     111 
     112                        //XOPOKAlert("test","This is a test"); 
     113 
     114                        if(n_slices == 0) { 
     115                                p->result =weight_dispersion( &disperse_cylinder_analytical_2D, 
     116                                                        par_values, weight_values,  
     117                                                        (int)floor(pars[11]), (int)floor(pars[12]), 
     118                                                        pars, q, phi );                  
     119                        } else { 
     120                                for(i_theta=0; i_theta<n_slices; i_theta++) { 
     121                                        SpinProcess(); 
     122                                        // average over theta 
     123                                         
     124                                        // For the cylinder model, theta_cyl=90 degrees 
     125                                        // will produce a NAN at phi_cyl=0 and 45 degrees 
     126                                        pars[5] = acos(-1.0)/n_slices * i_theta; 
     127                                        if( fabs(i_theta / n_slices) - 0.5 < 0.000001 ) { 
     128                                                //continue; 
     129                                                pars[5] += 0.00001; 
     130                                        } 
     131                                         
     132                                        // Multiply by sin(theta) because we are integrating in 
     133                                        // spherical coordinates 
     134                                        sum += sin(pars[5])* weight_dispersion( &disperse_cylinder_analytical_2D, 
     135                                                                par_values, weight_values,  
     136                                                                (int)floor(pars[11]), (int)floor(pars[12]), 
     137                                                                pars, q, phi );  
     138                                } 
     139                                 
     140                                p->result = sum/n_slices; 
     141                        } 
     142                         
     143                        return 0; 
     144                default:                                                                // We can't handle this wave data type. 
     145                        SetNaN64(&p->result); 
     146                        return REQUIRES_SP_OR_DP_WAVE; 
     147        } 
     148         
     149        return 0; 
     150} 
     151 
     152int 
     153CoreShellCylinder_2D(FitParams2DPtr p) 
     154{ 
     155        double *dp; 
     156         
     157        float *fp;                              // Pointer to single precision wave data. 
     158        double qx; 
     159        double qy; 
     160        double q, phi; 
     161        double pars[15]; 
     162        int i; 
     163         
     164        if (p->waveHandle == NIL) { 
     165                SetNaN64(&p->result); 
     166                return NON_EXISTENT_WAVE; 
     167        } 
     168     
     169        qx = p->qx; 
     170        qy = p->qy; 
     171         
     172        q = hypot(qx,qy); 
     173        phi = atan2(qy,qx); 
     174         
     175        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
     176                case NT_FP32: 
     177                        fp= WaveData(p->waveHandle); 
     178            SetNaN64(&p->result); 
     179                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
     180                case NT_FP64: 
     181                        dp= WaveData(p->waveHandle); 
     182                         
     183                        for(i=0; i<15; i++) { 
     184                                pars[i] = dp[i]; 
     185                        } 
     186 
     187                        p->result = disperse_core_shell_cylinder_analytical_2D( pars, q, phi );  
     188                        return 0; 
     189                default:                                                                // We can't handle this wave data type. 
     190                        SetNaN64(&p->result); 
     191                        return REQUIRES_SP_OR_DP_WAVE; 
     192        } 
     193         
     194        return 0; 
     195} 
     196 
     197int 
     198CoreShellCylinder_2D_Weight2D(FitParams2DWeightPtr p) 
     199{ 
     200        double *dp; 
     201         
     202        float *fp;                              // Pointer to single precision wave data. 
     203        double qx; 
     204        double qy; 
     205        double q, phi; 
     206        double *par_values; 
     207        double *weight_values; 
     208        double pars[17]; 
     209        int i, i_theta; 
     210        double sum; 
     211        int n_slices; 
     212         
     213        if (p->waveHandle == NIL) { 
     214                SetNaN64(&p->result); 
     215                return NON_EXISTENT_WAVE; 
     216        } 
     217     
     218        qx = p->qx; 
     219        qy = p->qy; 
     220         
     221        q = hypot(qx,qy); 
     222        phi = atan2(qy,qx); 
     223         
     224        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
     225                case NT_FP32: 
     226                        fp= WaveData(p->waveHandle); 
     227            SetNaN64(&p->result); 
     228                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
     229                case NT_FP64: 
     230                        dp= WaveData(p->waveHandle); 
     231                        par_values = WaveData(p->par_values); 
     232                        weight_values = WaveData(p->weight_values); 
     233                         
     234                        for(i=0; i<17; i++) { 
     235                                pars[i] = dp[i]; 
     236                        } 
     237 
     238                        sum = 0.0; 
     239                        n_slices = (int)floor(dp[17]); 
     240 
     241                        if(n_slices == 0) { 
     242                                p->result =weight_dispersion( &disperse_core_shell_cylinder_analytical_2D, 
     243                                                        par_values, weight_values,  
     244                                                        (int)floor(pars[15]), (int)floor(pars[16]), 
     245                                                        pars, q, phi );                  
     246                        } else { 
     247                                for(i_theta=0; i_theta<n_slices; i_theta++) { 
     248                                        SpinProcess(); 
     249                                        // average over theta 
     250                                         
     251                                        // For the cylinder model, theta_cyl=90 degrees 
     252                                        // will produce a NAN at phi_cyl=0 and 45 degrees 
     253                                        // TODO: integrate from 0 to pi/2 instead of 0 to pi 
     254                                        pars[8] = acos(-1.0)/n_slices * i_theta; 
     255                                        if( fabs(i_theta / n_slices) - 0.5 < 0.000001 ) { 
     256                                                //continue; 
     257                                                pars[8] += 0.00001; 
     258                                        } 
     259                                         
     260                                        // Multiply by sin(theta) because we are integrating in 
     261                                        // spherical coordinates 
     262                                        sum += sin(pars[8])* weight_dispersion( &disperse_core_shell_cylinder_analytical_2D, 
     263                                                                par_values, weight_values,  
     264                                                                (int)floor(pars[15]), (int)floor(pars[16]), 
     265                                                                pars, q, phi );  
     266                                } 
     267                                 
     268                                p->result = sum/n_slices; 
     269                        } 
     270                         
     271                        return 0; 
     272                default:                                                                // We can't handle this wave data type. 
     273                        SetNaN64(&p->result); 
     274                        return REQUIRES_SP_OR_DP_WAVE; 
     275        } 
     276         
     277        return 0; 
     278} 
     279 
     280int 
     281Ellipsoid_2D(FitParams2DPtr p) 
     282{ 
     283        double *dp; 
     284         
     285        float *fp;                              // Pointer to single precision wave data. 
     286        double qx; 
     287        double qy; 
     288        double q, phi; 
     289        double pars[12]; 
     290        int i; 
     291         
     292        if (p->waveHandle == NIL) { 
     293                SetNaN64(&p->result); 
     294                return NON_EXISTENT_WAVE; 
     295        } 
     296     
     297        qx = p->qx; 
     298        qy = p->qy; 
     299         
     300        q = hypot(qx,qy); 
     301        phi = atan2(qy,qx); 
     302         
     303        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
     304                case NT_FP32: 
     305                        fp= WaveData(p->waveHandle); 
     306            SetNaN64(&p->result); 
     307                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
     308                case NT_FP64: 
     309                        dp= WaveData(p->waveHandle); 
     310                         
     311                        for(i=0; i<12; i++) { 
     312                                pars[i] = dp[i]; 
     313                        } 
     314                        //p->result = 1.0; 
     315                        p->result = disperse_ellipsoid_analytical_2D( pars, q, phi );  
     316                        return 0; 
     317                default:                                                                // We can't handle this wave data type. 
     318                        SetNaN64(&p->result); 
     319                        return REQUIRES_SP_OR_DP_WAVE; 
     320        } 
     321         
     322        return 0; 
     323} 
     324 
     325int 
     326Ellipsoid_2D_Weight2D(FitParams2DWeightPtr p) 
     327{ 
     328        double *dp; 
     329         
     330        float *fp;                              // Pointer to single precision wave data. 
     331        double qx; 
     332        double qy; 
     333        double q, phi; 
     334        double *par_values; 
     335        double *weight_values; 
     336        double pars[14]; 
     337        int i, i_theta; 
     338        double sum; 
     339        int n_slices; 
     340         
     341        if (p->waveHandle == NIL) { 
     342                SetNaN64(&p->result); 
     343                return NON_EXISTENT_WAVE; 
     344        } 
     345     
     346        qx = p->qx; 
     347        qy = p->qy; 
     348         
     349        q = hypot(qx,qy); 
     350        phi = atan2(qy,qx); 
     351         
     352        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
     353                case NT_FP32: 
     354                        fp= WaveData(p->waveHandle); 
     355            SetNaN64(&p->result); 
     356                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
     357                case NT_FP64: 
     358                        dp= WaveData(p->waveHandle); 
     359                        par_values = WaveData(p->par_values); 
     360                        weight_values = WaveData(p->weight_values); 
     361                         
     362                        for(i=0; i<14; i++) { 
     363                                pars[i] = dp[i]; 
     364                        } 
     365 
     366                        sum = 0.0; 
     367                        n_slices = (int)floor(dp[14]); 
     368 
     369                        if(n_slices == 0) { 
     370                                p->result =weight_dispersion( &disperse_ellipsoid_analytical_2D, 
     371                                                        par_values, weight_values,  
     372                                                        (int)floor(pars[12]), (int)floor(pars[13]), 
     373                                                        pars, q, phi );                  
     374                        } else { 
     375                                for(i_theta=0; i_theta<n_slices; i_theta++) { 
     376                                        SpinProcess(); 
     377                                        // average over theta 
     378                                         
     379                                        // For the cylinder model, theta_cyl=90 degrees 
     380                                        // will produce a NAN at phi_cyl=0 and 45 degrees 
     381                                        pars[5] = acos(-1.0)/n_slices * i_theta; 
     382                                        if( fabs(i_theta / n_slices) - 0.5 < 0.000001 ) { 
     383                                                //continue; 
     384                                                pars[5] += 0.00001; 
     385                                        } 
     386                                         
     387                                        // Multiply by sin(theta) because we are integrating in 
     388                                        // spherical coordinates 
     389                                        sum += sin(pars[5])* weight_dispersion( &disperse_ellipsoid_analytical_2D, 
     390                                                                par_values, weight_values,  
     391                                                                (int)floor(pars[12]), (int)floor(pars[13]), 
     392                                                                pars, q, phi );  
     393                                } 
     394                                 
     395                                p->result = sum/n_slices; 
     396                        } 
     397                         
     398                        return 0; 
     399                default:                                                                // We can't handle this wave data type. 
     400                        SetNaN64(&p->result); 
     401                        return REQUIRES_SP_OR_DP_WAVE; 
     402        } 
     403         
     404        return 0; 
     405} 
     406 
     407 
     408int 
     409EllipticalCylinder_2D(FitParams2DPtr p) 
     410{ 
     411        double *dp; 
     412         
     413        float *fp;                              // Pointer to single precision wave data. 
     414        double qx; 
     415        double qy; 
     416        double q, phi; 
     417        double pars[14]; 
     418        int i; 
     419         
     420        if (p->waveHandle == NIL) { 
     421                SetNaN64(&p->result); 
     422                return NON_EXISTENT_WAVE; 
     423        } 
     424     
     425        qx = p->qx; 
     426        qy = p->qy; 
     427         
     428        q = hypot(qx,qy); 
     429        phi = atan2(qy,qx); 
     430         
     431        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
     432                case NT_FP32: 
     433                        fp= WaveData(p->waveHandle); 
     434            SetNaN64(&p->result); 
     435                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
     436                case NT_FP64: 
     437                        dp= WaveData(p->waveHandle); 
     438                         
     439                        for(i=0; i<14; i++) { 
     440                                pars[i] = dp[i]; 
     441                        } 
     442                        p->result = disperse_elliptical_cylinder_analytical_2D( pars, q, phi );  
     443                          
     444                        return 0; 
     445                default:                                                                // We can't handle this wave data type. 
     446                        SetNaN64(&p->result); 
     447                        return REQUIRES_SP_OR_DP_WAVE; 
     448        } 
     449         
     450        return 0; 
     451} 
     452 
     453int 
     454EllipticalCylinder_2D_Weight2D(FitParams2DWeightPtr p) 
     455{ 
     456        double *dp; 
     457         
     458        float *fp;                              // Pointer to single precision wave data. 
     459        double qx; 
     460        double qy; 
     461        double q, phi; 
     462        double *par_values; 
     463        double *weight_values; 
     464        double pars[16]; 
     465        int i, i_theta; 
     466        double sum; 
     467        int n_slices; 
     468         
     469        if (p->waveHandle == NIL) { 
     470                SetNaN64(&p->result); 
     471                return NON_EXISTENT_WAVE; 
     472        } 
     473     
     474        qx = p->qx; 
     475        qy = p->qy; 
     476         
     477        q = hypot(qx,qy); 
     478        phi = atan2(qy,qx); 
     479         
     480        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
     481                case NT_FP32: 
     482                        fp= WaveData(p->waveHandle); 
     483            SetNaN64(&p->result); 
     484                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
     485                case NT_FP64: 
     486                        dp= WaveData(p->waveHandle); 
     487                        par_values = WaveData(p->par_values); 
     488                        weight_values = WaveData(p->weight_values); 
     489                         
     490                        for(i=0; i<16; i++) { 
     491                                pars[i] = dp[i]; 
     492                        } 
     493 
     494                        sum = 0.0; 
     495                        n_slices = (int)floor(dp[16]); 
     496 
     497                        if(n_slices == 0) { 
     498                                p->result =weight_dispersion( &disperse_elliptical_cylinder_analytical_2D, 
     499                                                        par_values, weight_values,  
     500                                                        (int)floor(pars[14]), (int)floor(pars[15]), 
     501                                                        pars, q, phi );                  
     502                        } else { 
     503                                for(i_theta=0; i_theta<n_slices; i_theta++) { 
     504                                        SpinProcess(); 
     505                                        // average over theta 
     506                                         
     507                                        // For the cylinder model, theta_cyl=90 degrees 
     508                                        // will produce a NAN at phi_cyl=0 and 45 degrees 
     509                                        // TODO: integrate from 0 to pi/2 instead of 0 to pi 
     510                                         
     511                                        pars[6] = acos(-1.0)/n_slices * i_theta; 
     512                                         
     513                                         if( fabs(i_theta / n_slices) - 0.5 < 0.000001 ) { 
     514                                                //continue; 
     515                                                pars[6] += 0.00001; 
     516                                        } 
     517                                         
     518                                        // Multiply by sin(theta) because we are integrating in 
     519                                        // spherical coordinates 
     520                                        sum += sin(pars[6])* weight_dispersion( &disperse_elliptical_cylinder_analytical_2D, 
     521                                                                par_values, weight_values,  
     522                                                                (int)floor(pars[14]), (int)floor(pars[15]), 
     523                                                                pars, q, phi );  
     524                                } 
     525                                 
     526                                p->result = sum/n_slices; 
     527                        } 
     528                         
     529                        return 0; 
     530                default:                                                                // We can't handle this wave data type. 
     531                        SetNaN64(&p->result); 
     532                        return REQUIRES_SP_OR_DP_WAVE; 
     533        } 
     534         
     535        return 0; 
     536} 
     537 
     538int 
     539Sphere_2D(FitParams2DPtr p) 
     540{ 
     541        double *dp; 
     542         
     543        float *fp;                              // Pointer to single precision wave data. 
     544        double qx; 
     545        double qy; 
     546//      double q, phi; 
     547        double pars[4]; 
     548        int i; 
     549        char buf[256]; 
     550         
     551        if (p->waveHandle == NIL) { 
     552                SetNaN64(&p->result); 
     553                return NON_EXISTENT_WAVE; 
     554        } 
     555     
     556        qx = p->qx; 
     557        qy = p->qy; 
     558         
     559        sprintf(buf, "Qx = %g, Qy = %g\r",qx, qy); 
     560        XOPNotice(buf); 
     561         
     562 
     563                //not needed for a symmetric scattering function like this 
     564//      q = hypot(qx,qy); 
     565//      phi = atan2(qy,qx); 
     566         
     567        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
     568                case NT_FP32: 
     569                        fp= WaveData(p->waveHandle); 
     570            SetNaN64(&p->result); 
     571                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
     572                case NT_FP64: 
     573                        dp= WaveData(p->waveHandle); 
     574                         
     575                        for(i=0; i<4; i++) { 
     576                                pars[i] = dp[i]; 
     577                        } 
     578 
     579                        p->result = SphereForm(pars, sqrt(qx*qx+qy*qy));                //kind of a trivial example... 
     580                        return 0; 
     581                default:                                                                // We can't handle this wave data type. 
     582                        SetNaN64(&p->result); 
     583                        return REQUIRES_SP_OR_DP_WAVE; 
     584        } 
     585         
     586        return 0; 
     587} 
  • sans/Analysis/branches/ajj_23APR07/XOPs/SANSAnalysis/XOP/Func2D.h

    r113 r231  
    22/* IGOR Fit Functions */ 
    33 
    4 int Cylinder_2D_Dist(FitParams2DPtr p); 
     4int Cylinder_2D(FitParams2DPtr p); 
     5int Cylinder_2D_Weight2D(FitParams2DWeightPtr p); 
     6int CoreShellCylinder_2D(FitParams2DPtr p); 
     7int CoreShellCylinder_2D_Weight2D(FitParams2DWeightPtr p); 
     8int Ellipsoid_2D(FitParams2DPtr p); 
     9int Ellipsoid_2D_Weight2D(FitParams2DWeightPtr p); 
     10int EllipticalCylinder_2D(FitParams2DPtr p); 
     11int EllipticalCylinder_2D_Weight2D(FitParams2DWeightPtr p); 
     12int Sphere_2D(FitParams2DPtr p); 
  • sans/Analysis/branches/ajj_23APR07/XOPs/SANSAnalysis/XOP/ResolutionSmearing.c

    r188 r231  
    320320        double nord,va,vb,summ,yyy,zi,Pi; 
    321321        double answer,Resoln,i_shad,i_qbar,i_sigq; 
    322         char buf[256]; 
     322//      char buf[256]; 
    323323         
    324324        Pi = 4.0*atan(1.0); 
  • sans/Analysis/branches/ajj_23APR07/XOPs/SANSAnalysis/XOP/SANSAnalysis.c

    r188 r231  
    215215                case 58:                                                        // y =Smear_Model_76_X (utility). 
    216216                        return((long)SmearedCyl_PolyRadiusX);                   // This function is called using the direct method. 
    217                         break;   
    218                 case 59:                                                        // y =Smear_Model_76_X (utility). 
    219                         return((long)Cylinder_2D_Dist);                 // This function is called using the direct method. 
    220                         break;   
     217                        break; 
     218// 2D Functions from DANSE 
     219                case 59:                                                        // y = f(c,y,x) 
     220                        return((long)Cylinder_2D);                      // This function is called using the direct method. 
     221                        break; 
     222                case 60:                                                        // y = f(c,y,x) 
     223                        return((long)Cylinder_2D_Weight2D);                     // This function is called using the direct method. 
     224                        break; 
     225                case 61:                                                        // y = f(c,y,x) 
     226                        return((long)CoreShellCylinder_2D);                     // This function is called using the direct method. 
     227                        break; 
     228                case 62:                                                        // y = f(c,y,x) 
     229                        return((long)CoreShellCylinder_2D_Weight2D);                    // This function is called using the direct method. 
     230                        break; 
     231                case 63:                                                        // y = f(c,y,x) 
     232                        return((long)Ellipsoid_2D);                     // This function is called using the direct method. 
     233                        break; 
     234                case 64:                                                        // y = f(c,y,x) 
     235                        return((long)Ellipsoid_2D_Weight2D);                    // This function is called using the direct method. 
     236                        break; 
     237                case 65:                                                        // y = f(c,y,x) 
     238                        return((long)EllipticalCylinder_2D);                    // This function is called using the direct method. 
     239                        break; 
     240                case 66:                                                        // y = f(c,y,x) 
     241                        return((long)EllipticalCylinder_2D_Weight2D);                   // This function is called using the direct method. 
     242                        break; 
     243                case 67:                                                        // y = f(c,y,x) 
     244                        return((long)Sphere_2D);                        // This function is called using the direct method. 
     245                        break; 
     246 
    221247        } 
    222248        return NIL; 
  • sans/Analysis/branches/ajj_23APR07/XOPs/SANSAnalysis/XOP/SANSAnalysis.h

    r188 r231  
    3232}FitParams2D, *FitParams2DPtr; 
    3333 
     34// for 2D functions with arbitrary weights in phi and theta 
     35typedef struct FitParams2DWeight { 
     36        double qy;                              // Independent variable. 
     37        double qx;                              // Independent variable. 
     38        waveHndl weight_values; 
     39        waveHndl par_values; 
     40        waveHndl waveHandle;    // Coefficient wave. 
     41        void* tp;                               //unused void for ThreadSafe functions 
     42        double result; 
     43}FitParams2DWeight, *FitParams2DWeightPtr; 
     44 
    3445#include "XOPStructureAlignmentReset.h" 
  • sans/Analysis/branches/ajj_23APR07/XOPs/SANSAnalysis/XOP/SANSAnalysis.r

    r188 r231  
    532532 
    533533// 2D Functions 
    534                 "Cylinder_2D_Dist", 
     534                "Cylinder_2DX", 
     535                F_UTIL | F_THREADSAFE | F_EXTERNAL,                                     /* function category == UTILITY */ 
     536                NT_FP64,                                                /* return value type */                  
     537                { 
     538                        NT_FP64 + WAVE_TYPE,                            /* double precision wave (coefficient wave) */ 
     539                        NT_FP64,                                        /* double precision x */ 
     540                        NT_FP64,                                        /* double precision x */ 
     541                }, 
     542                 
     543                "Cylinder_2D_Weight2DX", 
     544                F_UTIL | F_THREADSAFE | F_EXTERNAL,                                     /* function category == UTILITY */ 
     545                NT_FP64, 
     546                { 
     547                        NT_FP64 + WAVE_TYPE, 
     548                        NT_FP64 + WAVE_TYPE, 
     549                        NT_FP64 + WAVE_TYPE, 
     550                        NT_FP64, 
     551                        NT_FP64, 
     552                }, 
     553 
     554                 
     555                "CoreShellCylinder_2DX", 
     556                F_UTIL | F_THREADSAFE | F_EXTERNAL,                                     /* function category == UTILITY */ 
     557                NT_FP64,                                                /* return value type */                  
     558                { 
     559                        NT_FP64 + WAVE_TYPE,                            /* double precision wave (coefficient wave) */ 
     560                        NT_FP64,                                        /* double precision x */ 
     561                        NT_FP64,                                        /* double precision x */ 
     562                }, 
     563                 
     564                "CoreShellCylinder_2D_Weight2DX", 
     565                F_UTIL | F_THREADSAFE | F_EXTERNAL,                                     /* function category == UTILITY */ 
     566                NT_FP64, 
     567                { 
     568                        NT_FP64 + WAVE_TYPE, 
     569                        NT_FP64 + WAVE_TYPE, 
     570                        NT_FP64 + WAVE_TYPE, 
     571                        NT_FP64, 
     572                        NT_FP64, 
     573                }, 
     574 
     575                 
     576                "Ellipsoid_2DX", 
     577                F_UTIL | F_THREADSAFE | F_EXTERNAL,                                     /* function category == UTILITY */ 
     578                NT_FP64,                                                /* return value type */                  
     579                { 
     580                        NT_FP64 + WAVE_TYPE,                            /* double precision wave (coefficient wave) */ 
     581                        NT_FP64,                                        /* double precision x */ 
     582                        NT_FP64,                                        /* double precision x */ 
     583                }, 
     584                 
     585                "Ellipsoid_2D_Weight2DX", 
     586                F_UTIL | F_THREADSAFE | F_EXTERNAL,                                     /* function category == UTILITY */ 
     587                NT_FP64, 
     588                { 
     589                        NT_FP64 + WAVE_TYPE, 
     590                        NT_FP64 + WAVE_TYPE, 
     591                        NT_FP64 + WAVE_TYPE, 
     592                        NT_FP64, 
     593                        NT_FP64, 
     594                }, 
     595                 
     596                "EllipticalCylinder_2DX", 
     597                F_UTIL | F_THREADSAFE | F_EXTERNAL,                                     /* function category == UTILITY */ 
     598                NT_FP64,                                                /* return value type */                  
     599                { 
     600                        NT_FP64 + WAVE_TYPE,                            /* double precision wave (coefficient wave) */ 
     601                        NT_FP64,                                        /* double precision x */ 
     602                        NT_FP64,                                        /* double precision x */ 
     603                }, 
     604                 
     605                "EllipticalCylinder_2D_Weight2DX", 
     606                F_UTIL | F_THREADSAFE | F_EXTERNAL,                                     /* function category == UTILITY */ 
     607                NT_FP64, 
     608                { 
     609                        NT_FP64 + WAVE_TYPE, 
     610                        NT_FP64 + WAVE_TYPE, 
     611                        NT_FP64 + WAVE_TYPE, 
     612                        NT_FP64, 
     613                        NT_FP64, 
     614                }, 
     615 
     616                "Sphere_2DX", 
    535617                F_UTIL | F_THREADSAFE | F_EXTERNAL,                                     /* function category == UTILITY */ 
    536618                NT_FP64,                                                /* return value type */                  
  • sans/Analysis/branches/ajj_23APR07/XOPs/SANSAnalysis/lib/libSANSAnalysis.h

    r189 r231  
    110110// it is imperative to set ALL the structure alignments to be two-byte 
    111111// rather than leave it to the whim of the compiler 
     112/* SRK08 
    112113#include "XOPStructureAlignmentTwoByte.h" 
    113114 
     
    147148double smeared_cylinder_analytical_2D(SmearCylinderParameters *pars, double q, double phi); 
    148149double smeared_cylinder_dist( double x, double mean, double sigma ); 
     150*/ 
Note: See TracChangeset for help on using the changeset viewer.