/** Initialize unit conversion helper * This method is interface to internal initialize method, which actually takes all parameters UnitConversion helper needs from * targetWSDescr class * @param targetWSDescr -- the class which contains all information about target workspace including energy transfer mode, number of dimensions, input workspace etc. * @param unitsTo -- the ID of the units conversion helper would help to convert to * @param forceViaTOF -- force to perform unit conversion via TOF even if quick conversion exist (by default, false) * */ void UnitsConversionHelper::initialize(const MDWSDescription &targetWSDescr, const std::string &unitsTo, bool forceViaTOF) { // obtain input workspace units API::MatrixWorkspace_const_sptr inWS2D = targetWSDescr.getInWS(); if (!inWS2D) throw(std::runtime_error("UnitsConversionHelper::initialize Should not be " "able to call this function when workpsace is " "undefined")); API::NumericAxis *pAxis = dynamic_cast<API::NumericAxis *>(inWS2D->getAxis(0)); if (!pAxis) throw(std::invalid_argument( "Cannot retrieve numeric X axis from the input workspace: " + inWS2D->name())); std::string unitsFrom = inWS2D->getAxis(0)->unit()->unitID(); // get detectors positions and other data needed for units conversion: if (!(targetWSDescr.m_PreprDetTable)) throw std::runtime_error("MDWSDescription does not have a detector table"); int Emode = (int)targetWSDescr.getEMode(); this->initialize(unitsFrom, unitsTo, targetWSDescr.m_PreprDetTable, Emode, forceViaTOF); }
void UnitsConversionHelper::initialize(const MDWSDescription &TWSD, const std::string &units_to) { // obtain input workspace units API::MatrixWorkspace_const_sptr inWS2D = TWSD.getInWS(); if(!inWS2D.get()){ throw(std::logic_error("UnitsConversionHelper::initialize Should not be able to call this function when workpsace is undefined")); } API::NumericAxis *pAxis = dynamic_cast<API::NumericAxis *>(inWS2D->getAxis(0)); if(!pAxis){ std::string ERR = "can not retrieve numeric X axis from the input workspace: "+inWS2D->name(); throw(std::invalid_argument(ERR)); } pSourceWSUnit = inWS2D->getAxis(0)->unit(); if(!pSourceWSUnit){ throw(std::logic_error(" can not retrieve source workspace units from the source workspace's numeric axis")); } // Check how input workspace units relate to the units requested UnitCnvrsn = analyzeUnitsConversion(pSourceWSUnit->unitID(),units_to); // get units class, requested by ChildAlgorithm pTargetUnit = Kernel::UnitFactory::Instance().create(units_to); if(!pTargetUnit){ throw(std::logic_error(" can not retrieve target unit from the units factory")); } // get detectors positions and other data needed for units conversion: pTwoTheta = &(TWSD.getDetectors()->getTwoTheta()); pL2 = &(TWSD.getDetectors()->getL2()); L1 = TWSD.getDetectors()->getL1(); // get efix efix = TWSD.getEi(); emode = (int)TWSD.getEMode(); }
/** function initalizes all variables necessary for converting workspace * variables into MD variables in ModQ (elastic/inelastic) cases */ void MDTransfQ3D::initialize(const MDWSDescription &ConvParams) { m_pEfixedArray = NULL; m_pDetMasks = NULL; //********** Generic part of initialization, common for elastic and inelastic // modes: // get transformation matrix (needed for CrystalAsPoder mode) m_RotMat = ConvParams.getTransfMatrix(); if (!ConvParams.m_PreprDetTable) throw(std::runtime_error("The detectors have not been preprocessed but " "they have to before running initialize")); // get pointer to the positions of the preprocessed detectors std::vector<Kernel::V3D> const &DetDir = ConvParams.m_PreprDetTable->getColVector<Kernel::V3D>("DetDirections"); m_DetDirecton = &DetDir[0]; // // get min and max values defined by the algorithm. ConvParams.getMinMax(m_DimMin, m_DimMax); // get additional coordinates which are m_AddDimCoordinates = ConvParams.getAddCoord(); //************ specific part of the initialization, dependent on emode: m_Emode = ConvParams.getEMode(); m_NMatrixDim = getNMatrixDimensions(m_Emode); if (m_Emode == Kernel::DeltaEMode::Direct || m_Emode == Kernel::DeltaEMode::Indirect) { // energy needed in inelastic case m_Ei = ConvParams.m_PreprDetTable->getLogs()->getPropertyValueAsType<double>( "Ei"); // the wave vector of incident neutrons; m_Ki = sqrt(m_Ei / PhysicalConstants::E_mev_toNeutronWavenumberSq); m_pEfixedArray = NULL; if (m_Emode == (int)Kernel::DeltaEMode::Indirect) m_pEfixedArray = ConvParams.m_PreprDetTable->getColDataArray<float>("eFixed"); } else { if (m_Emode != Kernel::DeltaEMode::Elastic) throw(std::runtime_error("MDTransfQ3D::initialize::Unknown or " "unsupported energy conversion mode")); // check if we need to calculate Lorentz corrections and if we do, prepare // values for their precalculation: m_isLorentzCorrected = ConvParams.isLorentsCorrections(); if (m_isLorentzCorrected) { auto &TwoTheta = ConvParams.m_PreprDetTable->getColVector<double>("TwoTheta"); SinThetaSq.resize(TwoTheta.size()); for (size_t i = 0; i < TwoTheta.size(); i++) { double sth = sin(0.5 * TwoTheta[i]); SinThetaSq[i] = sth * sth; } m_SinThetaSqArray = &SinThetaSq[0]; if (!m_SinThetaSqArray) throw(std::runtime_error("MDTransfQ3D::initialize::Uninitilized " "Sin(Theta)^2 array for calculating Lorentz " "corrections")); } } // use detectors masks untill signals are masked by 0 instead of NaN m_pDetMasks = ConvParams.m_PreprDetTable->getColDataArray<int>("detMask"); }
/** function initializes all variables necessary for converting workspace * variables into MD variables in ModQ (elastic/inelastic) cases */ void MDTransfModQ::initialize(const MDWSDescription &ConvParams) { //********** Generic part of initialization, common for elastic and inelastic // modes: // pHost = &Conv; // get transformation matrix (needed for CrystalAsPoder mode) m_RotMat = ConvParams.getTransfMatrix(); m_pEfixedArray = nullptr; if (!ConvParams.m_PreprDetTable) throw(std::runtime_error("The detectors have not been preprocessed but " "they have to before running initialize")); // get pointer to the positions of the detectors std::vector<Kernel::V3D> const &DetDir = ConvParams.m_PreprDetTable->getColVector<Kernel::V3D>("DetDirections"); m_DetDirecton = &DetDir[0]; // // get min and max values defined by the algorithm. ConvParams.getMinMax(m_DimMin, m_DimMax); // m_DimMin/max here are momentums and they are verified on momentum squared // base if (m_DimMin[0] < 0) m_DimMin[0] = 0; if (m_DimMax[0] < 0) m_DimMax[0] = 0; // m_DimMin here is a momentum and it is verified on momentum squared base m_DimMin[0] *= m_DimMin[0]; m_DimMax[0] *= m_DimMax[0]; if (std::fabs(m_DimMin[0] - m_DimMax[0]) < FLT_EPSILON || m_DimMax[0] < m_DimMin[0]) { std::string ERR = "ModQ coordinate transformation: Min Q^2 value: " + boost::lexical_cast<std::string>(m_DimMin[0]) + " is more or equal then Max Q^2 value: " + boost::lexical_cast<std::string>(m_DimMax[0]); throw(std::invalid_argument(ERR)); } m_AddDimCoordinates = ConvParams.getAddCoord(); //************ specific part of the initialization, dependent on emode: m_Emode = ConvParams.getEMode(); m_NMatrixDim = getNMatrixDimensions(m_Emode); if (m_Emode == Kernel::DeltaEMode::Direct || m_Emode == Kernel::DeltaEMode::Indirect) { // energy needed in inelastic case volatile double Ei = ConvParams.m_PreprDetTable->getLogs()->getPropertyValueAsType<double>( "Ei"); m_Ei = Ei; if (Ei != m_Ei) // Ei is NaN, try Efixed, but the value should be overridden later { try { m_Ei = ConvParams.m_PreprDetTable->getLogs() ->getPropertyValueAsType<double>("eFixed"); } catch (...) { } } // the wave vector of incident neutrons; m_Ki = sqrt(m_Ei / PhysicalConstants::E_mev_toNeutronWavenumberSq); m_pEfixedArray = nullptr; if (m_Emode == static_cast<int>(Kernel::DeltaEMode::Indirect)) m_pEfixedArray = ConvParams.m_PreprDetTable->getColDataArray<float>("eFixed"); } else if (m_Emode != Kernel::DeltaEMode::Elastic) throw(std::invalid_argument( "MDTransfModQ::initialize::Unknown energy conversion mode")); m_pDetMasks = ConvParams.m_PreprDetTable->getColDataArray<int>("detMask"); }