AmplitudeManager.h

Go to the documentation of this file.

#if !defined( AMPLITUDEMANAGER )
#define AMPLITUDEMANAGER

//******************************************************************************
// This file is part of AmpTools, a package for performing Amplitude Analysis
// 
// Copyright Trustees of Indiana University 2010, all rights reserved
// 
// This software written by Matthew Shepherd, Ryan Mitchell, and 
//                  Hrayr Matevosyan at Indiana University, Bloomington
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
//    notice and author attribution, this list of conditions and the
//    following disclaimer. 
// 2. Redistributions in binary form must reproduce the above copyright
//    notice and author attribution, this list of conditions and the
//    following disclaimer in the documentation and/or other materials
//    provided with the distribution.
// 3. Neither the name of the University nor the names of its contributors
//    may be used to endorse or promote products derived from this software
//    without specific prior written permission.
// 
// Creation of derivative forms of this software for commercial
// utilization may be subject to restriction; written permission may be
// obtained from the Trustees of Indiana University.
// 
// INDIANA UNIVERSITY AND THE AUTHORS MAKE NO REPRESENTATIONS OR WARRANTIES, 
// EXPRESS OR IMPLIED.  By way of example, but not limitation, INDIANA 
// UNIVERSITY MAKES NO REPRESENTATIONS OR WARRANTIES OF MERCANTABILITY OR 
// FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THIS SOFTWARE OR 
// DOCUMENTATION WILL NOT INFRINGE ANY PATENTS, COPYRIGHTS, TRADEMARKS, 
// OR OTHER RIGHTS.  Neither Indiana University nor the authors shall be 
// held liable for any liability with respect to any claim by the user or 
// any other party arising from use of the program.
//******************************************************************************


#include <map>
#include <iostream>
#include <vector>
#include <string>
#include <complex>

#include "IUAmpTools/IntensityManager.h"
#include "IUAmpTools/Amplitude.h"
#include "IUAmpTools/AmpParameter.h"
#include "IUAmpTools/DataReader.h"
#include "IUAmpTools/AmpVecs.h"
#include "IUAmpTools/ConfigurationInfo.h"

#include "GPUManager/GPUCustomTypes.h"

#ifdef GPU_ACCELERATION
#include "GPUManager/GPUManager.h"
#endif //GPU_ACCELERATION

class Kinematics;
class NormIntInterface;

using namespace std;

class AmplitudeManager : public IntensityManager
{
  
public:
  
  AmplitudeManager( const vector< string >& finalState, 
                    const string& reactionName = ""); 
  
  ~AmplitudeManager();
  
  Type type() const { return kAmplitude; }
  
  unsigned int maxFactorStoragePerEvent() const;
  
  unsigned int termStoragePerEvent() const;
  
  bool calcTerms( AmpVecs& ampVecs ) const;
  
  double calcIntensities( AmpVecs& ampVecs ) const;

  double calcSumLogIntensity( AmpVecs& ampVecs ) const;
  
  void calcIntegrals( AmpVecs& ampVecs, int iNGenEvents ) const;

  const vector< vector< int > >& getPermutations( const string& name ) const;
  
  const vector< const Amplitude* >& getFactors( const string& name ) const;

  bool hasTermWithFreeParam() const;

  //
  // The functions below modify the state of the AmplitudeManager
  //
  
  void setupFromConfigurationInfo( const ConfigurationInfo* configInfo );
 
  void addAmpFactor( const string& ampName, const string& factorName,
                     const vector< string >& args, const string& sum = "",
                     const string& scale = "1.0" );

  void addAmpPermutation( const string& ampName, const vector< int >& permutation );

  void registerAmplitudeFactor( const Amplitude& defaultAmplitude );
  
  void setParPtr( const string& termName, const string& parName,
                  const double* ampParPtr );
  
  void setParValue( const string& termName, const string& parName,
                    double ampParValue );
  
  void updatePar( const string& parName ) const;
  
  void setOptimizeParIteration( bool flag ) { m_optimizeParIteration = flag; }

  
private:
  
  // recursive routine to symmetrize final state
  void generateSymmetricCombos( const vector< pair< int, int > >& prevSwaps,
                               vector< vector< pair< int, int > > > remainingSwaps,
                               const vector< int >& defaultOrder );
  
  // amplitude name -> vector of amplitude factors
  map< string, vector< const Amplitude* > > m_mapNameToAmps;

  // amplitude name -> vector of particle permutations
  // by default this starts as m_symmCombos for each amp
  map< string, vector< vector< int > > > m_ampPermutations;
  
  // a vector to hold all of the symmetric combinations of final
  // state particles
  vector< vector< int > > m_symmCombos;

  // check to see if amplitudes have already been symmetrized so user can
  // be warned if additional amplitudes are added after symmetrization is done
  bool m_symmetrizeCalled;

  // this holds "default" amplitudes for all registered amplitudes
  map< string, Amplitude* > m_registeredFactors;

  // the sum that each amplitude belongs to indexed on amplitude index
  vector< string > m_ampSum;
  
  // a 2-D vector to track whether or not the two particular amplitudes interfere
  vector< vector< bool > > m_sumCoherently;
  
  // vector to short-cut recomputation of terms with all fixed factors
  vector< bool > m_vbIsAmpFixed;
  
  // some internal members to optimize amplitude recalculation
  bool m_optimizeParIteration;
  mutable map< const Amplitude*, int > m_ampIteration;
  mutable map< AmpVecs*, map< const Amplitude*, int > > m_dataAmpIteration;
};

#endif