DiffractionDataSingleCrystal.h

/*
* ObjCryst++ : a Crystallographic computing library in C++
*         http://objcryst.sourceforge.net
*         http://www.ccp14.ac.uk/ccp/web-mirrors/objcryst/
*
*  (c) 2000-2001 Vincent FAVRE-NICOLIN vincefn@users.sourceforge.net
*
*/
/*   DiffractionDataSingleCrystal.h header file for single-crystal
* diffraction objects.
*
*/
#ifndef _OBJCRYST_DIFFDATA_SINGLECRYSTAL_H_
#define _OBJCRYST_DIFFDATA_SINGLECRYSTAL_H_

#include "ObjCryst/CrystVector/CrystVector.h"

#include "ObjCryst/ObjCryst/General.h"

#include "ObjCryst/ObjCryst/ScatteringPower.h"
#include "ObjCryst/ObjCryst/Crystal.h"
#include "ObjCryst/ObjCryst/ScatteringData.h"
//#include "ObjCryst/ObjCryst/SpaceGroup.h"
//#include "ObjCryst/ObjCryst/Scatterer.h"

//#include <stdlib.h>
#include <string>
//#include <iomanip>
//#include <cmath>
//#include <typeinfo>
//#include <fstream>
//#include <ctime>

namespace ObjCryst
{
//######################################################################
//                   DiffractionDataSingleCrystal
//######################################################################

class DiffractionDataSingleCrystal:public ScatteringData
{
   public:
      DiffractionDataSingleCrystal(const bool regist=true);
      DiffractionDataSingleCrystal(Crystal &cryst,const bool regist=true);
      DiffractionDataSingleCrystal(const DiffractionDataSingleCrystal &old);
      ~DiffractionDataSingleCrystal();
      virtual DiffractionDataSingleCrystal* CreateCopy()const;
      virtual const string& GetClassName() const;

      const CrystVector_REAL& GetIcalc() const;
      std::map<RefinablePar*, CrystVector_REAL> & GetIcalc_FullDeriv(std::set<RefinablePar *> &vPar);

      const CrystVector_REAL& GetIobs() const;
      void SetIobs(const CrystVector_REAL&);

      const CrystVector_REAL& GetSigma() const;
      void SetSigma(const CrystVector_REAL&);

      void SetIobsToIcalc();

      const CrystVector_REAL& GetWeight() const;
      void SetWeight(const CrystVector_REAL&);

      void SetHklIobs(const CrystVector_long &h,
                      const CrystVector_long &k,
                      const CrystVector_long &l,
                      const CrystVector_REAL &iObs,
                      const CrystVector_REAL &sigma);

      void ImportHklIobs(const string &fileName,const long nbRefl,const int skipLines=0);
      void ImportHklIobsSigma(const string &fileName,const long nbRefl,const int skipLines=0);
      void ImportShelxHKLF4(const string &fileName);
      void ImportCIF(const string &fileName);
      void ImportHklIobsSigmaJanaM91(const string &fileName);
      void ImportHklIobsGroup(const string &fileName,const unsigned int skipLines=0);

      virtual REAL GetRw()const;
      virtual REAL GetR()const;

      // \return \f$ \chi^2 = \sum_i \left( \frac{ y_i^{obs}-y_i^{calc}}{\sigma_i} \right)^2
      virtual REAL GetChi2()const;

      /* \brief  Return  Goodness of Fit
      *
      * \return \f$ GoF =  \frac{\sum_i w_i\left( y_i^{obs}-y_i^{calc} \right)^2}
      * {N_{obs}-N_{indep.par}} \f$
      virtual REAL GoF()const;
      */

      virtual void FitScaleFactorForRw() const;
      virtual void FitScaleFactorForR() const;
      virtual REAL GetBestRFactor() const;

      virtual void SetSigmaToSqrtIobs();
      virtual void SetWeightToInvSigma2(const REAL minRelatSigma=1e-4, const REAL minIobsSigmaRatio=0);

      REAL GetScaleFactor()const;
      // Set the Scale factor (applied to Icalc to match Iobs)
      //void SetScaleFactor(const REAL);

      virtual void PrintObsData()const;
      virtual void PrintObsCalcData()const;

      virtual void SetUseOnlyLowAngleData(const bool useOnlyLowAngle,const REAL angle=0.);

      void SaveHKLIobsIcalc(const string &filename="hklIobsIcalc.out");
      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);
      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 const Radiation& GetRadiation()const;
      Radiation& GetRadiation();
      virtual void SetRadiationType(const RadiationType radiation);
      void SetWavelength(const REAL );
      void SetWavelength(const string &XRayTubeElementName,const REAL alpha2Alpha2ratio=0.5);
      void SetEnergy(const REAL );

   protected:
   private:
      virtual void InitRefParList();
      void CalcIcalc() const;
      void CalcIcalc_FullDeriv(std::set<RefinablePar *> &vPar);
      virtual CrystVector_long SortReflectionBySinThetaOverLambda(const REAL maxTheta=-1.);
      void InitOptions();
      void PrepareTwinningCalc() const;
      bool mHasObservedData;

      CrystVector_REAL mObsIntensity ;
      CrystVector_REAL mObsSigma ;
      CrystVector_REAL mWeight ;
      mutable CrystVector_REAL mCalcIntensity ;
      mutable std::map<RefinablePar*, CrystVector_REAL> mCalcIntensity_FullDeriv;
      mutable REAL mScaleFactor;
      mutable REAL mChi2;
      //Clocks
         mutable RefinableObjClock mClockIcalc;
         mutable RefinableObjClock mClockScaleFactor;
         mutable RefinableObjClock mClockChi2;
      // Grouped reflections
         RefObjOpt mGroupOption;
         mutable CrystVector_REAL mGroupIobs;
         mutable CrystVector_REAL mGroupSigma;
         mutable CrystVector_REAL mGroupIcalc;
         mutable std::map<RefinablePar*, CrystVector_REAL> mGroupIcalc_FullDeriv;
         mutable CrystVector_REAL mGroupWeight;
         mutable CrystVector_long mGroupIndex;
         mutable long mNbGroup;
         mutable long mNbGroupUsed;
         mutable RefinableObjClock mClockPrepareTwinningCorr;

      // The Radiation for this object
      Radiation mRadiation;
   #ifdef __WX__CRYST__
   public:
      virtual WXCrystObjBasic* WXCreate(wxWindow*);
      friend class WXDiffractionSingleCrystal;//to access the Radiation object

   #endif
};
extern ObjRegistry<DiffractionDataSingleCrystal> gDiffractionDataSingleCrystalRegistry;

} //namespace ObjCryst

#endif //_OBJCRYST_DIFFDATA_SINGLECRYSTAL_H_