EfieldInterpolator Class Reference

#include <EfieldInterpolator.h>

Inheritance diagram for EfieldInterpolator:

Collaboration diagram for EfieldInterpolator:

Public Member Functions
	EfieldInterpolator (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~EfieldInterpolator ()
void	setLayer (int layer)
StatusCode	loadTCADlist (const std::string &TCADfileListToLoad)
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
const std::string	loadTCADfiles (const std::string &targetList="")
const std::string	createInterpolationFromTCADtree (const std::string &fTCAD)
bool	initializeFromFile (const std::string &finpath)
bool	initializeFromDirectory (const std::string &fpath)
double	estimateEfield (std::vector< double > vvol, const std::vector< double > &vflu, const std::vector< std::vector< double > > &vfluvvol, double aimFlu, double aimVol, const std::string &prepend="", bool debug=false)
double	estimateEfieldInvDistance (const std::vector< double > &vvol, const std::vector< double > &vflu, const std::vector< std::vector< double > > &vfluvvol, double aimFlu, double aimVol, double measure=1.)
TH1D *	createEfieldProfile (double aimFluence, double aimVoltage)
TH1D *	getEfield (double aimFluence, double aimVoltage)
TH1D *	loadEfieldFromDat (const std::string &fname, bool fillEdges=true)
void	reliabilityCheck (double aimFluence, const std::vector< double > &fluences, double aimVoltage, const std::vector< double > &voltages)
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static void	scaleIntegralTo (TH1 *hin, double aimInt, int first=1, int last=-1)

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
std::vector< std::vector< TString > >	list_files (const TString &fileList_TCADsamples)
int	fillXYvectors (std::vector< double > vLoop, int ifix, const std::vector< std::vector< double > > &v2vsv1, std::vector< double > &xx, std::vector< double > &yy, bool regularOrder=true)
void	fillEdgeValues (TH1D *hin)
bool	isInterpolation (const std::vector< double > &vval, double aimval)
bool	isInterpolation (std::vector< double > *vval, double aimval)
double	estimateEfieldLinear (double aimVoltage)
void	saveTGraph (std::vector< double > vvol, std::vector< double > vflu, std::vector< std::vector< double > > vfluvvol, double aimFlu, double aimVol, const std::string &prepend, bool skipNegative=true)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Static Private Member Functions
static double	extrapolateLinear (double x1, double y1, double x2, double y2, double xaim)
static double	relativeDistance (double x1, double x2)
static double	relativeDistance (double x1, double y1, double x2, double y2)

Private Attributes
Gaudi::Property< bool >	m_initialized
Gaudi::Property< bool >	m_useSpline
Gaudi::Property< int >	m_sensorDepth
interpolationMethod	m_efieldOrigin
TH1D *	m_efieldProfile {}
std::string	m_fInter
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 35 of file EfieldInterpolator.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

EfieldInterpolator()

EfieldInterpolator::EfieldInterpolator	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 27 of file EfieldInterpolator.cxx.

                                                                                                             :
  AthAlgTool(type, name, parent),
  m_efieldOrigin(interspline) {}

~EfieldInterpolator()

EfieldInterpolator::~EfieldInterpolator ( )

virtualdefault

Member Function Documentation

createEfieldProfile()

TH1D * EfieldInterpolator::createEfieldProfile	(	double	aimFluence,
		double	aimVoltage
	)

Definition at line 678 of file EfieldInterpolator.cxx.

                                                                                  {
  if (!m_initialized) {
    ATH_MSG_WARNING("ERROR: EfieldInterpolator not properly intialized from " << m_fInter);
    return nullptr;
  }
  if (aimFluence > 1e12) aimFluence = aimFluence / 1e14; //adapt units - TCAD files save 20 for 20e14 neq/cm2
  TString title = "hefieldz";
  TString info = "#Phi=";
  info += TString::Format("%.2f", aimFluence);
  info += "-U=";
  info += TString::Format("%.0f", aimVoltage);
  info += ";Pixeldepth z [#mum]";
  info += ";E [V/cm]";
  m_efieldProfile = new TH1D(title, info, m_sensorDepth, -0.5, m_sensorDepth + 0.5);
  double pixeldepth;
  std::vector<double>         xfluence;
  std::vector<double>         yvoltage;
  std::vector<std::vector<double> >    efieldfluvol;
  TFile* ftreeInterpolation = TFile::Open(m_fInter.c_str());
  TTreeReader myReader("tz", ftreeInterpolation);
  TTreeReaderValue<std::vector<double> >       involtage(myReader, "yvoltage");
  TTreeReaderValue<std::vector<double> >       influence(myReader, "xfluence");
  TTreeReaderValue<std::vector<std::vector<double> > >  inefield(myReader, "efieldfluvol");
  TTreeReaderValue<double>            inpixeldepth(myReader, "pixeldepth");
  int ientry = 0;
  while (myReader.Next()) {
    ATH_MSG_DEBUG("TTree entry: " << ientry);
    pixeldepth = *inpixeldepth;
    xfluence = *influence;
    yvoltage = *involtage;
    efieldfluvol = *inefield;
    // Check if interpolation is reliable based on given TCAD samples
    if (ientry < 2) {
      reliabilityCheck(aimFluence, xfluence, aimVoltage, yvoltage);
    }
    double aimEf = 0.;
    switch (m_efieldOrigin) {
    case interspline: aimEf = estimateEfield(yvoltage, xfluence, efieldfluvol, aimFluence, aimVoltage);
      break;
 
    case interinvdist: aimEf = estimateEfieldInvDistance(yvoltage, xfluence, efieldfluvol, aimFluence, aimVoltage);
      break;
 
    case linearField: m_useSpline = false;
      aimEf = estimateEfield(yvoltage, xfluence, efieldfluvol, aimFluence, aimVoltage);
      break;
 
    case TCAD: aimEf = estimateEfieldLinear(aimVoltage);
      if (aimEf < 0.) ATH_MSG_ERROR("TCAD E field negative at" << pixeldepth << " !");
      break;
    }
 
    if (aimEf < 0.) {
      if (m_useSpline) {
        TString debugName = "negativeSplineZ";
        debugName += TString::Format("%.0f", pixeldepth);
        aimEf = estimateEfield(yvoltage, xfluence, efieldfluvol, aimFluence, aimVoltage, debugName.Data(), true);
        ATH_MSG_INFO("InterpolatorMessage: linearly interpolated e=" << aimEf << ", z=" << pixeldepth << " Phi=," << aimFluence << " U=" << aimVoltage);
        m_useSpline = false;
        m_efieldOrigin = linearField; // not as good as interpolation
      } else {
        TString debugName = "negativeLinearZ";
        debugName += TString::Format("%.0f", pixeldepth);
        aimEf = estimateEfield(yvoltage, xfluence, efieldfluvol, aimFluence, aimVoltage, debugName.Data(), true);
        ATH_MSG_ERROR("InterpolatorMessage: spline and linear interpolation failed => InvDistWeighhted  e=" << aimEf << ", z=" << pixeldepth << " Phi=," << aimFluence << " U=" << aimVoltage);
        m_efieldOrigin = interinvdist; // not as good as interpolation (linear or spline) but guaranteed to be positive
      }
 
      myReader.Restart();
    }
    m_efieldProfile->SetBinContent(m_efieldProfile->FindBin(pixeldepth), aimEf);
    ientry++;
  }
  ftreeInterpolation->Close();
  //Check edge values
  ATH_MSG_DEBUG("Fill edges");
  fillEdgeValues(m_efieldProfile);
  scaleIntegralTo(m_efieldProfile, aimVoltage * 10000, 2, m_sensorDepth);  //exclude first and last bin
  TString newtitle = m_efieldProfile->GetTitle();
  switch (m_efieldOrigin) {
  case interspline: newtitle += " spline";
    break;
 
  case interinvdist: newtitle += " inverse distance";
    break;
 
  case linearField: newtitle += " linear";
    break;
 
  case TCAD: newtitle += " TCAD";
    break;
  }
 
  m_efieldProfile->SetTitle(newtitle.Data());
  ATH_MSG_DEBUG("Created Efield");
  m_efieldProfile->SetLineWidth(3);
  m_efieldProfile->SetLineStyle(2);
  m_efieldProfile->SetLineColor(4);
  m_efieldProfile->SetStats(0);
  return m_efieldProfile;
}

createInterpolationFromTCADtree()

const std::string EfieldInterpolator::createInterpolationFromTCADtree

(

const std::string &

fTCAD

)

Definition at line 364 of file EfieldInterpolator.cxx.

                                                                                          {
  TString tmpfinter = fTCAD;
 
  tmpfinter.ReplaceAll("toTTree", "toInterpolationTTree");
  TFile* faim = new TFile(tmpfinter, "Recreate");
  TFile* ftreeTCAD = new TFile(fTCAD.c_str());
  TTreeReader myReader("tcad", ftreeTCAD);
  TTreeReaderValue<double>        involtage(myReader, "voltage");
  TTreeReaderValue<double>        influence(myReader, "fluence");
  TTreeReaderValue<std::vector<double> >   inefield(myReader, "efield");
  TTreeReaderValue<std::vector<int> >      inpixeldepth(myReader, "pixeldepth");
  // Get Data from TCAD tree
  // Loop tree once to initialize values
  // Finding which values for fluence and bias voltage exist
  // do not hardcode values to maintain compatibility with new simulations available
  std::vector<double> allFluences; // serves as x-axis
  std::vector<double> allVoltages; // serves as y-axis
  std::vector<double> allEfield;
  int ne = 0;
  double tmpflu, tmpvol;
  while (myReader.Next()) {
    tmpflu = *influence;
    tmpvol = *involtage;
    //Check if (double) value of fluence and bias voltage is already saved: if not save
    if (std::find_if(allFluences.begin(), allFluences.end(), [&tmpflu](const double& b) {
      return(std::abs(tmpflu - b) < 1E-6);
    }) == allFluences.end()) allFluences.push_back(tmpflu);
    if (std::find_if(allVoltages.begin(), allVoltages.end(), [&tmpvol](const double& b) {
      return(std::abs(tmpvol - b) < 1E-6);
    }) == allVoltages.end()) allVoltages.push_back(tmpvol);
    ne++;
  }
  //put into ascending order
  std::sort(allFluences.begin(), allFluences.end());
  std::sort(allVoltages.begin(), allVoltages.end());
  for (double & allFluence : allFluences) ATH_MSG_DEBUG("fluences recorded: " << allFluence);
  for (double & allVoltage : allVoltages) ATH_MSG_DEBUG("voltages recorded: " << allVoltage);
  std::vector<double> tmpef;
  myReader.Restart(); //available from ROOT 6.10.
  //Exclude TCAD efield values close to sensor edge
  int leftEdge = 3; //unify maps - different startting points from z=1 to z=2 and z=3. Simulation not reliable at edges,
                    // skip first and last
  int rightEdge = m_sensorDepth - 2;
  std::vector<int> tmpz;
  int nz = rightEdge - leftEdge;
  // Temporary saving to avoid nesting tree loops
  // ie read all z values at once -> add to each branch-param dimension for z
  std::vector<double>         zpixeldepth(nz, -1);
  std::vector<std::vector<double> >    zfluence(nz, std::vector<double>(ne, -1));
  std::vector<std::vector<double> >    zvoltage(nz, std::vector<double>(ne, -1));
  std::vector<std::vector<double> >    zefield(nz, std::vector<double>(ne, -1));
  std::vector<std::vector<std::vector<double> > > zefieldmap(nz, std::vector<std::vector<double> >(allFluences.size(), std::vector<double>(allVoltages.size(), -1)));
  int iev = 0;
  ATH_MSG_INFO("Access TTreeReader second time\n");
 
  while (myReader.Next()) {
    tmpz = *inpixeldepth; //Pixeldepth of current TCAD map
    ATH_MSG_DEBUG("Number of available z values = " << tmpz.size());
    if (tmpz.at(0) > leftEdge) ATH_MSG_WARNING("Map starting from high pixeldepth = " << tmpz.at(0) << ". Might trouble readout.");
    for (int iz = leftEdge; iz < rightEdge; iz++) {
      int index = 0;
      //Safety check:
      //files starting from z=1, z=2 or z=3
      //determine correct index to match sensor depth
      ATH_MSG_DEBUG("Access tmpz \n");
      ATH_MSG_DEBUG("Adapt index shift \n");
      while ((tmpz.at(index) != iz) && (index < nz)) {
        ATH_MSG_DEBUG("Adapt possible index shift for missing edge values: pixeldepth tree = " << nz << " current index = " << index);
        index++;
      }
      if (iz % 2 == 0) ATH_MSG_DEBUG("Index " << index << " - iev " << iev << " - iz " << iz);
      tmpflu = *influence;
      tmpvol = *involtage;
      tmpef = *inefield;
      zfluence.at(iz - leftEdge).at(iev) = tmpflu; // assign value to certain pixeldepth(z)
      zvoltage.at(iz - leftEdge).at(iev) = tmpvol;
      zefield.at(iz - leftEdge).at(iev) = tmpef.at(index);
      ((zefieldmap.at(iz - leftEdge)).at(isContainedAt(allFluences, tmpflu))).at(isContainedAt(allVoltages, tmpvol)) = tmpef.at(index);
      ATH_MSG_DEBUG("Event #" << iev << "-z=" << iz << ": fluence =" << tmpflu << " voltage=" << tmpvol << ", E=" << tmpef.at(index));
    }
    iev++;
  }
  ATH_MSG_DEBUG("# Start filling interpolation tree \n");
  //Filling the interpolation tree
  faim->cd();
  TTree* tz_tmp = new TTree("tz", "All TCAD E field simulations stored splitted by pixel depth");
  double pixeldepth = -1.;
  std::vector<double>     fluence;
  std::vector<double>     voltage;
  std::vector<double>     xfluence;
  std::vector<double>     yvoltage;
  std::vector<double>     efield;
  std::vector<std::vector<double> > efieldfluvol;
 
  tz_tmp->Branch("pixeldepth", &pixeldepth);
  tz_tmp->Branch("voltage", &voltage);
  tz_tmp->Branch("fluence", &fluence);
  tz_tmp->Branch("yvoltage", &yvoltage);
  tz_tmp->Branch("xfluence", &xfluence);
  tz_tmp->Branch("efield", &efield);
  tz_tmp->Branch("efieldfluvol", &efieldfluvol);
  for (int iz = leftEdge; iz < rightEdge; iz++) {
    pixeldepth = iz;
    fluence = zfluence.at(iz - leftEdge);
    voltage = zvoltage.at(iz - leftEdge);
    efield = zefield.at(iz - leftEdge);
    efieldfluvol = zefieldmap.at(iz - leftEdge);
    xfluence = allFluences;
    yvoltage = allVoltages;
    ATH_MSG_DEBUG("Fill tree for z =" << iz << " pd=" << pixeldepth);
    faim->cd();
    tz_tmp->Fill();
  }
 
  //Save new Interpolation tree
  faim->cd();
  tz_tmp->Write();
  faim->Close();
  m_fInter = tmpfinter.Data();
  return m_fInter;
}

declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyArrayType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
  }

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                 {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

estimateEfield()

double EfieldInterpolator::estimateEfield	(	std::vector< double >	vvol,
		const std::vector< double > &	vflu,
		const std::vector< std::vector< double > > &	vfluvvol,
		double	aimFlu,
		double	aimVol,
		const std::string &	prepend = "",
		bool	debug = false
	)

Definition at line 551 of file EfieldInterpolator.cxx.

                                                                                                                                                                                                                  {
  ATH_MSG_DEBUG("Estimating efield");
  std::vector<double> evol;          // e field values for fixed voltages inter- or extrapolated to fluence of interest
  std::vector<double> vvolWoEp;      // fixed voltages values for which no extrapolation is used to obatin E field in
                                     // between fluences
  std::vector<double> evolWoEp;
  //Loop the voltages
  for (uint ifix = 0; ifix < vvol.size(); ifix++) {
    std::vector<double> vx;// = new std::vector<double> ;
    std::vector<double> vy;// = new std::vector<double>;
    double efflu = -1.;
    int availableTCADpoints = fillXYvectors(vflu, ifix, vfluvvol, vx, vy);
    ATH_MSG_DEBUG("Number of available TCAD points for voltage " << vvol.at(ifix) << ": " << availableTCADpoints);
    TString name = "FluenceEfield_";
    name += ifix;
    name += "FixVol";
    name += TString::Format("%.0f", vvol.at(ifix));
    name += "-aimFlu";
    name += TString::Format("%.1f", aimFlu);
    name += "-aimVol";
    name += TString::Format("%.0f", aimVol);
 
    TGraph* tmpgr = new TGraph(CastStdVec(vx), CastStdVec(vy));
    tmpgr->SetTitle(name.Data());
    if (isInterpolation(vx, aimFlu)) {
      name += "_ip";
    } else {
      name += "_ep";
    }
    if (m_useSpline) {
      efflu = tmpgr->Eval(aimFlu, nullptr, "S");
    } else {
      efflu = tmpgr->Eval(aimFlu); //linear extrapolation
    }
    if (debug) {
      TString aimFile = m_fInter;
      aimFile.ReplaceAll(".root", "_debug.root");
      aimFile.ReplaceAll(".root", prepend);
      aimFile += name;
      aimFile += ".root";
      tmpgr->SaveAs(aimFile);
    }
    if (isInterpolation(vx, aimFlu)) {
      // try without extrapolation: skip extrapolated values
      vvolWoEp.push_back(vvol.at(ifix));
      evolWoEp.push_back(efflu);
    }
 
    delete tmpgr;
    evol.push_back(efflu); //includes extrapolated values
  }//end loop voltages
 
  //Check for debugging distribution of available E field values in fluence and
  if (debug) {
    saveTGraph(vvol, vflu, vfluvvol, aimFlu, aimVol, prepend);
  }
  // if possible to reach voltage of interest without any extrapolation in previous step, prefer this
  if (isInterpolation(vvolWoEp, aimVol) && vvolWoEp.size() > 1) {
    vvol = vvolWoEp;
    evol = evolWoEp;
  } else {
    ATH_MSG_WARNING("E field created on extrapolation. Please check if reasonable!");
  }
 
  TString name = "VoltageEfield";
  name += "-aimFlu";
  name += TString::Format("%.1f", aimFlu);
  name += "-aimVol";
  name += TString::Format("%.0f", aimVol);
  double aimEf = -1;
  TGraph* tmpgr = new TGraph(CastStdVec(vvol), CastStdVec(evol));
  tmpgr->SetTitle(name.Data());
  if (isInterpolation(vvol, aimVol)) {
    name += "_ip";
  } else {
    name += "_ep";
  }
  if (m_useSpline) {
    aimEf = tmpgr->Eval(aimVol, nullptr, "S");
  } else {
    aimEf = tmpgr->Eval(aimVol); //linear extrapolation
  }
  if (debug) {
    TString aimFile = m_fInter;
    aimFile.ReplaceAll(".root", "_debug.root");
    aimFile.ReplaceAll(".root", prepend);
    aimFile += name;
    aimFile += ".root";
    tmpgr->SaveAs(aimFile);
  }
  delete tmpgr;
  return aimEf;
}

estimateEfieldInvDistance()

double EfieldInterpolator::estimateEfieldInvDistance	(	const std::vector< double > &	vvol,
		const std::vector< double > &	vflu,
		const std::vector< std::vector< double > > &	vfluvvol,
		double	aimFlu,
		double	aimVol,
		double	measure = 1.
	)

Definition at line 526 of file EfieldInterpolator.cxx.

                                                                                                                                                                                                                 {
  ATH_MSG_WARNING("Use interpolation method _Inverse distance weighted_ - guarantees positive E field but no reliable interpolation");
  double weight = 0.;
  double meanEf = 0.;
  double distance = 1.;
  double efEntry = 0.;
  //Loop available efield values for fluence/voltage - take weighted mean
  for (uint ivol = 0; ivol < vvol.size(); ivol++) {
    for (uint iflu = 0; iflu < vflu.size(); iflu++) {
      efEntry = vfluvvol.at(iflu).at(ivol);
      if (efEntry > 0.) { //Otherwise (-1), TCAD not available
        distance = relativeDistance(aimVol, aimFlu, vvol.at(ivol), vflu.at(iflu));
        if (distance < 0.00001) return efEntry;//fluence and voltage almost correpsond to available TCAD simulation
 
        meanEf += efEntry * TMath::Power((1. / distance), measure);
        weight += TMath::Power((1. / distance), measure);
      }
    }
  }
  return(meanEf / weight);
}

estimateEfieldLinear()

double EfieldInterpolator::estimateEfieldLinear ( double  aimVoltage )

private

Definition at line 521 of file EfieldInterpolator.cxx.

                                                                 {
  return aimVoltage / (float) m_efieldProfile->GetNbinsX() * 10000; //10^4 for unit conversion
}

evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extrapolateLinear()

double EfieldInterpolator::extrapolateLinear ( double  x1, double  y1, double  x2, double  y2, double  xaim  )

staticprivate

Definition at line 236 of file EfieldInterpolator.cxx.

                                                                                                    {
  // follow linear extrapolation: y=mx+b
  double delx = x2 - x1;
 
  if (delx == 0) return 0.; // slope not defined
 
  double dely = y2 - y1;
  double b = y1 - (dely / delx) * x1;
  return(xaim * (dely / delx) + b);
}

fillEdgeValues()

void EfieldInterpolator::fillEdgeValues ( TH1D *  hin )

private

Definition at line 781 of file EfieldInterpolator.cxx.

                                                 {
  int nBins = hin->GetNbinsX();
 
  //Check first and last bins if filled
  // if not extrapolate linearly from two neighbouring values
  // empty (or zero) e field values cause unphysical behaviour in ATHENA/Allpix
  for (int i = 5; i > 0; i--) {
    //first bins
    float curval = hin->GetBinContent(i);
    float binii = hin->GetBinContent(i + 1);
    float biniii = hin->GetBinContent(i + 2);
    float bini = hin->GetBinContent(i);
    if ((bini < 0.01 && binii > 0.01 && biniii > 0.01) || ((biniii - binii) / (float) binii * (binii - bini) / (float) binii < -0.2)) {//either neighbour filled and bin negative, or edge detected, i.e.  slope changes sign and relatively larger than middle entry
      bini = extrapolateLinear(i + 1, binii, i + 2, biniii, i);
      if (bini > 0) {
        hin->SetBinContent(i, bini);
      } else {
        ATH_MSG_WARNING("Could not correct bin " << i << " for zero or edge ");
        if (curval <= 0.) hin->SetBinContent(i, 1.); //avoid negative Efield
      }
    } else {
      ATH_MSG_INFO("No need to fill edge bin: " << i);
    }
    //Last bins = right hand edge
    curval = hin->GetBinContent(nBins + 1 - i);
    binii = hin->GetBinContent(nBins + 1 - i - 1);
    biniii = hin->GetBinContent(nBins + 1 - i - 2);
    bini = hin->GetBinContent(nBins + 1 - i);
    if ((bini < 0.01 && binii > 0.01 && biniii > 0.01) || ((biniii - binii) / (float) binii * (binii - bini) / (float) binii < -0.2)) {//left neighbour filled and bin below negative or slope changes sign and magnitude
      bini = extrapolateLinear(nBins + 1 - i - 2, hin->GetBinContent(nBins + 1 - i - 2), nBins + 1 - i - 1, hin->GetBinContent(nBins + 1 - i - 1), nBins + 1 - i);
      if (bini > 0.) {
        hin->SetBinContent(nBins + 1 - i, bini);
      } else {
        ATH_MSG_WARNING("Could not correct bin" << nBins + 1 - i << " for zero or edge ");
        if (curval <= 0.) hin->SetBinContent(nBins + 1 - i, 1.); //avoid negative Efield
      }
    } else {
      ATH_MSG_INFO("No need to fill edge bin: " << (nBins - i));
    }
  }
}

fillXYvectors()

int EfieldInterpolator::fillXYvectors ( std::vector< double >  vLoop, int  ifix, const std::vector< std::vector< double > > &  v2vsv1, std::vector< double > &  xx, std::vector< double > &  yy, bool  regularOrder = true  )

private

Definition at line 487 of file EfieldInterpolator.cxx.

                                                                                                                                                                                      {
  yy.clear();
  xx.clear();
  int nfills = 0;
  if (regularOrder) {
    for (uint ie = 0; ie < v2vsv1.size(); ie++) {
      double ef = v2vsv1.at(ie).at(ifix); // different fluences for voltage ifix
      if (ef > 0) {
        yy.push_back(ef);
        xx.push_back(vLoop.at(ie));
        nfills++;
      } else {
        ATH_MSG_DEBUG("E field value not available for Phi=" << vLoop.at(ie) << " index Vol= " << ifix);
        //Values not ordered in a regular fluence-bias voltage grid
      }
    }
  } else {
    for (uint ie = 0; ie < v2vsv1.at(0).size(); ie++) {
      double ef = v2vsv1.at(ifix).at(ie);
      if (ef > 0) {
        yy.push_back(ef);
        xx.push_back(vLoop.at(ie));
        nfills++;
      } else {
        ATH_MSG_DEBUG("E field value not available for Phi=" << vLoop.at(ifix) << " U=" << vLoop.at(ie));
        //Values not ordered in a regular fluence-bias voltage grid
      }
    }
  }
 
  return nfills;
}

finalize()

StatusCode EfieldInterpolator::finalize ( )

overridevirtual

Definition at line 38 of file EfieldInterpolator.cxx.

                                        {
  ATH_MSG_DEBUG("Finalizing " << name() << "...");
  return StatusCode::SUCCESS;
}

getEfield()

TH1D * EfieldInterpolator::getEfield	(	double	aimFluence,
		double	aimVoltage
	)

Definition at line 825 of file EfieldInterpolator.cxx.

                                                                        {
  if (m_initialized) {
    m_efieldProfile = createEfieldProfile(aimFluence, aimVoltage);
  } else {
    ATH_MSG_WARNING("EfieldInterpolator not initialized! Not able to produce E field.");
  }
  return m_efieldProfile;
}

initialize()

StatusCode EfieldInterpolator::initialize ( )

overridevirtual

Definition at line 33 of file EfieldInterpolator.cxx.

                                          {
  ATH_MSG_DEBUG("Initializing " << name() << "...");
  return StatusCode::SUCCESS;
}

initializeFromDirectory()

bool EfieldInterpolator::initializeFromDirectory

(

const std::string &

fpath

)

Definition at line 93 of file EfieldInterpolator.cxx.

                                                                       {
  //similar to function  loadTCADfiles()
  //instead of reading file list, list files from directory fpath and create file listing information
 
  //retrieve fluence and bias voltage from file name (including path, directory names fluence value)
  //skip files which do not dollow naming declaration
 
  //Create textfile for tmp storage
  std::ofstream efieldscalib;
  efieldscalib.open("listOfEfields.txt");
  TPRegexp rvo("\\b-[0-9](\\w+)V\\b");
  TPRegexp rfl("\\bfl([\\w.]+)e[0-9]{1,2}");
  TString ext = ".dat";
  TString sflu, svol, fullpath;
  TSystemDirectory dir((TString)fpath, (TString)fpath);
  TList* files = dir.GetListOfFiles();
  if (files) {
    TSystemFile* file;
    TString fname;
    TIter next(files);
    while ((file = (TSystemFile*) next())) {
      fname = file->GetName();
      if (fname.BeginsWith("fl") && file->IsDirectory()) {
        TString deeppath = fpath;
        deeppath += fname;
        deeppath += "/reference/";
        TSystemDirectory deepdir(deeppath, deeppath);
        TList* deepfiles = deepdir.GetListOfFiles();
        if (deepfiles) {
          TSystemFile* deepfile;
          TString deepfname;
          TIter deepnext(deepfiles);
          while ((deepfile = (TSystemFile*) deepnext())) {
            deepfname = deepfile->GetName();
            if (!deepfile->IsDirectory() && deepfname.EndsWith(ext)) {
              svol = deepfname(rvo);
              svol.ReplaceAll("-", "");
              svol.ReplaceAll("V", "");
              sflu = deeppath(rfl);
              sflu.ReplaceAll("fl", "");
              fullpath = deeppath;
              fullpath += deepfname;
              if (!deepfname.Contains("pruned")) {
                if (!sflu.IsFloat()) {
                  ATH_MSG_INFO("EfieldInterpolator load from directory - could not resolve fluence from " << fullpath);
                  continue;
                }
                if (!svol.IsFloat()) {
                  ATH_MSG_INFO("EfieldInterpolator load from directory - could not resolve voltage from " << fullpath);
                  continue;
                }
              } else {
                ATH_MSG_INFO("Skip pruned files: " << fullpath);
                continue;
              }
              efieldscalib << fullpath << " " << sflu << " " << svol << std::endl;
            }
          }
        }
      }
    }
  }
  efieldscalib.close();
  bool success = initializeFromFile("listOfEfields.txt");
  if (success) ATH_MSG_INFO("Initialized from directory");
  return success;
}

initializeFromFile()

bool EfieldInterpolator::initializeFromFile

(

const std::string &

finpath

)

Definition at line 162 of file EfieldInterpolator.cxx.

                                                                    {
  TString fpath = finpath;
 
  m_initialized = false;
  TString fTCAD = "";
  if (fpath.EndsWith(".txt")) {
    //File list path, fluence and bias voltage of TCAD simulation as plain text
    fTCAD = loadTCADfiles(fpath.Data());
    ATH_MSG_INFO("Loaded file " << fpath << " - all maps accumulated in " << fTCAD);
    m_fInter = createInterpolationFromTCADtree(fTCAD.Data());
    ATH_MSG_INFO("created interpolation tree ");
    m_initialized = true;
    ATH_MSG_INFO("Loaded from .txt file");
  } else {
    if (fpath.EndsWith("toTTree.root")) {
      //File list TCAD efield maps as leaves
      m_fInter = createInterpolationFromTCADtree(fpath.Data());
      m_initialized = true;
    } else {
      if (fpath.EndsWith(".root")) {
        //File list is already transformed to tree
        m_fInter = fpath;
        m_initialized = true;
      }
    }
  }
  ATH_MSG_INFO("Interpolation has been initialized from file " << m_fInter << " - successful " << m_initialized);
  return m_initialized;
}

inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

isInterpolation() [1/2]

bool EfieldInterpolator::isInterpolation ( const std::vector< double > &  vval, double  aimval  )

inlineprivate

Definition at line 89 of file EfieldInterpolator.h.

  {return(vval.front() <= aimval && aimval <= vval.back());};

isInterpolation() [2/2]

bool EfieldInterpolator::isInterpolation ( std::vector< double > *  vval, double  aimval  )

inlineprivate

Definition at line 91 of file EfieldInterpolator.h.

  {return(vval->front() <= aimval && aimval <= vval->back());};

list_files()

std::vector< std::vector< TString > > EfieldInterpolator::list_files ( const TString &  fileList_TCADsamples )

private

Definition at line 334 of file EfieldInterpolator.cxx.

                                                                                                 {
  std::vector<std::vector<TString> > filelist;
  TString tmpname = "";
  TString tmpfluence = "";
  TString tmpvolt = "";
  std::vector<TString> vstr;
  std::ifstream in;
  ATH_MSG_DEBUG("Try to open: " << fileList_TCADsamples.Data());
  in.open(fileList_TCADsamples);
  while (1) {
    in >> tmpname >> tmpfluence >> tmpvolt;
    if (!in.good()) break;
    if (tmpname.BeginsWith('#')) continue;
    if (tmpname.EndsWith(".dat")) {
      vstr.push_back(tmpname);
      vstr.push_back(tmpfluence);
      vstr.push_back(tmpvolt);
      filelist.push_back(vstr);
      ATH_MSG_DEBUG("Found and load:" << tmpfluence.Atof() << " neq/cm2 " << tmpvolt.Atof() << "V - " << tmpname.Data());
      vstr.clear();
    } else {
      ATH_MSG_WARNING("Wrong extension: " << tmpname.Data() << " -- check input ");
    }
  }
  in.close();
  return filelist;
}

loadEfieldFromDat()

TH1D * EfieldInterpolator::loadEfieldFromDat	(	const std::string &	fname,
		bool	fillEdges = true
	)

Definition at line 249 of file EfieldInterpolator.cxx.

                                                                                  {
  TH1D* hefieldz = new TH1D("hefieldz", "hefieldz", m_sensorDepth + 1, -0.5, m_sensorDepth + 0.5);
 
  std::ifstream in;
  in.open(fname);
  TString z, e;
  int nlines = 0;
  ATH_MSG_INFO("Load E field from " << fname);
  while (1) {
    in >> z >> e;
    if (!in.good()) break;
    if (nlines < 3) printf("e=%s=%f, z=%s=%f  \n", e.Data(), e.Atof(), z.Data(), z.Atof());
    nlines++;
    hefieldz->Fill(z.Atof(), e.Atof());
  }
  in.close();
  if (fillEdges) EfieldInterpolator::fillEdgeValues(hefieldz);
  return hefieldz;
}

loadTCADfiles()

const std::string EfieldInterpolator::loadTCADfiles

(

const std::string &

targetList = ""

)

Definition at line 270 of file EfieldInterpolator.cxx.

                                                                             {
  bool isIBL = true;
  TString tl = targetList;
  TString fName = targetList;
 
  fName.ReplaceAll(".txt", "_toTTree.root");
  fName = fName.Remove(0, fName.Last('/') + 1); //Remove prepending path and store in run directory
  TFile* bufferTCADtree = new TFile(fName.Data(), "RECREATE");
 
  if (tl.Length() < 1) {
    tl = "list_TCAD_efield_maps.txt";
    ATH_MSG_WARNING("No List to load! Set default: " << tl.Data());
  }
  std::ifstream in;
  TTree* tcadtree = new TTree("tcad", "All TCAD E field simulations stored as individual events in tree");
  double voltage = -1.;
  double fluence = -1.;
  std::vector<double> efield;
  std::vector<Int_t> pixeldepth;
  tcadtree->Branch("voltage", &voltage, "voltage/D");
  tcadtree->Branch("fluence", &fluence, "fluence/D");
  tcadtree->Branch("efield", &efield);
  tcadtree->Branch("pixeldepth", &pixeldepth);
  //Get vetcor of {filename, fluence, bias voltage}
  std::vector<std::vector<TString> > infile = list_files(tl);
  TString z, e;
  TString tmp = "";
  for (uint ifile = 0; ifile < infile.size(); ifile++) {
    tmp = infile.at(ifile).at(0);
    in.open(infile.at(ifile).at(0));
    // Number format eg 10e14 also 1.2e13
    //fluence = (infile.at(ifile).at(1).ReplaceAll("e14","")).Atof();
    fluence = (infile.at(ifile).at(1)).Atof();
    fluence = fluence * 1e-14; //choose fluence e14 as default unit
    voltage = infile.at(ifile).at(2).Atof();
    Int_t nlines = 0;
    efield.clear();
    pixeldepth.clear();
    while (1) {
      in >> z >> e;
      if (!in.good()) {
        ATH_MSG_DEBUG("Break for file No. " << ifile << ": " << infile.at(ifile).at(0) << " . After " << nlines << " steps");
        break;
      }
      ATH_MSG_DEBUG("Reading input line: fluence=" << (infile.at(ifile).at(1)).Data() << fluence << " voltage=" << voltage << " e=" << e.Atof() << "=" << e.Data() << ", z=" << (int) z.Atof() << "=" << z.Data() << "  in file = " << ifile);
      nlines++;
      efield.push_back(e.Atof());
      pixeldepth.push_back((int) z.Atof());
      if (z.Atof() > 200) isIBL = false; // Pixel depth to huge to be IBL
    }
    bufferTCADtree->cd();
    tcadtree->Fill();
    in.close();
  }
  if (!isIBL) {
    ATH_MSG_INFO("Pixel depth read from file too big for IBL. Set to B layer, depth = 250um\n");
    m_sensorDepth = 250;
  }
  bufferTCADtree->cd();
  tcadtree->Write();
  bufferTCADtree->Close();
  return fName.Data();
}

loadTCADlist()

StatusCode EfieldInterpolator::loadTCADlist

(

const std::string &

TCADfileListToLoad

)

Definition at line 78 of file EfieldInterpolator.cxx.

                                                                               {
  m_efieldOrigin = interspline;
  ATH_MSG_INFO("Load from list " << TCADfileListToLoad);
  if (!initializeFromFile(TCADfileListToLoad)) {
    ATH_MSG_WARNING("ERROR: Initialize failed looking for file " << TCADfileListToLoad);
    //Check if given path links to directory:
    if (!initializeFromDirectory(TCADfileListToLoad)) {
      ;
      return StatusCode::FAILURE;
    }
  }
  ATH_MSG_INFO("Finished loading TCAD list");
  return StatusCode::SUCCESS;
}

msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

relativeDistance() [1/2]

double EfieldInterpolator::relativeDistance ( double  x1, double  x2  )

staticprivate

Definition at line 225 of file EfieldInterpolator.cxx.

                                                                {
  if (x1 == 0.) return 0.;
 
  return((x1 - x2) / x1);
}

relativeDistance() [2/2]

double EfieldInterpolator::relativeDistance ( double  x1, double  y1, double  x2, double  y2  )

staticprivate

Definition at line 232 of file EfieldInterpolator.cxx.

                                                                                      {
  return(std::sqrt(relativeDistance(x1, x2) * relativeDistance(x1, x2) + relativeDistance(y1, y2) * relativeDistance(y1, y2)));
}

reliabilityCheck()

void EfieldInterpolator::reliabilityCheck	(	double	aimFluence,
		const std::vector< double > &	fluences,
		double	aimVoltage,
		const std::vector< double > &	voltages
	)

Definition at line 193 of file EfieldInterpolator.cxx.

                                                                             {
  bool tooLowVolt = true;
  bool tooHighVolt = true;
 
  for (const auto iv : voltages) {
    if (aimVoltage < iv) tooHighVolt = false;
    if (aimVoltage > iv) tooLowVolt = false;
  }
  bool tooLowFlu = true;
  bool tooHighFlu = true;
  for (double fluence : fluences) {
    if (aimFluence < fluence) tooHighFlu = false;
    if (aimFluence > fluence) tooLowFlu = false;
  }
  if (tooLowFlu) ATH_MSG_WARNING(
      "WARNING: The fluence value you specified (" << aimFluence << ") is too low to be reliably interpolated!");
  if (tooLowVolt) ATH_MSG_WARNING(
      "WARNING: The voltage value you specified (" << aimVoltage << ") is too low to be reliably interpolated!");
  if (tooHighFlu) ATH_MSG_WARNING(
      "WARNING: The fluence value you specified (" << aimFluence << ") is too high to be reliably interpolated!");
  if (tooHighVolt) ATH_MSG_WARNING("WARNING: The voltage value you specified (" << aimVoltage << ") is too high to be reliably interpolated!");
 
  // Results from Closure Test
  // TCAD files save 20 for 20e14 neq/cm2
  if (12.2 < aimFluence || aimFluence < 1.) ATH_MSG_WARNING(" WARNING: The fluence value you specified (" << aimFluence << ") is outside the range within it could be reliably interpolated!"); //Based on closure test June 2018 - max fluences available: ... 10 12 15 20
  if (1010. < aimVoltage || aimVoltage < 79.) ATH_MSG_WARNING(" WARNING: The voltage value you specified (" << aimVoltage << ") is outside the range within it could be reliably interpolated!"); }

renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T &  h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

saveTGraph()

void EfieldInterpolator::saveTGraph ( std::vector< double >  vvol, std::vector< double >  vflu, std::vector< std::vector< double > >  vfluvvol, double  aimFlu, double  aimVol, const std::string &  prepend, bool  skipNegative = true  )

private

Definition at line 646 of file EfieldInterpolator.cxx.

                                                                                                                                                                                                     {
  TString name = "VoltageEfield";
 
  name += "-aimFlu";
  name += TString::Format("%.1f", aimFlu);
  name += "-aimVol";
  name += TString::Format("%.0f", aimVol);
  TGraph2D* tmpgr = new TGraph2D();
  tmpgr->GetYaxis()->SetTitle("voltage");
  tmpgr->GetXaxis()->SetTitle("fluence");
  tmpgr->SetTitle(name.Data());
  ATH_MSG_DEBUG("E field values: " << vfluvvol.size() << " x " << vfluvvol.at(0).size() << ", flu(x)" << vflu.size() << ", vol(y)" << vvol.size());
  int npoint = 0;
  for (uint ix = 0; ix < vfluvvol.size(); ix++) {
    for (uint iy = 0; iy < vfluvvol.at(ix).size(); iy++) {
      printf("Set point %i, %f,%f,%f\n", npoint, vflu.at(ix), vvol.at(iy), vfluvvol.at(ix).at(iy));
      if (vfluvvol.at(ix).at(iy) < 0) {
        if (!skipNegative) tmpgr->SetPoint(npoint, vflu.at(ix), vvol.at(iy), -1);
      } else {
        tmpgr->SetPoint(npoint, vflu.at(ix), vvol.at(iy), vfluvvol.at(ix).at(iy));
      }
      npoint++;
    }
  }
  TString aimFile = m_fInter;
  aimFile.ReplaceAll(".root", "_debugAvailableEfieldVals.root");
  aimFile.ReplaceAll(".root", prepend);
  aimFile += name;
  aimFile += ".root";
  tmpgr->SaveAs(aimFile);
}

scaleIntegralTo()

void EfieldInterpolator::scaleIntegralTo ( TH1 *  hin, double  aimInt, int  first = 1, int  last = -1  )

static

Definition at line 221 of file EfieldInterpolator.cxx.

                                                                                     {
  hin->Scale(aimInt / (float) hin->Integral(first, last));
}

setLayer()

void EfieldInterpolator::setLayer

(

int

layer

)

Definition at line 66 of file EfieldInterpolator.cxx.

                                           {
  ATH_MSG_INFO("Create interpolator for layer " << layer);
  if (layer > 0) {
    //it's b layer
    m_sensorDepth = 250;
  } else {
    //IBL
    m_sensorDepth = 200;
  }
  ATH_MSG_INFO("EfieldInterpolator: Default ctor");
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_efieldOrigin

interpolationMethod EfieldInterpolator::m_efieldOrigin

private

Definition at line 81 of file EfieldInterpolator.h.

m_efieldProfile

TH1D* EfieldInterpolator::m_efieldProfile {}

private

Definition at line 82 of file EfieldInterpolator.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_fInter

std::string EfieldInterpolator::m_fInter

private

Definition at line 83 of file EfieldInterpolator.h.

m_initialized

Gaudi::Property<bool> EfieldInterpolator::m_initialized

private

Initial value:

{
    this, "initialized", false, "Flag whether already initalized"
  }

Definition at line 66 of file EfieldInterpolator.h.

m_sensorDepth

Gaudi::Property<int> EfieldInterpolator::m_sensorDepth

private

Initial value:

{
    this, "sensorDepth", 200, "Depth of E fields in sensors in um"
  }

Definition at line 76 of file EfieldInterpolator.h.

m_useSpline

Gaudi::Property<bool> EfieldInterpolator::m_useSpline

private

Initial value:

{
    this, "useSpline", true, "Flag whether to use cubic splines for interpolation"
  }

Definition at line 71 of file EfieldInterpolator.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• EfieldInterpolator.h
• EfieldInterpolator.cxx