#include <ComputeStaveServices.h>

Collaboration diagram for ComputeStaveServices:

Public Member Functions
	ComputeStaveServices ()
StaveServices	compute (DetType::Type, DetType::Part, int layerNumber, int nModulesPerStave, int nChipsPerModule, MsgStream &msg) const
int	computeLVGaugeSerial (DetType::Type, DetType::Part, int layerNumber, int nModules, double moduleCurrent, double moduleVoltage, double poweringLoss, double lossInCable, double cableLen, MsgStream &msg) const

Detailed Description

Definition at line 11 of file ComputeStaveServices.h.

Constructor & Destructor Documentation

◆ ComputeStaveServices()

ComputeStaveServices::ComputeStaveServices ( )

inline

Definition at line 14 of file ComputeStaveServices.h.

14{}

Member Function Documentation

◆ compute()

StaveServices ComputeStaveServices::compute	(	DetType::Type	type,
		DetType::Part	part,
		int	layerNumber,
		int	nModulesPerStave,
		int	nChipsPerModule,
		MsgStream &	msg ) const

Definition at line 10 of file ComputeStaveServices.cxx.

{
  msg << MSG::DEBUG << "Computing services for " << DetType::name( type, part) << " layer " << layerNumber 
          << " with " << nModulesPerStave << " modulesPerStave and " 
          << nChipsPerModule << " chipsPerModule" << endmsg;
  
  // The input parameters to the calculation of services per stave.
  // FIXME: They must be eventually stored in the DB, and not hard-wired in the code
 
  const int HV_grouping = 4;  // FIXME: hard-wired number
  const int nDCS_Pixel = 10;  // FIXME: hard-wired number
  const int nDCS_Strip = 10;  // FIXME: hard-wired number
  const int max_SP_group_size = 8;  // FIXME: hard-wired number
 
  // HV part
  int nHV = nModulesPerStave / HV_grouping;
  if (nModulesPerStave % HV_grouping != 0) ++nHV;
 
  // DCS part
  int nDCS;
  if ( type == DetType::Pixel) {
    nDCS = nDCS_Pixel;  // FIXME
  }
  else {
    nDCS = nDCS_Strip;
  }
 
  // Data part
  int Data_grouping = 10;  // FIXME: hard-wired number
  if (layerNumber > 2) Data_grouping = 20;  // FIXME: hard-wired number
  int nChips = nModulesPerStave * nChipsPerModule;
  int nData = nChips/Data_grouping;
  if (nChips % Data_grouping != 0) ++nData;
 
  // LV part
  double chipCurrent = 0.5; // FIXME: hard-wired number
  double chipVoltage = 2.4; // FIXME: hard-wired number
  double poweringLoss = 0.2; // FIXME: hard-wired number
  double lossInCable = 0.1; // FIXME: hard-wired number
  double cableLen = 3.0; // FIXME: hard-wired number
 
  double moduleCurrent = chipCurrent * nChipsPerModule; // chips are powered in parallel inside a pixel module
  double moduleVoltage = chipVoltage;
 
  int nGroups = 1;
  int nModules = nModulesPerStave;
 
  if (nModulesPerStave > max_SP_group_size) {
    nGroups = nModulesPerStave / max_SP_group_size;
    if (nModulesPerStave % max_SP_group_size != 0) nGroups++;
    nModules =  max_SP_group_size;
    msg << MSG::DEBUG  << "Using " << nGroups << " powering groups with " << max_SP_group_size << " modules each" << endl;
  }
 
  int lvGauge = computeLVGaugeSerial( type, part, layerNumber, 
                      nModules, moduleCurrent, moduleVoltage,
                      poweringLoss, lossInCable, cableLen,
                                      msg);
 
  std::vector<int> lvg( nGroups, lvGauge);
  return StaveServices( type, part, layerNumber, nHV, nDCS, nData, lvg);
}

◆ computeLVGaugeSerial()

int ComputeStaveServices::computeLVGaugeSerial	(	DetType::Type	type,
		DetType::Part	part,
		int	layerNumber,
		int	nModules,
		double	moduleCurrent,
		double	moduleVoltage,
		double	poweringLoss,
		double	lossInCable,
		double	cableLen,
		MsgStream &	msg ) const

Definition at line 92 of file ComputeStaveServices.cxx.

{
  /*
  cout << "computeLVGaugeSerial: nModules = " << nModules
       << " moduleCurrent " << moduleCurrent
       << " moduleVoltage " << moduleVoltage
       << " poweringLoss " << poweringLoss
       << " lossInCable " << lossInCable
       << " cableLen " << cableLen 
       << endl;
  */
  // serial powering
  double cableCurrent = moduleCurrent;
  double staveVoltage = moduleVoltage * nModules / (1.-poweringLoss);
  double stavePower = cableCurrent*staveVoltage;
  double cablePowerDissipation = stavePower * lossInCable;
  if (cablePowerDissipation < 2.) cablePowerDissipation = 2.;  // we can always accept 2 W power loss in cable
 
  double cableResistivity = cablePowerDissipation / (cableCurrent*cableCurrent);
  double resistivityPerMeter = cableResistivity / (2*cableLen);
 
  int gauge = ccaw::closestResistivityCcawGauge( resistivityPerMeter);
 
  msg << MSG::DEBUG  << DetType::name( type, part) << " layer " << layerNumber
                     << " SP loop power " << stavePower << " [W], current " << moduleCurrent 
    // << " [A], cablePowerLoss " << cablePowerDissipation 
          << " [W], desired resistivity " << resistivityPerMeter 
          << " [Ohm/m], closest gauge " << gauge << endl;
 
  return gauge;
}