int MaskPeaksWorkspace::findPixelID(std::string bankName, int col, int row) {
Geometry::Instrument_const_sptr Iptr = m_inputW->getInstrument();
boost::shared_ptr<const IComponent> parent =
Iptr->getComponentByName(bankName);
if (parent->type().compare("RectangularDetector") == 0) {
boost::shared_ptr<const RectangularDetector> RDet =
boost::dynamic_pointer_cast<const RectangularDetector>(parent);
boost::shared_ptr<Detector> pixel = RDet->getAtXY(col, row);
return pixel->getID();
} else {
std::string bankName0 = bankName;
// Only works for WISH
bankName0.erase(0, 4);
std::ostringstream pixelString;
pixelString << Iptr->getName() << "/" << bankName0 << "/" << bankName
<< "/tube" << std::setw(3) << std::setfill('0') << col
<< "/pixel" << std::setw(4) << std::setfill('0') << row;
boost::shared_ptr<const Geometry::IComponent> component =
Iptr->getComponentByName(pixelString.str());
boost::shared_ptr<const Detector> pixel =
boost::dynamic_pointer_cast<const Detector>(component);
return pixel->getID();
}
}
/**
* Get position in space of a componentName
*/
V3D LoadILLSANS::getComponentPosition(const std::string &componentName) {
Geometry::Instrument_const_sptr instrument =
m_localWorkspace->getInstrument();
Geometry::IComponent_const_sptr component =
instrument->getComponentByName(componentName);
return component->getPos();
}
bool CentroidPeaks::edgePixel(std::string bankName, int col, int row,
int Edge) {
if (bankName.compare("None") == 0)
return false;
Geometry::Instrument_const_sptr Iptr = inWS->getInstrument();
boost::shared_ptr<const IComponent> parent =
Iptr->getComponentByName(bankName);
if (parent->type().compare("RectangularDetector") == 0) {
boost::shared_ptr<const RectangularDetector> RDet =
boost::dynamic_pointer_cast<const RectangularDetector>(parent);
return col < Edge || col >= (RDet->xpixels() - Edge) || row < Edge ||
row >= (RDet->ypixels() - Edge);
} else {
std::vector<Geometry::IComponent_const_sptr> children;
boost::shared_ptr<const Geometry::ICompAssembly> asmb =
boost::dynamic_pointer_cast<const Geometry::ICompAssembly>(parent);
asmb->getChildren(children, false);
boost::shared_ptr<const Geometry::ICompAssembly> asmb2 =
boost::dynamic_pointer_cast<const Geometry::ICompAssembly>(children[0]);
std::vector<Geometry::IComponent_const_sptr> grandchildren;
asmb2->getChildren(grandchildren, false);
int NROWS = static_cast<int>(grandchildren.size());
int NCOLS = static_cast<int>(children.size());
// Wish pixels and tubes start at 1 not 0
return col - 1 < Edge || col - 1 >= (NCOLS - Edge) || row - 1 < Edge ||
row - 1 >= (NROWS - Edge);
}
return false;
}
void LoadILLIndirect::moveComponent(const std::string &componentName,
double twoTheta, double offSet) {
try {
Geometry::Instrument_const_sptr instrument =
m_localWorkspace->getInstrument();
Geometry::IComponent_const_sptr component =
instrument->getComponentByName(componentName);
double r, theta, phi, newTheta, newR;
V3D oldPos = component->getPos();
oldPos.getSpherical(r, theta, phi);
newTheta = twoTheta;
newR = offSet;
V3D newPos;
newPos.spherical(newR, newTheta, phi);
// g_log.debug() << tube->getName() << " : t = " << theta << " ==> t = " <<
// newTheta << "\n";
Geometry::ParameterMap &pmap = m_localWorkspace->instrumentParameters();
Geometry::ComponentHelper::moveComponent(
*component, pmap, newPos, Geometry::ComponentHelper::Absolute);
} catch (Mantid::Kernel::Exception::NotFoundError &) {
throw std::runtime_error("Error when trying to move the " + componentName +
" : NotFoundError");
} catch (std::runtime_error &) {
throw std::runtime_error("Error when trying to move the " + componentName +
" : runtime_error");
}
}
V3D LoadHelper::getComponentPosition(API::MatrixWorkspace_sptr ws, const std::string &componentName)
{
try
{
Geometry::Instrument_const_sptr instrument = ws->getInstrument();
Geometry::IComponent_const_sptr component = instrument->getComponentByName(componentName);
V3D pos = component->getPos();
return pos;
} catch (Mantid::Kernel::Exception::NotFoundError&)
{
throw std::runtime_error("Error when trying to move the " + componentName + " : NotFoundError");
}
}
/** Extract a component's detectors and return it within detectors array
* It is a generalized version of bankToDetectors()
*
* @param componentnames -- vector of component names to process
* @param detectors -- vector of detector ids, which belongs to components
*provided as input.
*/
void LoadMask::componentToDetectors(
const std::vector<std::string> &componentnames,
std::vector<detid_t> &detectors) {
Geometry::Instrument_const_sptr minstrument = m_maskWS->getInstrument();
for (auto &componentname : componentnames) {
g_log.debug() << "Component name = " << componentname << '\n';
// a) get component
Geometry::IComponent_const_sptr component =
minstrument->getComponentByName(componentname);
if (component)
g_log.debug() << "Component ID = " << component->getComponentID() << '\n';
else {
// A non-exiting component. Ignore
g_log.warning() << "Component " << componentname << " does not exist!\n";
continue;
}
// b) component -> component assembly --> children (more than detectors)
boost::shared_ptr<const Geometry::ICompAssembly> asmb =
boost::dynamic_pointer_cast<const Geometry::ICompAssembly>(component);
std::vector<Geometry::IComponent_const_sptr> children;
asmb->getChildren(children, true);
g_log.debug() << "Number of Children = " << children.size() << '\n';
size_t numdets(0);
detid_t id_min(std::numeric_limits<Mantid::detid_t>::max());
detid_t id_max(0);
for (const auto &child : children) {
// c) convert component to detector
Geometry::IDetector_const_sptr det =
boost::dynamic_pointer_cast<const Geometry::IDetector>(child);
if (det) {
detid_t detid = det->getID();
detectors.push_back(detid);
numdets++;
if (detid < id_min)
id_min = detid;
if (detid > id_max)
id_max = detid;
}
}
g_log.debug() << "Number of Detectors in Children = " << numdets
<< " Range = " << id_min << ", " << id_max << '\n';
} // for component
}
void PoldiBasicChopper::loadConfiguration(
Geometry::Instrument_const_sptr poldiInstrument) {
Geometry::ICompAssembly_const_sptr chopperGroup =
boost::dynamic_pointer_cast<const Geometry::ICompAssembly>(
poldiInstrument->getComponentByName(std::string("chopper")));
size_t numberOfSlits = chopperGroup->nelements();
std::vector<double> slitPositions(numberOfSlits);
for (size_t i = 0; i < numberOfSlits; ++i) {
slitPositions[i] =
chopperGroup->getChild(static_cast<const int>(i))->getPos().X();
}
double distance = chopperGroup->getPos().norm() * 1000.0;
double t0 = chopperGroup->getNumberParameter("t0").front();
double t0const = chopperGroup->getNumberParameter("t0_const").front();
initializeFixedParameters(slitPositions, distance, t0, t0const);
}
/**
@param ws Name of workspace containing peaks
@param bankName Name of bank containing peak
@param col Column number containing peak
@param row Row number containing peak
@param Edge Number of edge points for each bank
@return True if peak is on edge
*/
bool OptimizeLatticeForCellType::edgePixel(PeaksWorkspace_sptr ws,
std::string bankName, int col,
int row, int Edge) {
if (bankName.compare("None") == 0)
return false;
Geometry::Instrument_const_sptr Iptr = ws->getInstrument();
boost::shared_ptr<const IComponent> parent =
Iptr->getComponentByName(bankName);
if (parent->type().compare("RectangularDetector") == 0) {
boost::shared_ptr<const RectangularDetector> RDet =
boost::dynamic_pointer_cast<const RectangularDetector>(parent);
return col < Edge || col >= (RDet->xpixels() - Edge) || row < Edge ||
row >= (RDet->ypixels() - Edge);
} else {
std::vector<Geometry::IComponent_const_sptr> children;
boost::shared_ptr<const Geometry::ICompAssembly> asmb =
boost::dynamic_pointer_cast<const Geometry::ICompAssembly>(parent);
asmb->getChildren(children, false);
int startI = 1;
if (children[0]->getName() == "sixteenpack") {
startI = 0;
parent = children[0];
children.clear();
boost::shared_ptr<const Geometry::ICompAssembly> asmb =
boost::dynamic_pointer_cast<const Geometry::ICompAssembly>(parent);
asmb->getChildren(children, false);
}
boost::shared_ptr<const Geometry::ICompAssembly> asmb2 =
boost::dynamic_pointer_cast<const Geometry::ICompAssembly>(children[0]);
std::vector<Geometry::IComponent_const_sptr> grandchildren;
asmb2->getChildren(grandchildren, false);
int NROWS = static_cast<int>(grandchildren.size());
int NCOLS = static_cast<int>(children.size());
// Wish pixels and tubes start at 1 not 0
return col - startI < Edge || col - startI >= (NCOLS - Edge) ||
row - startI < Edge || row - startI >= (NROWS - Edge);
}
return false;
}
void LoadHelper::rotateComponent(API::MatrixWorkspace_sptr ws, const std::string &componentName,
const Kernel::Quat & rot)
{
try
{
Geometry::Instrument_const_sptr instrument = ws->getInstrument();
Geometry::IComponent_const_sptr component = instrument->getComponentByName(componentName);
//g_log.debug() << tube->getName() << " : t = " << theta << " ==> t = " << newTheta << "\n";
Geometry::ParameterMap& pmap = ws->instrumentParameters();
Geometry::ComponentHelper::rotateComponent(*component, pmap, rot,
Geometry::ComponentHelper::Absolute);
} catch (Mantid::Kernel::Exception::NotFoundError&)
{
throw std::runtime_error("Error when trying to move the " + componentName + " : NotFoundError");
} catch (std::runtime_error &)
{
throw std::runtime_error("Error when trying to move the " + componentName + " : runtime_error");
}
}
/**
* Cache frequently accessed values
* @param instrument : The instrument for this run
* @param detID : The det ID for this observation
*/
void CachedExperimentInfo::initCaches(
const Geometry::Instrument_const_sptr &instrument, const detid_t detID) {
// Throws if detector does not exist
// Takes into account possible detector mapping
IDetector_const_sptr det = m_exptInfo.getDetectorByID(detID);
// Instrument distances
boost::shared_ptr<const ReferenceFrame> refFrame =
instrument->getReferenceFrame();
m_beam = refFrame->pointingAlongBeam();
m_up = refFrame->pointingUp();
m_horiz = refFrame->pointingHorizontal();
IComponent_const_sptr source = instrument->getSource();
IComponent_const_sptr sample = instrument->getSample();
IComponent_const_sptr aperture =
instrument->getComponentByName("aperture", 1);
if (!aperture) {
throw std::invalid_argument(
"No component named \"aperture\" found in instrument.");
}
IObjComponent_const_sptr firstChopper = instrument->getChopperPoint(0);
const Kernel::V3D samplePos = sample->getPos();
const Kernel::V3D beamDir = samplePos - source->getPos();
// Cache
m_twoTheta = det->getTwoTheta(samplePos, beamDir);
m_phi = det->getPhi();
m_modToChop = firstChopper->getDistance(*source);
m_apertureToChop = firstChopper->getDistance(*aperture);
m_chopToSample = sample->getDistance(*firstChopper);
m_sampleToDet = det->getDistance(*sample);
// Aperture
Geometry::BoundingBox apertureBox;
aperture->getBoundingBox(apertureBox);
if (apertureBox.isNull()) {
throw std::invalid_argument("CachedExperimentInfo::initCaches - Aperture "
"has no bounding box, cannot sample from it");
}
m_apertureSize.first = apertureBox.maxPoint()[0] - apertureBox.minPoint()[0];
m_apertureSize.second = apertureBox.maxPoint()[1] - apertureBox.minPoint()[1];
// Sample volume
const API::Sample &sampleDescription = m_exptInfo.sample();
const Geometry::Object &shape = sampleDescription.getShape();
m_sampleWidths = shape.getBoundingBox().width();
// Detector volume
// Make sure it encompasses all possible detectors
det->getBoundingBox(m_detBox);
if (m_detBox.isNull()) {
throw std::invalid_argument("CachedExperimentInfo::initCaches - Detector "
"has no bounding box, cannot sample from it. "
"ID:" +
boost::lexical_cast<std::string>(det->getID()));
}
const double rad2deg = 180. / M_PI;
const double thetaInDegs = twoTheta() * rad2deg;
const double phiInDegs = phi() * rad2deg;
m_gonimeter = new Goniometer;
m_gonimeter->makeUniversalGoniometer();
m_gonimeter->setRotationAngle("phi", thetaInDegs);
m_gonimeter->setRotationAngle("chi", phiInDegs);
m_sampleToDetMatrix =
m_exptInfo.sample().getOrientedLattice().getU() * m_gonimeter->getR();
// EFixed
m_efixed = m_exptInfo.getEFixed(det);
}
std::string LoadIsawPeaks::ApplyCalibInfo(std::ifstream & in, std::string startChar,Geometry::Instrument_const_sptr instr_old, Geometry::Instrument_const_sptr instr,
double &T0)
{
ParameterMap_sptr parMap1= instr_old->getParameterMap();
ParameterMap_sptr parMap= instr->getParameterMap();
while( in.good() && (startChar.size() <1 || startChar !="7") )
{
readToEndOfLine( in, true);
startChar = getWord(in, false);
}
if( !(in.good()))
{
//g_log.error()<<"Peaks file has no time shift and L0 info"<<std::endl;
throw std::invalid_argument("Peaks file has no time shift and L0 info");
}
std::string L1s= getWord(in,false);
std::string T0s =getWord(in, false);
if( L1s.length() < 1 || T0s.length() < 1)
{
g_log.error()<<"Missing L1 or Time offset"<<std::endl;
throw std::invalid_argument("Missing L1 or Time offset");
}
double L1;
try
{
std::istringstream iss( L1s+" "+T0s, std::istringstream::in);
iss>>L1;
iss>>T0;
V3D sampPos=instr->getSample()->getPos();
SCDCalibratePanels::FixUpSourceParameterMap(instr, L1/100, sampPos,parMap1);
}catch(...)
{
g_log.error()<<"Invalid L1 or Time offset"<<std::endl;
throw std::invalid_argument("Invalid L1 or Time offset");
}
readToEndOfLine( in, true);
startChar = getWord(in , false);
while( in.good() && (startChar.size() <1 || startChar !="5") )
{
readToEndOfLine( in, true);
startChar = getWord(in, false);
}
if( !(in.good()))
{
g_log.error()<<"Peaks file has no detector panel info"<<std::endl;
throw std::invalid_argument("Peaks file has no detector panel info");
}
while( startChar =="5")
{
std::string line;
for( int i=0; i<16;i++)
{
std::string s= getWord(in, false);
if( s.size() < 1)
{
g_log.error()<<"Not enough info to describe panel "<<std::endl;
throw std::length_error("Not enough info to describe panel ");
}
line +=" "+s;;
}
readToEndOfLine(in, true);
startChar = getWord( in, false);// blank lines ?? and # lines ignore
std::istringstream iss( line, std::istringstream::in);
int bankNum,nrows,ncols;
double width,height,depth,detD,Centx,Centy,Centz,Basex,Basey,Basez,
Upx,Upy,Upz;
try
{
iss>>bankNum>>nrows>>ncols>>width>>height>>depth>>detD
>>Centx>>Centy>>Centz>>Basex>>Basey>>Basez
>>Upx>>Upy>>Upz;
}catch(...)
{
g_log.error()<<"incorrect type of data for panel "<<std::endl;
throw std::length_error("incorrect type of data for panel ");
}
std::string SbankNum = boost::lexical_cast<std::string>(bankNum);
std::string bankName = "bank"+SbankNum;
boost::shared_ptr<const Geometry::IComponent> bank =instr_old->getComponentByName( bankName );
if( !bank)
{
g_log.error()<<"There is no bank "<< bankName<<" in the instrument"<<std::endl;
throw std::length_error("There is no bank "+ bankName+" in the instrument");
}
V3D dPos= V3D(Centx,Centy,Centz)/100.0- bank->getPos();
V3D Base(Basex,Basey,Basez), Up(Upx,Upy,Upz);
V3D ToSamp =Base.cross_prod(Up);
Base.normalize();
Up.normalize();
ToSamp.normalize();
Quat thisRot(Base,Up,ToSamp);
Quat bankRot(bank->getRotation());
bankRot.inverse();
Quat dRot = thisRot*bankRot;
boost::shared_ptr< const Geometry::RectangularDetector>bankR= boost::dynamic_pointer_cast
<const Geometry::RectangularDetector>( bank);
double DetWScale = 1, DetHtScale = 1;
if( bank)
{
DetWScale = width/bankR->xsize()/100;
DetHtScale = height/bankR->ysize()/100;
}
std::vector<std::string> bankNames;
bankNames.push_back(bankName);
SCDCalibratePanels::FixUpBankParameterMap(bankNames,instr, dPos,
dRot,DetWScale,DetHtScale , parMap1, false);
}
return startChar;
}
