#include <AlignmentVariation.h>

Public Member Functions
	AlignmentVariation (std::string quantity, std::string type, std::string version)

void	SetDisk (std::string disk)

void	SetUnits (std::string units)

void	SetTolerance (std::string tolerance)

void	SetNominalVersion (std::string v)

void	SetLabel (std::string label)

void	SetUser (std::string u)

void	SetNominalUser (std::string u)

void	SetCV (std::string cv)

void	SetScaleFactor (double scale_factor)

void	SetMacroSuffix (std::string macro_suffix)

void	AddVariation (std::string variation)

std::string	GetVariedQuantity ()

std::string	GetLabel ()

std::string	GetVariationType ()

std::vector< std::string >	GetVariationNames ()

std::string	GetUnits ()

std::string	GetTolerance ()

std::string	GetNominalHistoFile (std::string beam_mode="nu", std::string loc="LBNEFD", bool fastmc=false)

std::vector< std::string >	GetVariedHistoFiles (std::string beam_mode="nu", std::string loc="LBNEFD", bool fastmc=false)

std::string	GetCV ()

double	GetScaleFactor ()

std::string	GetUser ()

std::string	GetMacroSuffix ()

Detailed Description

Definition at line 6 of file AlignmentVariation.h.

Constructor & Destructor Documentation

AlignmentVariation::AlignmentVariation	(	std::string	quantity,
		std::string	type,
		std::string	version
	)

inline

Definition at line 35 of file AlignmentVariation.h.

                                           {
       
       m_variation_type = type;
       m_quantity_varied = quantity;
       m_label = "";
 
       m_version = version;
       m_nominal_version = version;
 
       m_user = std::getenv("USER");
       m_nominal_user = std::getenv("USER");
 
       m_nominal_plist = "QGSP_BERT";
       m_nominal_current = "200kA";      
 
       m_tolerance = "";
 
       m_cv = "0";
       
       m_scale_factor = 1.0;
 
       m_disk = "/lbne/data/";
 
       m_macro_suffix = "";
     }

Member Function Documentation

void AlignmentVariation::AddVariation ( std::string variation )

inline

Definition at line 104 of file AlignmentVariation.h.

                                            {
       m_variation_names.push_back(variation);
     }

std::string AlignmentVariation::GetCV ( )

inline

Definition at line 216 of file AlignmentVariation.h.

216 { return m_cv; }

AlignmentVariation::m_cv

std::string m_cv

Definition: AlignmentVariation.h:26

std::string AlignmentVariation::GetLabel ( )

inline

Definition at line 112 of file AlignmentVariation.h.

                          {
       return m_label;
     }

std::string AlignmentVariation::GetMacroSuffix ( )

inline

Definition at line 222 of file AlignmentVariation.h.

222 { return m_macro_suffix; }

AlignmentVariation::m_macro_suffix

std::string m_macro_suffix

Definition: AlignmentVariation.h:30

std::string AlignmentVariation::GetNominalHistoFile	(	std::string	beam_mode = `"nu"`,
		std::string	loc = `"LBNEFD"`,
		bool	fastmc = `false`
	)

inline

Definition at line 132 of file AlignmentVariation.h.

                                                                                                        {
 
       std::string temp_current = m_nominal_current;
       if(beam_mode=="antinu") temp_current = "-"+m_nominal_current;
 
       std::string fmc = "";
       if(fastmc) fmc="_fastmc";
 
       std::string the_file = m_disk+"/users/"+m_nominal_user+"/fluxfiles/g4lbne/"+m_nominal_version;
 
       the_file += "/"+m_nominal_plist+"/Nominal/"+temp_current+"/flux/";
       the_file += "histos_g4lbne_"+m_nominal_version+"_"+m_nominal_plist+"_Nominal_"+temp_current+"_"+loc+fmc+".root";
 
       std::cout<<"Nominal file: "<<the_file<<std::endl;
       return the_file;
     }

double AlignmentVariation::GetScaleFactor ( )

inline

Definition at line 218 of file AlignmentVariation.h.

218 { return m_scale_factor; }

AlignmentVariation::m_scale_factor

double m_scale_factor

Definition: AlignmentVariation.h:32

std::string AlignmentVariation::GetTolerance ( )

inline

Definition at line 128 of file AlignmentVariation.h.

                              {
       return m_tolerance;
     }

std::string AlignmentVariation::GetUnits ( )

inline

Definition at line 124 of file AlignmentVariation.h.

                          {
       return m_units;
     }

std::string AlignmentVariation::GetUser ( )

inline

Definition at line 220 of file AlignmentVariation.h.

220 { return m_user; }

AlignmentVariation::m_user

std::string m_user

Definition: AlignmentVariation.h:18

std::vector<std::string> AlignmentVariation::GetVariationNames ( )

inline

Definition at line 120 of file AlignmentVariation.h.

                                              {
       return m_variation_names;
     }

std::string AlignmentVariation::GetVariationType ( )

inline

Definition at line 116 of file AlignmentVariation.h.

                                  {
       return m_variation_type;
     }

std::vector<std::string> AlignmentVariation::GetVariedHistoFiles	(	std::string	beam_mode = `"nu"`,
		std::string	loc = `"LBNEFD"`,
		bool	fastmc = `false`
	)

inline

Definition at line 149 of file AlignmentVariation.h.

                                                                                                                   {
 
       std::string fmc = "";
       if(fastmc) fmc="_fastmc";
       
       std::vector<std::string> the_files;
 
       std::cout<<"Looking up flux histograms for variation "<<m_quantity_varied<<" which has type "<<m_variation_type<<std::endl;
 
       if(m_variation_type=="shift") {
 
         // "shift" type variations don't have multiple variations.  Example: baffle scraping involves shifting the nominal flux by a fraction of the flux from the baffle
 
         std::string temp_current = m_nominal_current;
         if(beam_mode=="antinu") temp_current = "-"+m_nominal_current;
         
         std::string the_file = m_disk+"/users/"+m_user+"/fluxfiles/g4lbne/"+m_version;
         the_file += "/"+m_nominal_plist+"/"+m_quantity_varied+m_units+m_macro_suffix+"/"+temp_current+"/flux/";
         the_file += "histos_g4lbne_"+m_version+"_"+m_nominal_plist+"_"+m_quantity_varied+m_units+m_macro_suffix+"_"+temp_current+"_"+loc+fmc+".root";
         the_files.push_back(the_file);
       }
       else
         for(unsigned int i = 0; i<m_variation_names.size(); i++) {
           std::string variation = m_quantity_varied+m_variation_names[i]+m_units+m_macro_suffix;
         if(m_variation_type=="current")
           variation = m_variation_names[i]+m_units+m_macro_suffix;
 
         std::string the_file = m_disk+"/users/"+m_user+"/fluxfiles/g4lbne/"+m_version;
         
         if(m_variation_type=="macro") {
           std::string temp_current = m_nominal_current;
           if(beam_mode=="antinu") temp_current = "-"+m_nominal_current;
 
           the_file += "/"+m_nominal_plist+"/"+variation+"/"+temp_current+"/flux/";
           the_file += "histos_g4lbne_"+m_version+"_"+m_nominal_plist+"_"+variation+"_"+temp_current+"_"+loc+fmc+".root";
         }
         else if(m_variation_type=="current") {
           std::string current_sign = "";
           if(beam_mode=="antinu") current_sign = "-";
 
           the_file += "/"+m_nominal_plist+"/Nominal/"+current_sign+variation+"/flux/";
           the_file += "histos_g4lbne_"+m_nominal_version+"_"+m_nominal_plist+"_Nominal_"+current_sign+variation+"_"+loc+fmc+".root";
         }
         else if(m_variation_type=="location") {
           std::string temp_current = m_nominal_current;
           if(beam_mode=="antinu") temp_current = "-"+m_nominal_current;
         
           std::cout<<" i "<<i<<" m_variation_names[i] "<<m_variation_names[i]<<std::endl;
           std::cout<<"m_quantity_varied "<<m_quantity_varied<<" loc "<<loc<<std::endl;
           std::string temploc = loc;
           if(m_quantity_varied.find(loc)==0) {
             temploc = m_quantity_varied+m_variation_names[i];
             std::cout<<"temploc "<<temploc<<std::endl;
           }
           the_file += "/"+m_nominal_plist+"/Nominal/"+temp_current+"/flux/";
           the_file += "histos_g4lbne_"+m_nominal_version+"_"+m_nominal_plist+"_Nominal_"+temp_current+"_"+temploc+fmc+".root";
         }
         else {
           std::cout<<"Variation type"<<m_variation_type<<" not yet supported"<<std::endl;
           return the_files;
         }
         the_files.push_back(the_file);
         std::cout<<"varied file "<<the_file<<std::endl;
       }
       return the_files;
     }

std::string AlignmentVariation::GetVariedQuantity ( )

inline

Definition at line 108 of file AlignmentVariation.h.

                                   {
       return m_quantity_varied;
     }

void AlignmentVariation::SetCV ( std::string cv )

inline

Definition at line 92 of file AlignmentVariation.h.

                              {
       m_cv = cv;
     }

void AlignmentVariation::SetDisk ( std::string disk )

inline

Definition at line 63 of file AlignmentVariation.h.

                                  {
      m_disk = disk;
     }

void AlignmentVariation::SetLabel ( std::string label )

inline

Definition at line 80 of file AlignmentVariation.h.

                                    {
       m_label = label;
     }

void AlignmentVariation::SetMacroSuffix ( std::string macro_suffix )

inline

Definition at line 100 of file AlignmentVariation.h.

                                                 {
       m_macro_suffix = macro_suffix;
     }

void AlignmentVariation::SetNominalUser ( std::string u )

inline

Definition at line 88 of file AlignmentVariation.h.

                                      {
       m_nominal_user = u;
     }

void AlignmentVariation::SetNominalVersion ( std::string v )

inline

Definition at line 76 of file AlignmentVariation.h.

                                         {
       m_nominal_version = v;
     }

void AlignmentVariation::SetScaleFactor ( double scale_factor )

inline

Definition at line 96 of file AlignmentVariation.h.

                                              {
       m_scale_factor = scale_factor;
     }

void AlignmentVariation::SetTolerance ( std::string tolerance )

inline

Definition at line 72 of file AlignmentVariation.h.

                                            {
       m_tolerance=tolerance;
     }

void AlignmentVariation::SetUnits ( std::string units )

inline

Definition at line 68 of file AlignmentVariation.h.

                                    {
       m_units=units;
     }

void AlignmentVariation::SetUser ( std::string u )

inline

Definition at line 84 of file AlignmentVariation.h.

                               {
       m_user = u;
     }

Member Data Documentation

std::string AlignmentVariation::m_cv

private

Definition at line 26 of file AlignmentVariation.h.

std::string AlignmentVariation::m_disk

private

Definition at line 28 of file AlignmentVariation.h.

std::string AlignmentVariation::m_label

private

Definition at line 11 of file AlignmentVariation.h.

std::string AlignmentVariation::m_macro_suffix

private

Definition at line 30 of file AlignmentVariation.h.

std::string AlignmentVariation::m_nominal_current

private

Definition at line 22 of file AlignmentVariation.h.

std::string AlignmentVariation::m_nominal_plist

private

Definition at line 21 of file AlignmentVariation.h.

std::string AlignmentVariation::m_nominal_user

private

Definition at line 19 of file AlignmentVariation.h.

std::string AlignmentVariation::m_nominal_version

private

Definition at line 16 of file AlignmentVariation.h.

std::string AlignmentVariation::m_quantity_varied

private

Definition at line 10 of file AlignmentVariation.h.

double AlignmentVariation::m_scale_factor

private

Definition at line 32 of file AlignmentVariation.h.

std::string AlignmentVariation::m_tolerance

private

Definition at line 24 of file AlignmentVariation.h.

std::string AlignmentVariation::m_units

private

Definition at line 13 of file AlignmentVariation.h.

std::string AlignmentVariation::m_user

private

Definition at line 18 of file AlignmentVariation.h.

std::vector<std::string> AlignmentVariation::m_variation_names

private

Definition at line 12 of file AlignmentVariation.h.

std::string AlignmentVariation::m_variation_type

private

Definition at line 8 of file AlignmentVariation.h.

std::string AlignmentVariation::m_version

private

Definition at line 15 of file AlignmentVariation.h.

The documentation for this class was generated from the following file:

g4lbne/BeamSimStudies/700MWToleranceStudy/AlignmentVariation.h

Private Attributes
std::string	m_variation_type

std::string	m_quantity_varied

std::string	m_label

std::vector< std::string >	m_variation_names

std::string	m_units

std::string	m_version

std::string	m_nominal_version

std::string	m_user

std::string	m_nominal_user

std::string	m_nominal_plist

std::string	m_nominal_current

std::string	m_tolerance

std::string	m_cv

std::string	m_disk

std::string	m_macro_suffix

double	m_scale_factor

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation