fts/analyzer/BinaryStructureFactor.h

#ifndef RP_BINARY_STRUCTURE_FACTOR_H
#define RP_BINARY_STRUCTURE_FACTOR_H
 
/*
* PSCF - Polymer Self-Consistent Field
*
* Copyright 2015 - 2025, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include <pscf/math/IntVec.h>                     // member
#include <util/accumulators/Average.h>            // member
#include <util/containers/DArray.h>               // member
 
#include <iostream>
 
// Forward declaration
namespace Util {
   template <typename T> class Array;
}
 
namespace Pscf {
namespace Rp {
 
   using namespace Util;

   template <int D, class T>
   class BinaryStructureFactor : public T::Analyzer
   {
 
   public:

      BinaryStructureFactor(typename T::Simulator& simulator, 
                            typename T::System& system);

      void readParameters(std::istream& in) override;
 
      // Virual setup and sample functions are implemented by subclasses

      void output() override;
 
   protected:

      void allocate();

      void findWaveBunches(
       Array<double> const & kSq,
       Array<bool> const & implicit);

      void computeW();

      void computeS(Array<typename T::Complex> const & wk);

      typename T::RFieldDft wk_;
 
      // Alias for base class
      using AnalyzerT = typename T::Analyzer;
 
      // Inherited protected member functions (selected)
      using AnalyzerT::system;
      using AnalyzerT::simulator;
 
   private:

      typename T::RField wm_;

      DArray<int> waveBunchIds_;

      DArray<double> waveWeights_;

      DArray<double> bunchWavenumbers_;

      DArray<double> bunchValues_;

      DArray<Average> bunchAccumulators_;

      DArray<Average> waveAccumulators_;

      double a_, b_;

      IntVec<D> kMeshDimensions_;

      int nWave_;

      int nBunch_;

      bool writeWaveData_;

      bool isInitialized_;
 
      // Alias for FFT wrapper class
      using FFTT = typename T::FFT;
 
   };
 
} // namespace Rp
} // namespace Pscf
#endif