Feature/MultiMode

Source/Core/LMCHFSSResponseFileHandler.cc

@@ -25,6 +25,7 @@ namespace locust
     fResolution(1e-12),
     fCharacteristicImpedance(1.0),
     fNSkips(1),
+    fNModes(2),
     fComplexFFT(),
     fHFSSFiletype(""),
     fIsFIRCreated(false),
@@ -41,12 +42,40 @@ namespace locust
 
     bool HFSSResponseFileHandlerCore::Configure(const scarab::param_node& aParam)
     {
-
         if( aParam.has( "print-fir-debug" ) )
-    	{
-    	    fPrintFIR = aParam["print-fir-debug"]().as_bool();
+    	{    
+	    fPrintFIR = aParam["print-fir-debug"]().as_bool();
     	}
+	if( aParam.has( "n-modes" ) )
+	{
+		fNModes = aParam["n-modes"]().as_int();
+	}
 
+        fFilterComplexArray.resize(2);
+        fFIRNBinsArray.resize(2);
+        fResolutionArray.resize(2);
+        fIsFIRCreatedArray.resize(2);  
+	for ( unsigned bTE=0; bTE<2; bTE++)
+	{
+	        fFilterComplexArray[bTE].resize(fNModes);
+		fFIRNBinsArray[bTE].resize(fNModes);
+		fResolutionArray[bTE].resize(fNModes);
+		fIsFIRCreatedArray[bTE].resize(fNModes);	
+        	for (unsigned l=0; l<fNModes; l++)
+        	{   
+               		fFilterComplexArray[bTE][l].resize(fNModes);
+			fFIRNBinsArray[bTE][l].resize(fNModes);
+        		fResolutionArray[bTE][l].resize(fNModes);
+        		fIsFIRCreatedArray[bTE][l].resize(fNModes);  
+               		for (unsigned m=0; m<fNModes; m++)
+               		{   
+                       		fFilterComplexArray[bTE][l][m].resize(fNModes);
+				fFIRNBinsArray[bTE][l][m].resize(fNModes);
+        			fResolutionArray[bTE][l][m].resize(fNModes);
+        			fIsFIRCreatedArray[bTE][l][m].resize(fNModes);  
+			}
+               	}   
+        }  
         if( aParam.has( "convert-sparams-to-z"))
         {
         	fConvertStoZ = aParam["convert-sparams-to-z"]().as_bool();
@@ -108,13 +137,13 @@ namespace locust
         }
         int firBinNumber=0;
 
+	int inputBufferSize = inputBuffer.size();
         for (auto it = inputBuffer.begin();it!=inputBuffer.end(); ++it)
         {
         	convolutionValueReal += *(it)*fFilterComplex[firBinNumber][0];
         	convolutionValueImag += *(it)*fFilterComplex[firBinNumber][1];
         	firBinNumber++;
         }
-
         std::pair<double,double> complexConvolution;
         double complexPhase = atan(convolutionValueImag/convolutionValueReal);
         double complexMag = pow(convolutionValueReal*convolutionValueReal + convolutionValueImag*convolutionValueImag, 0.5);
@@ -134,6 +163,31 @@ namespace locust
         return complexConvolution;
     }
 
+    std::pair<double,double> HFSSResponseFileHandlerCore::ConvolveWithComplexFIRFilterArray(int bTE, int l, int m, int n, std::deque<double> inputBuffer)
+    {   
+        double convolutionMag = 0.0;
+        double convolutionValueReal = 0.0;
+        double convolutionValueImag = 0.0;
+
+        if(fFIRNBinsArray[bTE][l][m][n]<=0)
+        {   
+            LERROR(lmclog,"Number of bins in the filter should be positive");
+        }   
+        int firBinNumber=0;
+
+        int inputBufferSize = inputBuffer.size();    
+        for (auto it = inputBuffer.begin();it!=inputBuffer.end(); ++it)
+        {  
+                convolutionValueReal += *(it)*fFilterComplexArray[bTE][l][m][n][firBinNumber][0];
+                convolutionValueImag += *(it)*fFilterComplexArray[bTE][l][m][n][firBinNumber][1];
+                firBinNumber++;
+        }
+        //std::pair<double,double> complexConvolution;
+        double complexPhase = atan(convolutionValueImag/convolutionValueReal);
+        double complexMag = pow(convolutionValueReal*convolutionValueReal + convolutionValueImag*convolutionValueImag, 0.5);
+        return std::make_pair(complexMag, complexPhase);
+        //return complexConvolution;
+    }  
 
     TFFileHandlerCore::TFFileHandlerCore():HFSSResponseFileHandlerCore(),
     fTFComplex(NULL),
@@ -157,7 +211,6 @@ namespace locust
             fFIRComplex = NULL;
         }
     }
-
     bool TFFileHandlerCore::Configure(const scarab::param_node& aParam)
     {
         return true;
@@ -291,7 +344,6 @@ namespace locust
         }
 
         fIsFIRCreated=true;
-
         if (fPrintFIR)
         {
             scarab::path dataDir = TOSTRING(PB_DATA_INSTALL_DIR);
@@ -371,36 +423,35 @@ namespace locust
     	return true;
     }
 
-    bool TFFileHandlerCore::ConvertAnalyticGFtoFIR(std::vector<std::pair<double,std::pair<double,double> > > gfArray)
+    bool TFFileHandlerCore::ConvertAnalyticGFtoFIR(int bTE, int l, int m, int n, std::vector<std::pair<double,std::pair<double,double> > > gfArray)
     {
-
-    	if(fIsFIRCreated)
+    	if(fIsFIRCreatedArray[bTE][l][m][n])
         {
             return true;
         }
 
-        fFIRNBins = gfArray.size();
-        fResolution = gfArray[0].first;
-
-        fFilterComplex=(fftw_complex*)fftw_malloc(sizeof(fftw_complex) * fFIRNBins);
+        fFIRNBinsArray[bTE][l][m][n] = gfArray.size();
+        fResolutionArray[bTE][l][m][n] = gfArray[0].first;
 
-        for (int i = 0; i < fFIRNBins; i++)
+        fFilterComplexArray[bTE][l][m][n]=(fftw_complex*)fftw_malloc(sizeof(fftw_complex) * fFIRNBinsArray[bTE][l][m][n]);
+        for (int i = 0; i < fFIRNBinsArray[bTE][l][m][n]; i++)
         {
-        	fFilterComplex[i][0] = gfArray[i].second.first;
-        	fFilterComplex[i][1] = gfArray[i].second.second;
+        	fFilterComplexArray[bTE][l][m][n][i][0] = gfArray[i].second.first;
+        	fFilterComplexArray[bTE][l][m][n][i][1] = gfArray[i].second.second;
         }
-
         if (fPrintFIR)
         {
 
             scarab::path dataDir = TOSTRING(PB_DATA_INSTALL_DIR);
-
-            PrintFIR( fFilterComplex, fFIRNBins, (dataDir / "../output/FIRhisto.root").string() );
-            LPROG( lmclog, "Finished writing histos to output/FIRhisto.root");
+	    std::string modeIndexStr = std::to_string(bTE) + std::to_string(l) + std::to_string(m) + std::to_string(n);
+	    std::string fileName = (dataDir / "../output/FIRhisto").string() + modeIndexStr + ".root";
+            PrintFIR( fFilterComplexArray[bTE][l][m][n], fFIRNBinsArray[bTE][l][m][n], fileName );
+
+            LPROG( lmclog, "Finished writing histos to output/FIRhisto"+modeIndexStr+".root");
             LPROG( lmclog, "Press Return to continue, or Cntrl-C to quit.");
             getchar();
         }
-
+	fIsFIRCreatedArray[bTE][l][m][n]=true;
         LDEBUG( lmclog, "Finished populating FIR filter with Green's function.");
 
     	return true;

Source/Core/LMCHFSSResponseFileHandler.hh

@@ -32,29 +32,36 @@ namespace locust
         virtual bool Configure( const scarab::param_node& aNode);
         virtual bool ReadHFSSFile();
         virtual double ConvolveWithFIRFilter(std::deque<double>);// Convolve input signal (voltage or field) with FIR
+        virtual std::pair<double,double> ConvolveWithComplexFIRFilterArray(int bTE, int l, int m, int n, std::deque<double> inputBuffer);
         virtual std::pair<double,double> ConvolveWithComplexFIRFilter(std::deque<double> inputBuffer);
         int GetFilterSize() const;//Number of entries in the filter
+	int GetFilterSizeArray(int bTE, int l, int m, int n) const;//Number of entries in the filter
         double GetFilterResolution() const;//Get the resolution of the filter
+	double GetFilterResolutionArray(int bTE, int l, int m, int n) const;//Get the resolution of the filter
         void PrintFIR( std::vector<double>, int nBins, std::string filename );
         void PrintFIR( fftw_complex* aFilter, int nBins, std::string filename );
         bool WriteRootHisto( std::vector<double> aFilter, int nBins, bool bIQ );
 
-
     protected:
 
         // Member variables
         std::string fHFSSFilename;
         std::vector<double> fFilter;
         fftw_complex* fFilterComplex;
+	std::vector< std::vector< std::vector < std::vector< fftw_complex*>>>> fFilterComplexArray;
         int fTFNBins;
         int fFIRNBins;
-        int fCropIndex;
+	std::vector < std::vector < std::vector < std::vector < int >>>> fFIRNBinsArray;
+	int fNModes;
         double fResolution;
+	std::vector < std::vector < std::vector < std::vector < double >>>> fResolutionArray;
+        int fCropIndex;
         double fCharacteristicImpedance;
         int fNSkips;
         bool fHFSSFiletype;
         ComplexFFT fComplexFFT;
         bool fIsFIRCreated;
+	std::vector < std::vector < std::vector < std::vector < bool >>>> fIsFIRCreatedArray;
         std::string fWindowName;
         double fWindowParam;
         bool fPrintFIR;
@@ -74,11 +81,20 @@ namespace locust
         return fFIRNBins;
     }
 
+    inline int HFSSResponseFileHandlerCore::GetFilterSizeArray(int bTE, int l, int m, int n) const
+    {
+        return fFIRNBinsArray[bTE][l][m][n];
+    }
+
     inline double HFSSResponseFileHandlerCore::GetFilterResolution() const
     {
         return fResolution;
     }
 
+    inline double HFSSResponseFileHandlerCore::GetFilterResolutionArray(int bTE, int l, int m, int n) const
+    {   
+        return fResolutionArray[bTE][l][m][n];
+    }   
 
     /*!
      @class TFFileHandlerCore
@@ -97,7 +113,7 @@ namespace locust
         virtual bool Configure( const scarab::param_node& aNode) override;
         bool ReadHFSSFile() override;
         bool ConvertAnalyticTFtoFIR(double initialFreq, std::vector<std::complex<double>> tfArray);
-        bool ConvertAnalyticGFtoFIR(std::vector<std::pair<double,std::pair<double,double> > > gfArray);
+        bool ConvertAnalyticGFtoFIR(int bTE, int l, int m, int n, std::vector<std::pair<double,std::pair<double,double> > > gfArray);
 
 
     private:

Source/Fields/LMCCylindricalCavity.cc

@@ -218,14 +218,18 @@ namespace locust
     	return tIntegral;
     }
 
-    std::vector<double> CylindricalCavity::GetDopplerFrequency(int l, int m, int n, std::vector<double> tKassParticleXP)
+    std::vector<double> CylindricalCavity::GetDopplerFrequency(int bTE, int l, int m, int n, std::vector<double> tKassParticleXP)
     {
     	std::vector<double> freqPrime;
     	double vz = tKassParticleXP[5];
-    	double term1 = fFieldCore->GetBesselNKPrimeZeros(l,m) / GetDimR();
+	double term1 = 0;
+    	if(bTE==1) term1 = fFieldCore->GetBesselNKPrimeZeros(l,m) / GetDimR();
+	else term1 = fFieldCore->GetBesselNKZeros(l,m) / GetDimR();
     	double term2 = n * LMCConst::Pi() / GetDimL();
     	double lambda = 1. / pow( 1. / 4. / LMCConst::Pi() / LMCConst::Pi() * ( term1*term1 + term2*term2 ), 0.5);
-    	double lambda_c = 2 * LMCConst::Pi() * GetDimR() / fFieldCore->GetBesselNKPrimeZeros(l,m);
+    	double lambda_c = 0.;
+	if(bTE==1)lambda_c = 2 * LMCConst::Pi() * GetDimR() / fFieldCore->GetBesselNKPrimeZeros(l,m);
+	else lambda_c = 2 * LMCConst::Pi() * GetDimR() / fFieldCore->GetBesselNKZeros(l,m);
     	double vp = LMCConst::C() / pow( 1. - lambda*lambda/lambda_c/lambda_c, 0.5 );
     	double dopplerShift = 0.;
     	if (vp > 0.) dopplerShift = vz / vp;
@@ -362,12 +366,25 @@ namespace locust
        	return tField;  // return normalized field.
     }
 
-	double CylindricalCavity::CalculateDotProductFactor(int l, int m, int n, std::vector<double> tKassParticleXP, std::vector<double> anE_normalized, double tThisEventNSamples)
+/*
+	double CylindricalCavity::TotalFieldNorm(std::vector<double> field)
+	{
+		double norm = 0;
+		auto it = field.begin();
+		while (it != field.end())
+		{
+			if (!isnan(*it)) norm += (*it)*(*it);
+			*it++;
+		}
+		return sqrt(norm);
+	}
+*/
+	double CylindricalCavity::CalculateDotProductFactor(int bTE, int l, int m, int n, std::vector<double> tKassParticleXP, std::vector<double> anE_normalized, double tThisEventNSamples)
 	{
-		std::vector<std::vector<std::vector<double>>> tAvgDotProductFactor = GetAvgDotProductFactor();
-		tAvgDotProductFactor[l][m][n] = 1. / ( tThisEventNSamples + 1 ) * ( tAvgDotProductFactor[l][m][n] * tThisEventNSamples + GetDotProductFactor(tKassParticleXP, anE_normalized, 0) );  // unit velocity \dot unit theta
+		std::vector<std::vector<std::vector<std::vector<double>>>> tAvgDotProductFactor = GetAvgDotProductFactor();
+		tAvgDotProductFactor[bTE][l][m][n] = 1. / ( tThisEventNSamples + 1 ) * ( tAvgDotProductFactor[bTE][l][m][n] * tThisEventNSamples + GetDotProductFactor(tKassParticleXP, anE_normalized, 0) );  // unit velocity \dot unit theta
 		SetAvgDotProductFactor(tAvgDotProductFactor);
-		return tAvgDotProductFactor[l][m][n];
+		return tAvgDotProductFactor[bTE][l][m][n];
 	}
 
 

Source/Fields/LMCCylindricalCavity.hh

@@ -58,12 +58,13 @@ namespace locust
             virtual double Z_TE(int l, int m, int n, double fcyc) const;
             virtual double Z_TM(int l, int m, int n, double fcyc) const;
             virtual double Integrate(int l, int m, int n, bool teMode, bool eField);
-            virtual std::vector<double> GetDopplerFrequency(int l, int m, int n, std::vector<double> tKassParticleXP);
+            virtual std::vector<double> GetDopplerFrequency(int bTE, int l, int m, int n, std::vector<double> tKassParticleXP);
             virtual std::vector<double> GetNormalizedModeField(int l, int m, int n, std::vector<double> tKassParticleXP, bool includeOtherPols, bool teMode);
             virtual std::vector<std::vector<std::vector<double>>> CalculateNormFactors(int nModes, bool bTE);
             virtual std::vector<double> GetTE_E(int l, int m, int n, double r, double theta, double z, bool includeOtherPols);
             virtual std::vector<double> GetTM_E(int l, int m, int n, double r, double theta, double z, bool includeOtherPols);
-        	virtual double CalculateDotProductFactor(int l, int m, int n, std::vector<double> tKassParticleXP, std::vector<double> anE_normalized, double tThisEventNSamples);
+	    //double TotalFieldNorm(std::vector<double> field);
+            virtual double CalculateDotProductFactor(int bTE, int l, int m, int n, std::vector<double> tKassParticleXP, std::vector<double> anE_normalized, double tThisEventNSamples);
             virtual double GetDotProductFactor(std::vector<double> tKassParticleXP, std::vector<double> anE_normalized, bool IntermediateFile);
             virtual bool InVolume(std::vector<double> tKassParticleXP);
             virtual void CheckNormalization(int nModes);

Source/Fields/LMCField.cc

@@ -14,7 +14,7 @@ namespace locust
     Field::Field():
         fnPixels( 100 ),
         fCentralFrequency(1.63e11),
-		fAvgDotProductFactor( 0. ),
+		fAvgDotProductFactor( {{{{0.}}}} ),
         fNModes( 2 ),
         fR( 0.18 ),
         fL( 3.0 ),
@@ -45,19 +45,23 @@ namespace locust
     		SetNPixels(aParam["n-pixels"]().as_int());
     	}
 
-    	if( aParam.has( "plot-mode-maps" ) )
-    	{
-    		SetPlotModeMaps(aParam["plot-mode-maps"]().as_bool());
-    	}
-
-    	fAvgDotProductFactor.resize(fNModes);
-    	for (unsigned m=0; m<fNModes; m++)
-    	{
-    		fAvgDotProductFactor[m].resize(fNModes);
-        	for (unsigned n=0; n<fNModes; n++)
-        	{
-        		fAvgDotProductFactor[m][n].resize(fNModes);
-        	}
+        if( aParam.has( "plot-mode-maps" ) ) 
+        {   
+                SetPlotModeMaps(aParam["plot-mode-maps"]().as_bool());
+        }   
+
+	fAvgDotProductFactor.resize(2);
+	for (unsigned bTE=0; bTE<2; bTE++)
+	{
+    		fAvgDotProductFactor[bTE].resize(fNModes);
+		for(unsigned l=0; l<fNModes; l++)
+		{
+			fAvgDotProductFactor[bTE][l].resize(fNModes);
+    			for (unsigned m=0; m<fNModes; m++)
+    			{
+    				fAvgDotProductFactor[bTE][l][m].resize(fNModes);
+			}
+		}
     	}
 
 
@@ -87,12 +91,12 @@ namespace locust
     	fModeNormFactorTM = aNormFactor;
     }
 
-    std::vector<std::vector<std::vector<double>>> Field::GetAvgDotProductFactor()
+    std::vector<std::vector<std::vector<std::vector<double>>>> Field::GetAvgDotProductFactor()
     {
     	return fAvgDotProductFactor;
     }
 
-    void Field::SetAvgDotProductFactor(std::vector<std::vector<std::vector<double>>> aFactor)
+    void Field::SetAvgDotProductFactor(std::vector<std::vector<std::vector<std::vector<double>>>> aFactor)
     {
     	fAvgDotProductFactor = aFactor;
     }

Source/Fields/LMCField.hh

@@ -74,13 +74,13 @@ namespace locust
             virtual double Z_TM(int l, int m, int n, double fcyc) const {return {0.};};
             virtual double Z_TE(int l, int m, int n, double fcyc) const {return {0.};};
             virtual double Integrate(int l, int m, int n, bool teMode, bool eField){return 0.;};
-            virtual std::vector<double> GetDopplerFrequency(int l, int m, int n, std::vector<double> tKassParticleXP) {return {0.};};
+            virtual std::vector<double> GetDopplerFrequency(int bTE, int l, int m, int n, std::vector<double> tKassParticleXP) {return {0.};};
             virtual std::vector<double> GetNormalizedModeField(int l, int m, int n, std::vector<double> tKassParticleXP, bool includeOtherPols, bool teMode) {return {0.};};
             double NormalizedEFieldMag(std::vector<double> field);
             virtual std::vector<std::vector<std::vector<double>>> CalculateNormFactors(int nModes, bool bTE) {return {{{0.}}};};
             virtual std::vector<double> GetTE_E(int l, int m, int n, double r, double theta, double z, bool includeOtherPols) {return {0.};};
             virtual std::vector<double> GetTM_E(int l, int m, int n, double r, double theta, double z, bool includeOtherPols) {return {0.};};
-            virtual double CalculateDotProductFactor(int l, int m, int n, std::vector<double> tKassParticleXP, std::vector<double> aTE_E_normalized, double tThisEventNSamples) {return {0.};};
+            virtual double CalculateDotProductFactor(int bTE, int l, int m, int n, std::vector<double> tKassParticleXP, std::vector<double> aTE_E_normalized, double tThisEventNSamples) {return {0.};};
             virtual double GetDotProductFactor(std::vector<double> tKassParticleXP, std::vector<double> aTE_E_normalized, bool IntermediateFile) {return {0.};};
             virtual bool InVolume(std::vector<double> tKassParticleXP){return false;};
             virtual void CheckNormalization(int nModes){};
@@ -92,8 +92,8 @@ namespace locust
             void SetNormFactorsTE(std::vector<std::vector<std::vector<double>>> aNormFactor);
             std::vector<std::vector<std::vector<double>>> GetNormFactorsTM();
             void SetNormFactorsTM(std::vector<std::vector<std::vector<double>>> aNormFactor);
-            std::vector<std::vector<std::vector<double>>> GetAvgDotProductFactor();
-            void SetAvgDotProductFactor(std::vector<std::vector<std::vector<double>>> aFactor);
+            std::vector<std::vector<std::vector<std::vector<double>>>> GetAvgDotProductFactor();
+            void SetAvgDotProductFactor(std::vector<std::vector<std::vector<std::vector<double>>>> aFactor);
             double GetCentralFrequency();
             void SetCentralFrequency( double aCentralFrequency );
             int GetNPixels();
@@ -129,7 +129,7 @@ namespace locust
             double fY;
             double fCENTER_TO_SHORT;
             double fCENTER_TO_ANTENNA;
-            std::vector<std::vector<std::vector<double>>> fAvgDotProductFactor;
+            std::vector<std::vector<std::vector<std::vector<double>>>> fAvgDotProductFactor;
             bool fPlotModeMaps;