PowderPattern.h

/*  ObjCryst++ Object-Oriented Crystallographic Library
    (c) 2000-2002 Vincent Favre-Nicolin vincefn@users.sourceforge.net
        2000-2001 University of Geneva (Switzerland)

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
#ifndef _OBJCRYST_POWDERPATTERN_H_
#define _OBJCRYST_POWDERPATTERN_H_

#include <utility>
#include <list>
#include <string>

#include "ObjCryst/CrystVector/CrystVector.h"
#include "ObjCryst/ObjCryst/General.h"
#include "ObjCryst/ObjCryst/Crystal.h"
#include "ObjCryst/ObjCryst/ScatteringCorr.h"
#include "ObjCryst/ObjCryst/ReflectionProfile.h"
#include "ObjCryst/ObjCryst/CIF.h"
#include "ObjCryst/ObjCryst/Indexing.h"
#include "ObjCryst/ObjCryst/DiffractionDataSingleCrystal.h"

namespace ObjCryst
{

class PowderPattern;

//######################################################################
//######################################################################
class PowderPatternComponent : virtual public RefinableObj
{
   public:
      PowderPatternComponent();
      PowderPatternComponent(const PowderPatternComponent&);
      virtual ~PowderPatternComponent();
      virtual const string& GetClassName() const;

      const PowderPattern& GetParentPowderPattern()const;
      PowderPattern& GetParentPowderPattern();
      virtual void SetParentPowderPattern(PowderPattern&)=0;
      virtual const CrystVector_REAL& GetPowderPatternCalc()const=0;
      virtual std::map<RefinablePar*,CrystVector_REAL>& GetPowderPattern_FullDeriv(std::set<RefinablePar *> &vPar);
      virtual pair<const CrystVector_REAL*,const RefinableObjClock*> GetPowderPatternIntegratedCalc()const=0;
      virtual std::map<RefinablePar*,CrystVector_REAL>& GetPowderPatternIntegrated_FullDeriv(std::set<RefinablePar *> &vPar);
      bool IsScalable()const;
      virtual const CrystVector_REAL& GetPowderPatternCalcVariance()const=0;
      virtual pair<const CrystVector_REAL*,const RefinableObjClock*>
         GetPowderPatternIntegratedCalcVariance() const=0;
      virtual bool HasPowderPatternCalcVariance()const=0;
      const RefinableObjClock& GetClockPowderPatternCalc()const;
      const list<pair<const REAL ,const string > >& GetPatternLabelList() const;
   protected:
      const RefinableObjClock& GetClockPowderPatternCalcVariance()const;

      virtual void CalcPowderPattern() const=0;
      virtual void CalcPowderPattern_FullDeriv(std::set<RefinablePar *> &vPar);
      virtual void CalcPowderPatternIntegrated_FullDeriv(std::set<RefinablePar *> &vPar);

      virtual const CrystVector_long& GetBraggLimits()const=0;
      const RefinableObjClock& GetClockBraggLimits()const;

      virtual void SetMaxSinThetaOvLambda(const REAL max)=0;

      mutable CrystVector_REAL mPowderPatternCalc;
      mutable CrystVector_REAL mPowderPatternIntegratedCalc;

      mutable CrystVector_REAL mPowderPatternCalcVariance;
      mutable CrystVector_REAL mPowderPatternIntegratedCalcVariance;

      mutable CrystVector_long mIntegratedReflLimits;

      virtual void Prepare()=0;

      bool mIsScalable;

      //Clocks
         mutable RefinableObjClock mClockPowderPatternCalc;
         mutable RefinableObjClock mClockPowderPatternIntegratedCalc;
         mutable RefinableObjClock mClockPowderPatternVarianceCalc;
         mutable RefinableObjClock mClockPowderPatternIntegratedVarianceCalc;

      PowderPattern *mpParentPowderPattern;
      mutable RefinableObjClock mClockBraggLimits;

      mutable list<pair<const REAL ,const string > > mvLabel;

      mutable std::map<RefinablePar*,CrystVector_REAL> mPowderPattern_FullDeriv;
      mutable std::map<RefinablePar*,CrystVector_REAL> mPowderPatternIntegrated_FullDeriv;
      //Eventually this should be removed (?)
      friend class PowderPattern;
};
extern ObjRegistry<PowderPatternComponent> gPowderPatternComponentRegistry;

//######################################################################
//######################################################################
class PowderPatternBackground : public PowderPatternComponent
{
   public:
      PowderPatternBackground();
      PowderPatternBackground(const PowderPatternBackground&);
      virtual ~PowderPatternBackground();
      virtual const string& GetClassName() const;

      virtual void SetParentPowderPattern(PowderPattern&);
      virtual const CrystVector_REAL& GetPowderPatternCalc()const;
      virtual pair<const CrystVector_REAL*,const RefinableObjClock*>
         GetPowderPatternIntegratedCalc()const;
      void ImportUserBackground(const string &filename);
      void SetInterpPoints(const CrystVector_REAL tth, const CrystVector_REAL backgd);
      const std::pair<const CrystVector_REAL*,const CrystVector_REAL*> GetInterpPoints()const;
      virtual void XMLOutput(ostream &os,int indent=0)const;
      virtual void XMLInput(istream &is,const XMLCrystTag &tag);
      //virtual void XMLInputOld(istream &is,const IOCrystTag &tag);
      virtual void GetGeneGroup(const RefinableObj &obj,
                                CrystVector_uint & groupIndex,
                                unsigned int &firstGroup) const;
      virtual void BeginOptimization(const bool allowApproximations=false,
                                     const bool enableRestraints=false);
      virtual const CrystVector_REAL& GetPowderPatternCalcVariance()const;
      virtual pair<const CrystVector_REAL*,const RefinableObjClock*>
         GetPowderPatternIntegratedCalcVariance() const;
      virtual bool HasPowderPatternCalcVariance()const;
      virtual void TagNewBestConfig()const;
      void OptimizeBayesianBackground();
      void FixParametersBeyondMaxresolution(RefinableObj &obj);
   protected:
      virtual void CalcPowderPattern() const;
      virtual void CalcPowderPattern_FullDeriv(std::set<RefinablePar *> &vPar);
      virtual void CalcPowderPatternIntegrated() const;
      virtual void CalcPowderPatternIntegrated_FullDeriv(std::set<RefinablePar *> &vPar);
      virtual void Prepare();
      virtual const CrystVector_long& GetBraggLimits()const;
      virtual void SetMaxSinThetaOvLambda(const REAL max);
      void InitRefParList();
      void InitOptions();
      void InitSpline()const;
      int mBackgroundNbPoint;
      CrystVector_REAL mBackgroundInterpPointX;
      CrystVector_REAL mBackgroundInterpPointIntensity;
      mutable CrystVector_long mPointOrder;
      mutable CrystVector_REAL mvSplinePixel;
      mutable CubicSpline mvSpline;
      // Clocks
         RefinableObjClock mClockBackgroundPoint;
         mutable RefinableObjClock mClockSpline;

      REAL mMaxSinThetaOvLambda;

      REAL mModelVariance;

      RefObjOpt mInterpolationModel;
      //To be removed
      friend class PowderPattern;
   #ifdef __WX__CRYST__
   public:
      virtual WXCrystObjBasic* WXCreate(wxWindow*);
      friend class WXPowderPatternBackground;
   #endif
};

//######################################################################
//######################################################################
class PowderPatternDiffraction : virtual public PowderPatternComponent,public ScatteringData
{
   public:
      PowderPatternDiffraction();
      PowderPatternDiffraction(const PowderPatternDiffraction&);
      virtual ~PowderPatternDiffraction();
      virtual PowderPatternDiffraction* CreateCopy()const;
      virtual const string& GetClassName() const;

      virtual void SetParentPowderPattern(PowderPattern&);
      virtual const CrystVector_REAL& GetPowderPatternCalc()const;
      virtual pair<const CrystVector_REAL*,const RefinableObjClock*>
         GetPowderPatternIntegratedCalc()const;

      void SetReflectionProfilePar(const ReflectionProfileType prof,
                                   const REAL fwhmCagliotiW,
                                   const REAL fwhmCagliotiU=0,
                                   const REAL fwhmCagliotiV=0,
                                   const REAL eta0=0.5,
                                   const REAL eta1=0.);
      void SetProfile(ReflectionProfile *prof);
      const ReflectionProfile& GetProfile()const;
      ReflectionProfile& GetProfile();
      virtual void GenHKLFullSpace();
      virtual void XMLOutput(ostream &os,int indent=0)const;
      virtual void XMLInput(istream &is,const XMLCrystTag &tag);
      //virtual void XMLInputOld(istream &is,const IOCrystTag &tag);
      virtual void GetGeneGroup(const RefinableObj &obj,
                                CrystVector_uint & groupIndex,
                                unsigned int &firstGroup) const;
      virtual void BeginOptimization(const bool allowApproximations=false,
                                     const bool enableRestraints=false);
      virtual void EndOptimization();
      virtual void SetApproximationFlag(const bool allow);
      virtual const Radiation& GetRadiation()const;
      virtual const CrystVector_REAL& GetPowderPatternCalcVariance()const;
      virtual pair<const CrystVector_REAL*,const RefinableObjClock*>
         GetPowderPatternIntegratedCalcVariance() const;
      virtual bool HasPowderPatternCalcVariance()const;
      virtual void SetCrystal(Crystal &crystal);
      void SetExtractionMode(const bool extract=true,const bool init=false);
      bool GetExtractionMode()const;
      void ExtractLeBail(unsigned int nbcycle=1);
      virtual long GetNbReflBelowMaxSinThetaOvLambda()const;
      void SetFrozenLatticePar(const unsigned int i, REAL v);
      REAL GetFrozenLatticePar(const unsigned int i) const;
      void FreezeLatticePar(const bool use);
      bool FreezeLatticePar() const;
   protected:
      virtual void CalcPowderPattern() const;
      virtual void CalcPowderPattern_FullDeriv(std::set<RefinablePar *> &vPar);
      virtual void CalcPowderPatternIntegrated() const;
      virtual void CalcPowderPatternIntegrated_FullDeriv(std::set<RefinablePar *> &vPar);

      void CalcPowderReflProfile()const;
      void CalcPowderReflProfile_FullDeriv(std::set<RefinablePar *> &vPar);
      void CalcIntensityCorr()const;
      virtual void CalcIhkl() const;
      virtual void CalcIhkl_FullDeriv(std::set<RefinablePar*> &vPar);
      virtual void Prepare();
      virtual void InitOptions();
      virtual const CrystVector_long& GetBraggLimits()const;
      virtual void SetMaxSinThetaOvLambda(const REAL max);
      virtual const CrystMatrix_REAL& GetBMatrix()const;
      void CalcFrozenBMatrix()const;
      void PrepareIntegratedProfile()const;
      //Clocks
         RefinableObjClock mClockProfilePar;
         RefinableObjClock mClockLorentzPolarSlitCorrPar;
      //Clocks (internal, mutable)
         mutable RefinableObjClock mClockIntensityCorr;
         mutable RefinableObjClock mClockProfileCalc;
         mutable RefinableObjClock mClockIhklCalc;
         ReflectionProfile *mpReflectionProfile;
      // Corrections
         mutable CrystVector_REAL mIntensityCorr;
         LorentzCorr mCorrLorentz;
         PolarizationCorr mCorrPolar;
         PowderSlitApertureCorr mCorrSlitAperture;
         TextureMarchDollase mCorrTextureMarchDollase;
         TextureEllipsoid mCorrTextureEllipsoid;
         TOFCorr mCorrTOF;

         mutable CrystVector_REAL mIhklCalc;
         mutable std::map<RefinablePar*,CrystVector_REAL> mIhkl_FullDeriv;
         mutable CrystVector_REAL mIhklCalcVariance;

      // Saved arrays to speed-up computations
         struct ReflProfile
         {
            long first;
            long last;
            CrystVector_REAL profile;
         };
         mutable vector<ReflProfile> mvReflProfile;
         mutable std::map<RefinablePar*,vector<CrystVector_REAL> > mvReflProfile_FullDeriv;

      // When using integrated profiles
         mutable vector< pair<unsigned long, CrystVector_REAL> > mIntegratedProfileFactor;
         mutable RefinableObjClock mClockIntegratedProfileFactor;
      bool mExtractionMode;
      DiffractionDataSingleCrystal *mpLeBailData;
      mutable CrystVector_REAL mFrozenLatticePar;
      bool mFreezeLatticePar;
      mutable CrystMatrix_REAL mFrozenBMatrix;
   #ifdef __WX__CRYST__
   public:
      virtual WXCrystObjBasic* WXCreate(wxWindow*);
      friend class WXPowderPatternDiffraction;
   #endif
   private:
      // Avoid compiler warnings.  Explicitly hide the base-class method.
      void GenHKLFullSpace(const REAL, const bool);
};


//######################################################################
//######################################################################
class PowderPattern : public RefinableObj
{
    public:
      PowderPattern();
      PowderPattern(const PowderPattern&);
      ~PowderPattern();
      virtual const string& GetClassName() const;
      void AddPowderPatternComponent(PowderPatternComponent &);
      unsigned int GetNbPowderPatternComponent()const;
      const PowderPatternComponent& GetPowderPatternComponent(const string &name)const;
      const PowderPatternComponent& GetPowderPatternComponent(const int)const;
      PowderPatternComponent& GetPowderPatternComponent(const string &name);
      PowderPatternComponent& GetPowderPatternComponent(const int);
      REAL GetScaleFactor(const int i)const;
      REAL GetScaleFactor(const PowderPatternComponent &comp)const;
      void SetScaleFactor(const int i, REAL s);
      void SetScaleFactor(const PowderPatternComponent &comp, REAL s);

      // Pattern parameters (2theta range, wavelength, radiation)
         void SetPowderPatternPar(const REAL min,
                                  const REAL step,
                                  unsigned long nbPoint);
         void SetPowderPatternX(const CrystVector_REAL &x);
         unsigned long GetNbPoint()const;
         unsigned long GetNbPointUsed()const;
         const RefinableObjClock& GetClockNbPointUsed()const;

         void SetRadiation(const Radiation &radiation);
         const Radiation& GetRadiation()const;
         Radiation& GetRadiation();

         void SetRadiationType(const RadiationType radiation);
         RadiationType GetRadiationType()const;
         void SetWavelength(const REAL lambda);

         void SetWavelength(const string &XRayTubeElementName,const REAL alpha12ratio=0.5);

         void SetEnergy(const REAL energy);
         REAL GetWavelength()const;

      //Access to pattern data
         const CrystVector_REAL& GetPowderPatternCalc()const;
         std::map<RefinablePar*,CrystVector_REAL>& GetPowderPattern_FullDeriv(std::set<RefinablePar *> &vPar);
         const CrystVector_REAL& GetPowderPatternObs()const;
         const CrystVector_REAL& GetPowderPatternObsSigma()const;
         const CrystVector_REAL& GetPowderPatternVariance()const;
         const CrystVector_REAL& GetPowderPatternWeight()const;
         REAL GetPowderPatternXMin()const;
         REAL GetPowderPatternXStep()const;
         REAL GetPowderPatternXMax()const;
         const CrystVector_REAL& GetPowderPatternX()const;
         const CrystVector_REAL& GetChi2Cumul()const;

      // Clocks
         const RefinableObjClock& GetClockPowderPatternCalc()const;
         const RefinableObjClock& GetClockPowderPatternPar()const;
         const RefinableObjClock& GetClockPowderPatternRadiation()const;
         const RefinableObjClock& GetClockPowderPatternXCorr()const;

      // Corrections to the x (2theta, tof) coordinate
         void SetXZero(const REAL newZero);
         void Set2ThetaDisplacement(const REAL displacement);
         void Set2ThetaTransparency(const REAL transparency);

      // Import & export powder pattern
         void ImportPowderPatternFullprof(const string &fullprofFileName);
         void ImportPowderPatternPSI_DMC(const string &filename);
         void ImportPowderPatternILL_D1A5(const string &filename);
         void ImportPowderPatternXdd(const string &fileName);
         void ImportPowderPatternSietronicsCPI(const string &fileName);
         void ImportPowderPattern2ThetaObsSigma(const string &fileName,const int nbSkip=0);
         void ImportPowderPatternFullprof4(const string &fileName);
         void ImportPowderPatternMultiDetectorLLBG42(const string &fileName);
         void ImportPowderPattern2ThetaObs(const string &fileName,const int nbSkip=0);
         void ImportPowderPatternTOF_ISIS_XYSigma(const string &fileName);
         void ImportPowderPatternGSAS(const string &fileName);
         void ImportPowderPatternCIF(const CIF &cif);
         void SetPowderPatternObs(const CrystVector_REAL& obs);

         void SavePowderPattern(const string &filename="powderPattern.out") const;
         void PrintObsCalcData(ostream&os=cout)const;

      // Statistics..
         REAL GetR()const ;
         REAL GetIntegratedR()const ;
         REAL GetRw()const;
         REAL GetIntegratedRw()const;
         REAL GetChi2()const;
         REAL GetIntegratedChi2()const;
         REAL GetChi2_Option()const;
         void FitScaleFactorForR()const;
         void FitScaleFactorForIntegratedR()const;
         void FitScaleFactorForRw()const;
         void FitScaleFactorForIntegratedRw()const;
         void SetSigmaToSqrtIobs();
         void SetWeightToInvSigmaSq(const REAL minRelatSigma=1e-3);
         void SetWeightToUnit();
         void SetWeightPolynomial(const REAL a, const REAL b, const REAL c,
                                     const REAL minRelatIobs=1e-3);

         void AddExcludedRegion(const REAL min2Theta,const REAL max2theta);

      virtual void BeginOptimization(const bool allowApproximations=false,
                                     const bool enableRestraints=false);
      //virtual void SetApproximationFlag(const bool allow);
      virtual void GlobalOptRandomMove(const REAL mutationAmplitude,
                                       const RefParType *type=gpRefParTypeObjCryst);
      virtual REAL GetLogLikelihood()const;
      //LSQ functions
         virtual unsigned int GetNbLSQFunction()const;
         virtual const CrystVector_REAL& GetLSQCalc(const unsigned int) const;
         virtual const CrystVector_REAL& GetLSQObs(const unsigned int) const;
         virtual const CrystVector_REAL& GetLSQWeight(const unsigned int) const;
         virtual std::map<RefinablePar*, CrystVector_REAL>& GetLSQ_FullDeriv(const unsigned int,std::set<RefinablePar *> &vPar);
      // I/O
         virtual void XMLOutput(ostream &os,int indent=0)const;
         virtual void XMLInput(istream &is,const XMLCrystTag &tag);
         //virtual void XMLInputOld(istream &is,const IOCrystTag &tag);
         void Prepare();
      virtual void GetGeneGroup(const RefinableObj &obj,
                                CrystVector_uint & groupIndex,
                                unsigned int &firstGroup) const;
      virtual void SetMaxSinThetaOvLambda(const REAL max);
      REAL GetMaxSinThetaOvLambda()const;

      // For integrated pattern calculations
         const CrystVector_long& GetIntegratedProfileMin()const;
         const CrystVector_long& GetIntegratedProfileMax()const;
         const RefinableObjClock& GetIntegratedProfileLimitsClock()const;
      REAL X2XCorr(const REAL x)const;
      REAL X2PixelCorr(const REAL x)const;
      REAL X2Pixel(const REAL x)const;

         REAL STOL2X(const REAL stol)const;
         REAL X2STOL(const REAL x)const;
         REAL STOL2Pixel(const REAL stol)const;
      PeakList FindPeaks(const float dmin=2.0,const float maxratio=0.01,const unsigned int maxpeak=100);
      const CrystVector_REAL &GetScaleFactor() const;
      CrystVector_REAL &GetScaleFactor();
      void ExportFullprof(const std::string &prefix)const;
   protected:
      void CalcPowderPattern() const;
      void CalcPowderPattern_FullDeriv(std::set<RefinablePar *> &vPar);
      void CalcPowderPatternIntegrated() const;
      void CalcPowderPatternIntegrated_FullDeriv(std::set<RefinablePar *> &vPar);
      virtual void Init();
      void PrepareIntegratedRfactor()const;
      void CalcNbPointUsed()const;
      virtual void InitOptions();

      mutable CrystVector_REAL mPowderPatternCalc;
      mutable std::map<RefinablePar*,CrystVector_REAL> mPowderPattern_FullDeriv;
      mutable CrystVector_REAL mPowderPatternIntegratedCalc;
      mutable std::map<RefinablePar*,CrystVector_REAL> mPowderPatternIntegrated_FullDeriv;
      mutable CrystVector_REAL mPowderPatternBackgroundCalc;
      mutable CrystVector_REAL mPowderPatternBackgroundIntegratedCalc;
      CrystVector_REAL mPowderPatternObs;
      CrystVector_REAL mPowderPatternObsSigma;
      mutable CrystVector_REAL mPowderPatternWeight;
      mutable CrystVector_REAL mPowderPatternVariance;
      mutable CrystVector_REAL mPowderPatternVarianceIntegrated;
      mutable CrystVector_REAL mChi2Cumul;


      mutable CrystVector_REAL mPowderPatternUsedCalc;
      mutable std::map<RefinablePar*,CrystVector_REAL> mPowderPatternUsed_FullDeriv;
      mutable CrystVector_REAL mPowderPatternUsedObs;
      mutable CrystVector_REAL mPowderPatternUsedWeight;

      CrystVector_REAL mX;
      bool mIsXAscending;
      unsigned long mNbPoint;

      Radiation mRadiation;

      // Clocks
         RefinableObjClock mClockPowderPatternPar;
         RefinableObjClock mClockPowderPatternRadiation;
         mutable RefinableObjClock mClockPowderPatternCalc;
         mutable RefinableObjClock mClockPowderPatternIntegratedCalc;
         RefinableObjClock mClockPowderPatternXCorr;
         mutable RefinableObjClock mClockScaleFactor;

      //Excluded regions in the powder pattern, for statistics.
         CrystVector_REAL mExcludedRegionMinX;
         CrystVector_REAL mExcludedRegionMaxX;

      //Various corrections to 2theta-to be used by the components
         REAL mXZero;
         REAL m2ThetaDisplacement;
         REAL m2ThetaTransparency;
         REAL mDIFC,mDIFA;
      // Components of the powder pattern
         ObjRegistry<PowderPatternComponent> mPowderPatternComponentRegistry;
         mutable CrystVector_REAL mScaleFactor;

      bool mUseFastLessPreciseFunc;

      // For statistics
         bool mStatisticsExcludeBackground;
         mutable CrystVector_int mScalableComponentIndex;
         mutable CrystMatrix_REAL mFitScaleFactorM,mFitScaleFactorB,mFitScaleFactorX;

         RefObjOpt mOptProfileIntegration;

      // Integrated R-factors
         mutable CrystVector_long mIntegratedPatternMin,mIntegratedPatternMax;
         mutable CrystVector_REAL mIntegratedObs;
         mutable CrystVector_REAL mIntegratedWeight;
         mutable CrystVector_REAL mIntegratedWeightObs;
         mutable CrystVector_REAL mIntegratedVarianceObs;
         mutable RefinableObjClock mClockIntegratedFactorsPrep;
      // Statistical indicators
         mutable REAL mChi2,mIntegratedChi2;
         mutable REAL mChi2LikeNorm,mIntegratedChi2LikeNorm;
         mutable REAL mR;
         mutable REAL mRw;
         mutable RefinableObjClock mClockChi2,mClockIntegratedChi2;
      REAL mMaxSinThetaOvLambda;
      mutable unsigned long mNbPointUsed;
      mutable unsigned long mNbIntegrationUsed;
      mutable RefinableObjClock mClockNbPointUsed;
   #ifdef __WX__CRYST__
   public:
      virtual WXCrystObjBasic* WXCreate(wxWindow*);
      friend class WXPowderPattern;
      // This should be removed
      friend class WXPowderPatternGraph;
   #endif
};
extern ObjRegistry<PowderPattern> gPowderPatternRegistry;
//######################################################################
//    PROFILE FUNCTIONS (for powder diffraction)
//######################################################################

CrystVector_REAL PowderProfileGauss  (const CrystVector_REAL theta,
                                      const REAL fwhm,
                                      const REAL asymmetryPar=1.);
CrystVector_REAL PowderProfileLorentz(const CrystVector_REAL theta,
                                      const REAL fwhm,
                                      const REAL asymmetryPar=1.);


}//namespace ObjCryst
#endif // _OBJCRYST_POWDERPATTERN_H_