Changeset 73cd800 in sasview


Ignore:
Timestamp:
Mar 30, 2019 5:41:43 PM (6 years ago)
Author:
GitHub <noreply@…>
Parents:
1cf0fc0 (diff), 1342f6a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
git-author:
dehoni <honecker@…> (03/30/19 17:41:43)
git-committer:
GitHub <noreply@…> (03/30/19 17:41:43)
Message:

Merge 1342f6af95377b8acc4a1082f09169a8a0813fcb into 1cf0fc0426654aa29d891b968376b013686c685f

Location:
src/sas
Files:
2 added
9 edited

Legend:

Unmodified
Added
Removed

  • src/sas/sascalc/calculator/c_extensions/libfunc.c

    r144e032a r1342f6a  
    8787} 
    8888 
     89//The code calculating magnetic sld below seems to be not used. 
     90//Keeping it in order to check if it is not breaking anything. 
    8991// calculate magnetic sld and return total sld 
    9092// bn : contrast (not just sld of the layer) 
    … …  
    9597// spintheta: angle (anti-clock-wise) between neutron spin(up) and x axis 
    9698// Note: all angles are in degrees. 
    97 void cal_msld(polar_sld *p_sld, int isangle, double qx, double qy, double bn, 
    98                                 double m01, double mtheta1, double mphi1, 
    99                                 double spinfraci, double spinfracf, double spintheta) 
    100 { 
    101         //locals 
    102         double q_x = qx; 
    103         double q_y = qy; 
    104         double sld = bn; 
    105         int is_angle = isangle; 
    106         double pi = 4.0*atan(1.0); 
    107         double s_theta = spintheta * pi/180.0; 
    108         double m_max = m01; 
    109         double m_phi = mphi1; 
    110         double m_theta = mtheta1; 
    111         double in_spin = spinfraci; 
    112         double out_spin = spinfracf; 
    113  
    114         double m_perp = 0.0; 
    115         double m_perp_z = 0.0; 
    116         double m_perp_y = 0.0; 
    117         double m_perp_x = 0.0; 
    118         double m_sigma_x = 0.0; 
    119         double m_sigma_z = 0.0; 
    120         double m_sigma_y = 0.0; 
    121         //double b_m = 0.0; 
    122         double q_angle = 0.0; 
    123         double mx = 0.0; 
    124         double my = 0.0; 
    125         double mz = 0.0; 
    126         double uu = sld; 
    127         double dd = sld; 
    128         double re_ud = 0.0; 
    129         double im_ud = 0.0; 
    130         double re_du = 0.0; 
    131         double im_du = 0.0; 
    132  
    133         //No mag means no further calculation 
    134         if (isangle>0) { 
    135                 if (m_max < 1.0e-32){ 
    136                         uu = sqrt(sqrt(in_spin * out_spin)) * uu; 
    137                         dd = sqrt(sqrt((1.0 - in_spin) * (1.0 - out_spin))) * dd; 
    138                 } 
    139         } 
    140         else if (fabs(m_max)< 1.0e-32 && fabs(m_phi)< 1.0e-32 && fabs(m_theta)< 1.0e-32){ 
    141                         uu = sqrt(sqrt(in_spin * out_spin)) * uu; 
    142                         dd = sqrt(sqrt((1.0 - in_spin) * (1.0 - out_spin))) * dd; 
    143         } else { 
    144  
    145                 //These are needed because of the precision of inputs 
    146                 if (in_spin < 0.0) in_spin = 0.0; 
    147                 if (in_spin > 1.0) in_spin = 1.0; 
    148                 if (out_spin < 0.0) out_spin = 0.0; 
    149                 if (out_spin > 1.0) out_spin = 1.0; 
    150  
    151                 if (q_x == 0.0) q_angle = pi / 2.0; 
    152                 else q_angle = atan(q_y/q_x); 
    153                 if (q_y < 0.0 && q_x < 0.0) q_angle -= pi; 
    154                 else if (q_y > 0.0 && q_x < 0.0) q_angle += pi; 
    155  
    156                 q_angle = pi/2.0 - q_angle; 
    157                 if (q_angle > pi) q_angle -= 2.0 * pi; 
    158                 else if (q_angle < -pi) q_angle += 2.0 * pi; 
    159  
    160                 if (fabs(q_x) < 1.0e-16 && fabs(q_y) < 1.0e-16){ 
    161                         m_perp = 0.0; 
    162                         } 
    163                 else { 
    164                         m_perp = m_max; 
    165                         } 
    166                 if (is_angle > 0){ 
    167                         m_phi *= pi/180.0; 
    168                         m_theta *= pi/180.0; 
    169                         mx = m_perp * cos(m_theta) * cos(m_phi); 
    170                         my = m_perp * sin(m_theta); 
    171                         mz = -(m_perp * cos(m_theta) * sin(m_phi)); 
    172                 } 
    173                 else{ 
    174                         mx = m_perp; 
    175                         my = m_phi; 
    176                         mz = m_theta; 
    177                 } 
    178                 //ToDo: simplify these steps 
    179                 // m_perp1 -m_perp2 
    180                 m_perp_x = (mx) *  cos(q_angle); 
    181                 m_perp_x -= (my) * sin(q_angle); 
    182                 m_perp_y = m_perp_x; 
    183                 m_perp_x *= cos(-q_angle); 
    184                 m_perp_y *= sin(-q_angle); 
    185                 m_perp_z = mz; 
    186  
    187                 m_sigma_x = (m_perp_x * cos(-s_theta) - m_perp_y * sin(-s_theta)); 
    188                 m_sigma_y = (m_perp_x * sin(-s_theta) + m_perp_y * cos(-s_theta)); 
    189                 m_sigma_z = (m_perp_z); 
    190  
    191                 //Find b 
    192                 uu -= m_sigma_x; 
    193                 dd += m_sigma_x; 
    194                 re_ud = m_sigma_y; 
    195                 re_du = m_sigma_y; 
    196                 im_ud = m_sigma_z; 
    197                 im_du = -m_sigma_z; 
    198  
    199                 uu = sqrt(sqrt(in_spin * out_spin)) * uu; 
    200                 dd = sqrt(sqrt((1.0 - in_spin) * (1.0 - out_spin))) * dd; 
    201  
    202                 re_ud = sqrt(sqrt(in_spin * (1.0 - out_spin))) * re_ud; 
    203                 im_ud = sqrt(sqrt(in_spin * (1.0 - out_spin))) * im_ud; 
    204                 re_du = sqrt(sqrt((1.0 - in_spin) * out_spin)) * re_du; 
    205                 im_du = sqrt(sqrt((1.0 - in_spin) * out_spin)) * im_du; 
    206         } 
    207         p_sld->uu = uu; 
    208         p_sld->dd = dd; 
    209         p_sld->re_ud = re_ud; 
    210         p_sld->im_ud = im_ud; 
    211         p_sld->re_du = re_du; 
    212         p_sld->im_du = im_du; 
    213 } 
     99// void cal_msld(polar_sld *p_sld, int isangle, double qx, double qy, double bn, 
     100//                              double m01, double mtheta1, double mphi1, 
     101//                              double spinfraci, double spinfracf, double spintheta) 
     102// { 
     103//      //locals 
     104//      double q_x = qx; 
     105//      double q_y = qy; 
     106//      double sld = bn; 
     107//      int is_angle = isangle; 
     108//      double pi = 4.0*atan(1.0); 
     109//      double s_theta = spintheta * pi/180.0; 
     110//      double m_max = m01; 
     111//      double m_phi = mphi1; 
     112//      double m_theta = mtheta1; 
     113//      double in_spin = spinfraci; 
     114//      double out_spin = spinfracf; 
     115// 
     116//      double m_perp = 0.0; 
     117//      double m_perp_z = 0.0; 
     118//      double m_perp_y = 0.0; 
     119//      double m_perp_x = 0.0; 
     120//      double m_sigma_x = 0.0; 
     121//      double m_sigma_z = 0.0; 
     122//      double m_sigma_y = 0.0; 
     123//      //double b_m = 0.0; 
     124//      double q_angle = 0.0; 
     125//      double mx = 0.0; 
     126//      double my = 0.0; 
     127//      double mz = 0.0; 
     128//      double uu = sld; 
     129//      double dd = sld; 
     130//      double re_ud = 0.0; 
     131//      double im_ud = 0.0; 
     132//      double re_du = 0.0; 
     133//      double im_du = 0.0; 
     134//  const double norm=outspin; 
     135 
     136 
     137// The norm is needed to make sure that the scattering cross sections are 
     138//correctly weighted, such that the sum of spin-resolved measurements adds up to 
     139// the unpolarised or half-polarised scattering cross section. No intensity weighting 
     140// needed on the incoming polariser side (assuming that a user), has normalised 
     141// to the incoming flux with polariser in for SANSPOl and unpolarised beam, respectively. 
     142 
     143//if (out_spin < 0.5){norm=1-out_spin;} 
     144//else{norm=out_spin;} 
     145 
     146//      //No mag means no further calculation 
     147//      if (isangle>0) { 
     148//              if (m_max < 1.0e-32){ 
     149//                      uu = sqrt(in_spin * out_spin/ norm) * uu ; 
     150//                      dd = sqrt((1.0 - in_spin) * (1.0 - out_spin)/ norm) * dd ; 
     151//              } 
     152//      } 
     153//      else if (fabs(m_max)< 1.0e-32 && fabs(m_phi)< 1.0e-32 && fabs(m_theta)< 1.0e-32){ 
     154//                      uu = sqrt(in_spin * out_spin/ norm) * uu; 
     155//                      dd = sqrt((1.0 - in_spin) * (1.0 - out_spin)/ norm) * dd; 
     156//      } else { 
     157// 
     158//              //These are needed because of the precision of inputs 
     159//              if (in_spin < 0.0) in_spin = 0.0; 
     160//              if (in_spin > 1.0) in_spin = 1.0; 
     161//              if (out_spin < 0.0) out_spin = 0.0; 
     162//              if (out_spin > 1.0) out_spin = 1.0; 
     163// 
     164//              if (q_x == 0.0) q_angle = pi / 2.0; 
     165//              else q_angle = atan(q_y/q_x); 
     166//              if (q_y < 0.0 && q_x < 0.0) q_angle -= pi; 
     167//              else if (q_y > 0.0 && q_x < 0.0) q_angle += pi; 
     168// 
     169//              q_angle = pi/2.0 - q_angle; 
     170//              if (q_angle > pi) q_angle -= 2.0 * pi; 
     171//              else if (q_angle < -pi) q_angle += 2.0 * pi; 
     172// 
     173//              if (fabs(q_x) < 1.0e-16 && fabs(q_y) < 1.0e-16){ 
     174//                      m_perp = 0.0; 
     175//                      } 
     176//              else { 
     177//                      m_perp = m_max; 
     178//                      } 
     179//              if (is_angle > 0){ 
     180//                      m_phi *= pi/180.0; 
     181//                      m_theta *= pi/180.0; 
     182//                      mx = m_perp * cos(m_theta) * cos(m_phi); 
     183//                      my = m_perp * sin(m_theta); 
     184//                      mz = -(m_perp * cos(m_theta) * sin(m_phi)); 
     185//              } 
     186//              else{ 
     187//                      mx = m_perp; 
     188//                      my = m_phi; 
     189//                      mz = m_theta; 
     190//              } 
     191//              //ToDo: simplify these steps 
     192//              // m_perp1 -m_perp2 
     193//              m_perp_x = (mx) *  cos(q_angle); 
     194//              m_perp_x -= (my) * sin(q_angle); 
     195//              m_perp_y = m_perp_x; 
     196//              m_perp_x *= cos(-q_angle); 
     197//              m_perp_y *= sin(-q_angle); 
     198//              m_perp_z = mz; 
     199// 
     200//              m_sigma_x = (m_perp_x * cos(-s_theta) - m_perp_y * sin(-s_theta)); 
     201//              m_sigma_y = (m_perp_x * sin(-s_theta) + m_perp_y * cos(-s_theta)); 
     202//              m_sigma_z = (m_perp_z); 
     203// 
     204//              //Find b 
     205//              uu += m_sigma_x; 
     206//              dd -= m_sigma_x; 
     207//              re_ud = m_sigma_y; 
     208//              re_du = m_sigma_y; 
     209//              im_ud = m_sigma_z; 
     210//              im_du = -m_sigma_z; 
     211// 
     212//              uu = sqrt((in_spin) * (out_spin)/ norm) * uu; 
     213//              dd = sqrt((1.0 - in_spin) * (1.0 - out_spin)/ norm) * dd; 
     214// 
     215//              re_ud = sqrt(in_spin * (1.0 - out_spin)/ norm) * re_ud; 
     216//              im_ud = sqrt(in_spin * (1.0 - out_spin)/ norm) * im_ud; 
     217//              re_du = sqrt((1.0 - in_spin) * out_spin/ norm) * re_du; 
     218//              im_du = sqrt((1.0 - in_spin) * out_spin/ norm) * im_du; 
     219//      } 
     220//      p_sld->uu = uu; 
     221//      p_sld->dd = dd; 
     222//      p_sld->re_ud = re_ud; 
     223//      p_sld->im_ud = im_ud; 
     224//      p_sld->re_du = re_du; 
     225//      p_sld->im_du = im_du; 
     226// } 
    214227 
    215228 

  • src/sas/sascalc/calculator/c_extensions/libfunc.h

    r144e032a rb36e7c7  
    1818//double gamln(double x); 
    1919 
    20 void cal_msld(polar_sld*, int isangle, double qx, double qy, double bn, double m01, double mtheta1,  
    21                         double mphi1, double spinfraci, double spinfracf, double spintheta); 
     20//void cal_msld(polar_sld*, int isangle, double qx, double qy, double bn, double m01, double mtheta1, 
     21//                      double mphi1, double spinfraci, double spinfracf, double spintheta); 
    2222 
    2323//void gser(float *gamser, float a, float x, float *gln); 

  • src/sas/sascalc/calculator/c_extensions/sld2i.c

    r144e032a rb36e7c7  
    4747 * Compute 2D anisotropic 
    4848 */ 
    49 void genicomXY(GenI* this, int npoints, double *qx, double *qy, double *I_out){ 
    50         //npoints is given negative for angular averaging 
    51         // Assumes that q doesn't have qz component and sld_n is all real 
    52         //double q = 0.0; 
    53         //double Pi = 4.0*atan(1.0); 
    54         polar_sld b_sld; 
    55         double qr = 0.0; 
    56         Cplx iqr; 
    57         Cplx ephase; 
    58         Cplx comp_sld; 
    59  
    60         Cplx sumj_uu; 
    61         Cplx sumj_ud; 
    62         Cplx sumj_du; 
    63         Cplx sumj_dd; 
    64         Cplx temp_fi; 
    65  
    66         double count = 0.0; 
    67         int i, j; 
    68  
    69         cassign(&iqr, 0.0, 0.0); 
    70         cassign(&ephase, 0.0, 0.0); 
    71         cassign(&comp_sld, 0.0, 0.0); 
    72  
    73         //Assume that pixel volumes are given in vol_pix in A^3 unit 
    74         //int x_size = 0; //in Ang 
    75         //int y_size = 0; //in Ang 
    76         //int z_size = 0; //in Ang 
    77  
    78         // Loop over q-values and multiply apply matrix 
    79  
    80         //printf("npoints: %d, npix: %d\n", npoints, this->n_pix); 
    81         for(i=0; i<npoints; i++){ 
    82                 //I_out[i] = 0.0; 
    83                 cassign(&sumj_uu, 0.0, 0.0); 
    84                 cassign(&sumj_ud, 0.0, 0.0); 
    85                 cassign(&sumj_du, 0.0, 0.0); 
    86                 cassign(&sumj_dd, 0.0, 0.0); 
    87                 //printf("i: %d\n", i); 
    88                 //q = sqrt(qx[i]*qx[i] + qy[i]*qy[i]); // + qz[i]*qz[i]); 
    89  
    90                 for(j=0; j<this->n_pix; j++){ 
    91                         if (this->sldn_val[j]!=0.0 
    92                                 ||this->mx_val[j]!=0.0 
    93                                 ||this->my_val[j]!=0.0 
    94                                 ||this->mz_val[j]!=0.0) 
    95                         { 
    96                             // printf("i,j: %d,%d\n", i,j); 
    97                                 //anisotropic 
    98                                 cassign(&temp_fi, 0.0, 0.0); 
    99                                 cal_msld(&b_sld, 0, qx[i], qy[i], this->sldn_val[j], 
    100                                                          this->mx_val[j], this->my_val[j], this->mz_val[j], 
    101                                                          this->inspin, this->outspin, this->stheta); 
    102                                 qr = (qx[i]*this->x_val[j] + qy[i]*this->y_val[j]); 
    103                                 cassign(&iqr, 0.0, qr); 
    104                                 cplx_exp(&ephase, iqr); 
    105  
    106                                 //Let's multiply pixel(atomic) volume here 
    107                                 rcmult(&ephase, this->vol_pix[j], ephase); 
    108                                 //up_up 
    109                                 if (this->inspin > 0.0 && this->outspin > 0.0){ 
    110                                         cassign(&comp_sld, b_sld.uu, 0.0); 
    111                                         cplx_mult(&temp_fi, comp_sld, ephase); 
    112                                         cplx_add(&sumj_uu, sumj_uu, temp_fi); 
    113                                 } 
    114                                 //down_down 
    115                                 if (this->inspin < 1.0 && this->outspin < 1.0){ 
    116                                         cassign(&comp_sld, b_sld.dd, 0.0); 
    117                                         cplx_mult(&temp_fi, comp_sld, ephase); 
    118                                         cplx_add(&sumj_dd, sumj_dd, temp_fi); 
    119                                 } 
    120                                 //up_down 
    121                                 if (this->inspin > 0.0 && this->outspin < 1.0){ 
    122                                         cassign(&comp_sld, b_sld.re_ud, b_sld.im_ud); 
    123                                         cplx_mult(&temp_fi, comp_sld, ephase); 
    124                                         cplx_add(&sumj_ud, sumj_ud, temp_fi); 
    125                                 } 
    126                                 //down_up 
    127                                 if (this->inspin < 1.0 && this->outspin > 0.0){ 
    128                                         cassign(&comp_sld, b_sld.re_du, b_sld.im_du); 
    129                                         cplx_mult(&temp_fi, comp_sld, ephase); 
    130                                         cplx_add(&sumj_du, sumj_du, temp_fi); 
    131                                 } 
    132  
    133                                 if (i == 0){ 
    134                                         count += this->vol_pix[j]; 
    135                                 } 
    136                         } 
    137                 } 
    138                 //printf("aa%d=%g %g %d\n", i, (sumj_uu.re*sumj_uu.re + sumj_uu.im*sumj_uu.im), (sumj_dd.re*sumj_dd.re + sumj_dd.im*sumj_dd.im), count); 
    139  
    140                 I_out[i] = (sumj_uu.re*sumj_uu.re + sumj_uu.im*sumj_uu.im); 
    141                 I_out[i] += (sumj_ud.re*sumj_ud.re + sumj_ud.im*sumj_ud.im); 
    142                 I_out[i] += (sumj_du.re*sumj_du.re + sumj_du.im*sumj_du.im); 
    143                 I_out[i] += (sumj_dd.re*sumj_dd.re + sumj_dd.im*sumj_dd.im); 
    144  
    145                 I_out[i] *= (1.0E+8 / count); //in cm (unit) / number; //to be multiplied by vol_pix 
    146         } 
    147         //printf("count = %d %g %g %g %g\n", count, this->sldn_val[0],this->mx_val[0], this->my_val[0], this->mz_val[0]); 
    148 } 
     49 
     50 
     51 //The code calculating magnetic scattering below seems to be not used. 
     52 //Keeping it in order to check if it is not breaking anything. 
     53// void genicomXY(GenI* this, int npoints, double *qx, double *qy, double *I_out){ 
     54//      //npoints is given negative for angular averaging 
     55//      // Assumes that q doesn't have qz component and sld_n is all real 
     56//      //double q = 0.0; 
     57//      //double Pi = 4.0*atan(1.0); 
     58//      polar_sld b_sld; 
     59//      double qr = 0.0; 
     60//      Cplx iqr; 
     61//      Cplx ephase; 
     62//      Cplx comp_sld; 
     63// 
     64//      Cplx sumj_uu; 
     65//      Cplx sumj_ud; 
     66//      Cplx sumj_du; 
     67//      Cplx sumj_dd; 
     68//      Cplx temp_fi; 
     69// 
     70//      double count = 0.0; 
     71//      int i, j; 
     72// 
     73//      cassign(&iqr, 0.0, 0.0); 
     74//      cassign(&ephase, 0.0, 0.0); 
     75//      cassign(&comp_sld, 0.0, 0.0); 
     76// 
     77//      //Assume that pixel volumes are given in vol_pix in A^3 unit 
     78//      //int x_size = 0; //in Ang 
     79//      //int y_size = 0; //in Ang 
     80//      //int z_size = 0; //in Ang 
     81// 
     82//      // Loop over q-values and multiply apply matrix 
     83// 
     84//      //printf("npoints: %d, npix: %d\n", npoints, this->n_pix); 
     85//      for(i=0; i<npoints; i++){ 
     86//              //I_out[i] = 0.0; 
     87//              cassign(&sumj_uu, 0.0, 0.0); 
     88//              cassign(&sumj_ud, 0.0, 0.0); 
     89//              cassign(&sumj_du, 0.0, 0.0); 
     90//              cassign(&sumj_dd, 0.0, 0.0); 
     91//              //printf("i: %d\n", i); 
     92//              //q = sqrt(qx[i]*qx[i] + qy[i]*qy[i]); // + qz[i]*qz[i]); 
     93// 
     94//              for(j=0; j<this->n_pix; j++){ 
     95// 
     96//                      if (this->sldn_val[j]!=0.0 
     97//                              ||this->mx_val[j]!=0.0 
     98//                              ||this->my_val[j]!=0.0 
     99//                              ||this->mz_val[j]!=0.0) 
     100//                      { 
     101//                          // printf("i,j: %d,%d\n", i,j); 
     102//                              //anisotropic 
     103//                              cassign(&temp_fi, 0.0, 0.0); 
     104//                              cal_msld(&b_sld, 0, qx[i], qy[i], this->sldn_val[j], 
     105//                                                       this->mx_val[j], this->my_val[j], this->mz_val[j], 
     106//                                                       this->inspin, this->outspin, this->stheta); 
     107//                              qr = (qx[i]*this->x_val[j] + qy[i]*this->y_val[j]); 
     108//                              cassign(&iqr, 0.0, qr); 
     109//                              cplx_exp(&ephase, iqr); 
     110// 
     111//                              //Let's multiply pixel(atomic) volume here 
     112//                              rcmult(&ephase, this->vol_pix[j], ephase); 
     113//                              //up_up 
     114//                              if (this->inspin > 0.0 && this->outspin > 0.0){ 
     115//                                      cassign(&comp_sld, b_sld.uu, 0.0); 
     116//                                      cplx_mult(&temp_fi, comp_sld, ephase); 
     117//                                      cplx_add(&sumj_uu, sumj_uu, temp_fi); 
     118//                              } 
     119//                              //down_down 
     120//                              if (this->inspin < 1.0 && this->outspin < 1.0){ 
     121//                                      cassign(&comp_sld, b_sld.dd, 0.0); 
     122//                                      cplx_mult(&temp_fi, comp_sld, ephase); 
     123//                                      cplx_add(&sumj_dd, sumj_dd, temp_fi); 
     124//                              } 
     125//                              //up_down 
     126//                              if (this->inspin > 0.0 && this->outspin < 1.0){ 
     127//                                      cassign(&comp_sld, b_sld.re_ud, b_sld.im_ud); 
     128//                                      cplx_mult(&temp_fi, comp_sld, ephase); 
     129//                                      cplx_add(&sumj_ud, sumj_ud, temp_fi); 
     130//                              } 
     131//                              //down_up 
     132//                              if (this->inspin < 1.0 && this->outspin > 0.0){ 
     133//                                      cassign(&comp_sld, b_sld.re_du, b_sld.im_du); 
     134//                                      cplx_mult(&temp_fi, comp_sld, ephase); 
     135//                                      cplx_add(&sumj_du, sumj_du, temp_fi); 
     136//                              } 
     137// 
     138//                              if (i == 0){ 
     139//                                      count += this->vol_pix[j]; 
     140//                              } 
     141//                      } 
     142//              } 
     143//              //printf("aa%d=%g %g %d\n", i, (sumj_uu.re*sumj_uu.re + sumj_uu.im*sumj_uu.im), (sumj_dd.re*sumj_dd.re + sumj_dd.im*sumj_dd.im), count); 
     144// 
     145//              I_out[i] = (sumj_uu.re*sumj_uu.re + sumj_uu.im*sumj_uu.im); 
     146//              I_out[i] += (sumj_ud.re*sumj_ud.re + sumj_ud.im*sumj_ud.im); 
     147//              I_out[i] += (sumj_du.re*sumj_du.re + sumj_du.im*sumj_du.im); 
     148//              I_out[i] += (sumj_dd.re*sumj_dd.re + sumj_dd.im*sumj_dd.im); 
     149// 
     150//              I_out[i] *= (1.0E+8  / count); //in cm (unit) / number; //to be multiplied by vol_pix 
     151//      } 
     152//      //printf("count = %d %g %g %g %g\n", count, this->sldn_val[0],this->mx_val[0], this->my_val[0], this->mz_val[0]); 
     153// } 
    149154/** 
    150155 * Compute 1D isotropic 

  • src/sas/sascalc/calculator/c_extensions/sld2i.h

    r54b0650 rb36e7c7  
    3232                double s_theta); 
    3333// compute function 
    34 void genicomXY(GenI*, int npoints, double* qx, double* qy, double *I_out); 
     34//void genicomXY(GenI*, int npoints, double* qx, double* qy, double *I_out); 
    3535void genicom(GenI*, int npoints, double* q, double *I_out); 
    3636 

  • src/sas/sascalc/calculator/c_extensions/sld2i_module.c

    r7ba6470 rb36e7c7  
    1818// Vector binding glue 
    1919#if (PY_VERSION_HEX > 0x03000000) && !defined(Py_LIMITED_API) 
    20   // Assuming that a view into a writable vector points to a  
    21   // non-changing pointer for the duration of the C call, capture  
     20  // Assuming that a view into a writable vector points to a 
     21  // non-changing pointer for the duration of the C call, capture 
    2222  // the view pointer and immediately free the view. 
    2323  #define VECTOR(VEC_obj, VEC_buf, VEC_len) do { \ 
    … …  
    101101 * GenI the given input (2D) according to a given object 
    102102 */ 
    103 PyObject * genicom_inputXY(PyObject *self, PyObject *args) { 
    104         PyObject *gen_obj; 
    105         PyObject *qx_obj; 
    106         PyObject *qy_obj; 
    107         PyObject *I_out_obj; 
    108         Py_ssize_t n_qx, n_qy, n_out; 
    109         double *qx; 
    110         double *qy; 
    111         double *I_out; 
    112         GenI* sld2i; 
    113  
    114         //printf("in genicom_inputXY\n"); 
    115         if (!PyArg_ParseTuple(args, "OOOO",  &gen_obj, &qx_obj, &qy_obj, &I_out_obj)) return NULL; 
    116         sld2i = (GenI *)PyCapsule_GetPointer(gen_obj, "GenI"); 
    117         VECTOR(qx_obj, qx, n_qx); 
    118         VECTOR(qy_obj, qy, n_qy); 
    119         VECTOR(I_out_obj, I_out, n_out); 
    120         //printf("qx, qy, I_out: %d %d %d, %d %d %d\n", qx, qy, I_out, n_qx, n_qy, n_out); 
    121  
    122         // Sanity check 
    123         //if(n_q!=n_out) return Py_BuildValue("i",-1); 
    124  
    125         genicomXY(sld2i, (int)n_qx, qx, qy, I_out); 
    126         //printf("done calc\n"); 
    127         //return PyCObject_FromVoidPtr(s, del_genicom); 
    128         return Py_BuildValue("i",1); 
    129 } 
     103// PyObject * genicom_inputXY(PyObject *self, PyObject *args) { 
     104//      PyObject *gen_obj; 
     105//      PyObject *qx_obj; 
     106//      PyObject *qy_obj; 
     107//      PyObject *I_out_obj; 
     108//      Py_ssize_t n_qx, n_qy, n_out; 
     109//      double *qx; 
     110//      double *qy; 
     111//      double *I_out; 
     112//      GenI* sld2i; 
     113// 
     114//      //printf("in genicom_inputXY\n"); 
     115//      if (!PyArg_ParseTuple(args, "OOOO",  &gen_obj, &qx_obj, &qy_obj, &I_out_obj)) return NULL; 
     116//      sld2i = (GenI *)PyCapsule_GetPointer(gen_obj, "GenI"); 
     117//      VECTOR(qx_obj, qx, n_qx); 
     118//      VECTOR(qy_obj, qy, n_qy); 
     119//      VECTOR(I_out_obj, I_out, n_out); 
     120//      //printf("qx, qy, I_out: %d %d %d, %d %d %d\n", qx, qy, I_out, n_qx, n_qy, n_out); 
     121// 
     122//      // Sanity check 
     123//      //if(n_q!=n_out) return Py_BuildValue("i",-1); 
     124// 
     125//      genicomXY(sld2i, (int)n_qx, qx, qy, I_out); 
     126//      //printf("done calc\n"); 
     127//      //return PyCObject_FromVoidPtr(s, del_genicom); 
     128//      return Py_BuildValue("i",1); 
     129// } 
    130130 
    131131/** 
    … …  
    161161        {"genicom",(PyCFunction)genicom_input, METH_VARARGS, 
    162162                  "genicom the given 1d input arrays"}, 
    163         {"genicomXY",(PyCFunction)genicom_inputXY, METH_VARARGS, 
    164                   "genicomXY the given 2d input arrays"}, 
     163//      {"genicomXY",(PyCFunction)genicom_inputXY, METH_VARARGS, 
     164//                "genicomXY the given 2d input arrays"}, 
    165165    {NULL} 
    166166}; 

  • src/sas/sascalc/calculator/sas_gen.py

    r952ea1f rb36e7c7  
    134134        sldn -= self.params['solvent_SLD'] 
    135135        # **** WARNING **** new_GenI holds pointers to numpy vectors 
    136         # be sure that they are contiguous double precision arrays and make  
     136        # be sure that they are contiguous double precision arrays and make 
    137137        # sure the GC doesn't eat them before genicom is called. 
    138138        # TODO: rewrite so that the parameters are passed directly to genicom 

  • src/sas/sasgui/perspectives/fitting/media/fitting.rst

    rc926a97 r332c10d  
    1717   Smearing Functions <resolution> 
    1818 
     19   Fitting Models with Structure Factors <fitting_sq> 
     20 
     21   Writing a Plugin Model <plugin> 
     22 
    1923   Polarisation/Magnetic Scattering <magnetism/magnetism> 
    20     
     24 
    2125   Oriented Particles <orientation/orientation> 
    2226 
    … …  
    2731   Fitting SESANS Data <sesans/sesans_fitting> 
    2832 
    29    Writing a Plugin Model <plugin> 
    30  
    3133   Computations with a GPU <gpu_setup> 
    3234 

  • src/sas/sasgui/perspectives/fitting/media/fitting_help.rst

    rb7ce5ad r3ec78a1  
    4242*  *Ellipsoid* - ellipsoidal shapes (oblate,prolate, core shell, etc) 
    4343*  *Parellelepiped* - as the name implies 
    44 *  *Sphere* - sheroidal shapes (sphere, core multishell, vesicle, etc) 
     44*  *Sphere* - spheroidal shapes (sphere, core multishell, vesicle, etc) 
    4545*  *Lamellae* - lamellar shapes (lamellar, core shell lamellar, stacked 
    4646   lamellar, etc) 
    … …  
    6161on the *Description* button to the right. 
    6262 
     63S(Q) models can be combined with models in the other categories to generate 
     64what SasView calls "product models". See :ref:`Product_Models` for more 
     65information. 
     66 
    6367Show 1D/2D 
    6468^^^^^^^^^^ 
    … …  
    119123 
    120124For a complete list of all the library models available in SasView, see 
    121 the `Model Documentation <../../../index.html>`_ . 
     125the `Model Documentation <../../../sasgui/perspectives/fitting/models/index.html>`_ . 
    122126 
    123127It is also possible to add your own models. 

  • src/sas/sasview/test/README.txt

    r914ba0a r1cf0fc0  
    1 Test data sets are included as a convenience to our users. The data sets are organized based on their data structure; 1D data (ie, I(Q)), 2D data (ie, I(Qx,Qy)), coordinate data (eg, PDB files), image data (eg, TIFF files), SasView saved states, SESANS data, and data in formats that are not yet implemented but which are in the works for future releases. 
     1Test data sets are included as a convenience to our users. The data sets are 
     2organized based on their data structure; 1D data (ie, I(Q)), 2D data 
     3(ie, I(Qx,Qy)), coordinate data (eg, PDB files), image data 
     4(eg, TIFF files), SasView saved states, SESANS data, and data in formats that 
     5are not yet implemented but which are in the works for future releases. 
    26 
    3 1D data sets EITHER a) have at least two columns of data with I(abs. units) on the y-axis and Q on the x-axis, OR b) have I and Q in separate files. Data in the latter format (/convertible_files) need to be converted to a single file format with the File Converter tool before SasView will analyse them. 
     71D data sets EITHER a) have at least two columns of data with I(abs. units) on 
     8the y-axis and Q on the x-axis, OR b) have I and Q in separate files. Data in 
     9the latter format (/convertible_files) need to be converted to a single file 
     10format with the File Converter tool before SasView will analyse them. 
    411 
    5 2D data sets are data sets that give the deduced intensity for each detector pixel. Depending on the file extension, uncertainty and metadata may also be available. 
     122D data sets are data sets that give the deduced intensity for each detector 
     13pixel. Depending on the file extension, uncertainty and metadata may also be 
     14available. 
    615 
    7 Coordinate data sets are designed to be read by the Generic Scattering Calculator tool. 
     16Coordinate data sets are designed to be read by the Generic Scattering 
     17Calculator tool. 
    818 
    919Image data sets are designed to be read by the Image Viewer tool. 
    1020 
    11 Save states are projects and analyses saved by the SASVIEW program. A single analysis file contains the data and parameters for a single fit (.fit), p(r) inversion (.pr), or invariant calculation (.inv). A project file (.svs) contains the results for every active analysis. 
     21Save states are projects and analyses saved by the SASVIEW program. A single 
     22analysis file contains the data and parameters for a single fit (.fit), p(r) 
     23inversion (.pr), or invariant calculation (.inv). A project file (.svs) 
     24contains the results for every active analysis. 
    1225 
    13 SESANS data sets primarily contain the neutron polarisation as a function of the spin-echo length. 
     26SESANS data sets primarily contain the neutron polarisation as a function of 
     27the spin-echo length. 
Note: See TracChangeset for help on using the changeset viewer.